Use more explicit imports

diff --git a/rt/gc/cdgc/bits.d b/rt/gc/cdgc/bits.d
index 275beb622db188445808a8870392d1fff1b32ecd..a2dbb50c9bcd02c8049ac35855bc8c8baaf04fb8 100644 (file)
--- a/rt/gc/cdgc/bits.d
+++ b/rt/gc/cdgc/bits.d
@@ -26,7 +26,7 @@
 
 module rt.gc.cdgc.bits;
 
 
 module rt.gc.cdgc.bits;
 

-import rt.gc.cdgc.libc;
+import libc = rt.gc.cdgc.libc;

 
 private extern (C) void onOutOfMemoryError();
 
 
 private extern (C) void onOutOfMemoryError();
 


@@ -63,7 +63,7 @@ struct GCBits
     {
         if (data)
         {
     {
         if (data)
         {

-            free(data);
+            libc.free(data);

             data = null;
         }
     }
             data = null;
         }
     }


@@ -80,7 +80,7 @@ struct GCBits
     {
         this.nbits = nbits;
         nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT;
     {
         this.nbits = nbits;
         nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT;

-        data = cast(uint*)calloc(nwords + 2, uint.sizeof);
+        data = cast(uint*)libc.calloc(nwords + 2, uint.sizeof);

         if (!data)
             onOutOfMemoryError();
     }
         if (!data)
             onOutOfMemoryError();
     }


@@ -157,7 +157,7 @@ struct GCBits
             for (;d1!=dEnd;++d1)
                 *d1=0u;
         } else {
             for (;d1!=dEnd;++d1)
                 *d1=0u;
         } else {

-            memset(data + 1, 0, nwords * uint.sizeof);
+            libc.memset(data + 1, 0, nwords * uint.sizeof);

         }
     }
 
         }
     }
 


@@ -173,7 +173,7 @@ struct GCBits
             for (;d1!=dEnd;++d1,++d2)
                 *d1=*d2;
         } else {
             for (;d1!=dEnd;++d1,++d2)
                 *d1=*d2;
         } else {

-            memcpy(data + 1, f.data + 1, nwords * uint.sizeof);
+            libc.memcpy(data + 1, f.data + 1, nwords * uint.sizeof);

         }
     }
 
         }
     }
 

diff --git a/rt/gc/cdgc/gc.d b/rt/gc/cdgc/gc.d
index 1c9905524d5153926f3048045a55308ea027d85c..f73bcb02577f0517e2817f941ede902d79d7d4bc 100644 (file)
--- a/rt/gc/cdgc/gc.d
+++ b/rt/gc/cdgc/gc.d
@@ -46,10 +46,10 @@ version = STACKGROWSDOWN;       // growing the stack means subtracting from the
 
 /***************************************************/
 
 
 /***************************************************/
 

-import rt.gc.cdgc.bits;
-import rt.gc.cdgc.stats;
-import rt.gc.cdgc.alloc;
-import rt.gc.cdgc.libc;
+import rt.gc.cdgc.bits: GCBits;
+import rt.gc.cdgc.stats: GCStats;
+import alloc = rt.gc.cdgc.alloc;
+import libc = rt.gc.cdgc.libc;

 
 
 version (GNU)
 
 
 version (GNU)


@@ -58,7 +58,7 @@ version (GNU)
     //      subdirectory is elsewhere.  Instead, perhaps the functions
     //      could be declared directly or some other resolution could
     //      be found.
     //      subdirectory is elsewhere.  Instead, perhaps the functions
     //      could be declared directly or some other resolution could
     //      be found.

-    import gcc.builtins; // for __builtin_unwind_init
+    static import gcc.builtins; // for __builtin_unwind_int

 }
 
 
 }
 
 


@@ -145,7 +145,7 @@ debug (LOGGING)
         void Dtor()
         {
             if (data)
         void Dtor()
         {
             if (data)

-                .free(data);
+                libc.free(data);

             data = null;
         }
 
             data = null;
         }
 


@@ -158,18 +158,18 @@ debug (LOGGING)
                 assert(dim + nentries <= allocdim);
                 if (!data)
                 {
                 assert(dim + nentries <= allocdim);
                 if (!data)
                 {

-                    data = cast(Log*) .malloc(allocdim * Log.sizeof);
+                    data = cast(Log*) libc.malloc(allocdim * Log.sizeof);

                     if (!data && allocdim)
                         onOutOfMemoryError();
                 }
                 else
                 {   Log *newdata;
 
                     if (!data && allocdim)
                         onOutOfMemoryError();
                 }
                 else
                 {   Log *newdata;
 

-                    newdata = cast(Log*) .malloc(allocdim * Log.sizeof);
+                    newdata = cast(Log*) libc.malloc(allocdim * Log.sizeof);

                     if (!newdata && allocdim)
                         onOutOfMemoryError();
                     if (!newdata && allocdim)
                         onOutOfMemoryError();

-                    .memcpy(newdata, data, dim * Log.sizeof);
-                    .free(data);
+                    libc.memcpy(newdata, data, dim * Log.sizeof);
+                    libc.free(data);

                     data = newdata;
                 }
             }
                     data = newdata;
                 }
             }


@@ -184,7 +184,7 @@ debug (LOGGING)
 
         void remove(size_t i)
         {
 
         void remove(size_t i)
         {

-            .memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);
+            libc.memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);

             dim--;
         }
 
             dim--;
         }
 


@@ -204,7 +204,7 @@ debug (LOGGING)
         {
             reserve(from.dim - dim);
             assert(from.dim <= allocdim);
         {
             reserve(from.dim - dim);
             assert(from.dim <= allocdim);

-            .memcpy(data, from.data, from.dim * Log.sizeof);
+            libc.memcpy(data, from.data, from.dim * Log.sizeof);

             dim = from.dim;
         }
     }
             dim = from.dim;
         }
     }


@@ -235,7 +235,7 @@ class GC
     void initialize()
     {
         gcLock = GCLock.classinfo;
     void initialize()
     {
         gcLock = GCLock.classinfo;

-        gcx = cast(Gcx*) .calloc(1, Gcx.sizeof);
+        gcx = cast(Gcx*) libc.calloc(1, Gcx.sizeof);

         if (!gcx)
             onOutOfMemoryError();
         gcx.initialize();
         if (!gcx)
             onOutOfMemoryError();
         gcx.initialize();


@@ -248,7 +248,7 @@ class GC
         if (gcx)
         {
             gcx.Dtor();
         if (gcx)
         {
             gcx.Dtor();

-            .free(gcx);
+            libc.free(gcx);

             gcx = null;
         }
     }
             gcx = null;
         }
     }


@@ -481,9 +481,9 @@ class GC
             // Return next item from free list
             gcx.bucket[bin] = (cast(List*)p).next;
             if( !(bits & BlkAttr.NO_SCAN) )
             // Return next item from free list
             gcx.bucket[bin] = (cast(List*)p).next;
             if( !(bits & BlkAttr.NO_SCAN) )

-                .memset(p + size, 0, binsize[bin] - size);
+                libc.memset(p + size, 0, binsize[bin] - size);

             //debug(PRINTF) printf("\tmalloc => %x\n", p);
             //debug(PRINTF) printf("\tmalloc => %x\n", p);

-            debug (MEMSTOMP) .memset(p, 0xF0, size);
+            debug (MEMSTOMP) libc.memset(p, 0xF0, size);

         }
         else
         {
         }
         else
         {


@@ -537,7 +537,7 @@ class GC
 
         //debug(PRINTF) printf("calloc: %x len %d\n", p, len);
         void *p = mallocNoSync(size, bits);
 
         //debug(PRINTF) printf("calloc: %x len %d\n", p, len);
         void *p = mallocNoSync(size, bits);

-        .memset(p, 0, size);
+        libc.memset(p, 0, size);

         return p;
     }
 
         return p;
     }
 


@@ -607,7 +607,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);

-                    .memcpy(p2, p, size);
+                    libc.memcpy(p2, p, size);

                     p = p2;
                 }
             }
                     p = p2;
                 }
             }


@@ -628,7 +628,8 @@ class GC
                     {   // Shrink in place
                         synchronized (gcLock)
                         {
                     {   // Shrink in place
                         synchronized (gcLock)
                         {

-                            debug (MEMSTOMP) .memset(p + size, 0xF2, psize - size);
+                            debug (MEMSTOMP)
+                                libc.memset(p + size, 0xF2, psize - size);

                             pool.freePages(pagenum + newsz, psz - newsz);
                         }
                         return p;
                             pool.freePages(pagenum + newsz, psz - newsz);
                         }
                         return p;


@@ -642,8 +643,11 @@ class GC
                             {
                                 if (i == pagenum + newsz)
                                 {
                             {
                                 if (i == pagenum + newsz)
                                 {

-                                    debug (MEMSTOMP) .memset(p + psize, 0xF0, size - psize);
-                                    .memset(&pool.pagetable[pagenum + psz], B_PAGEPLUS, newsz - psz);
+                                    debug (MEMSTOMP)
+                                        libc.memset(p + psize, 0xF0,
+                                                size - psize);
+                                    libc.memset(&pool.pagetable[pagenum + psz],
+                                            B_PAGEPLUS, newsz - psz);

                                     return p;
                                 }
                                 if (i == pool.npages)
                                     return p;
                                 }
                                 if (i == pool.npages)


@@ -683,7 +687,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);

-                    .memcpy(p2, p, size);
+                    libc.memcpy(p2, p, size);

                     p = p2;
                 }
             }
                     p = p2;
                 }
             }


@@ -754,8 +758,9 @@ class GC
         }
         if (sz < minsz)
             return 0;
         }
         if (sz < minsz)
             return 0;

-        debug (MEMSTOMP) .memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
-        .memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
+        debug (MEMSTOMP)
+            libc.memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
+        libc.memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);

         gcx.p_cache = null;
         gcx.size_cache = 0;
         return (psz + sz) * PAGESIZE;
         gcx.p_cache = null;
         gcx.size_cache = 0;
         return (psz + sz) * PAGESIZE;


@@ -848,14 +853,14 @@ class GC
             n = pagenum;
             while (++n < pool.npages && pool.pagetable[n] == B_PAGEPLUS)
                 npages++;
             n = pagenum;
             while (++n < pool.npages && pool.pagetable[n] == B_PAGEPLUS)
                 npages++;

-            debug (MEMSTOMP) .memset(p, 0xF2, npages * PAGESIZE);
+            debug (MEMSTOMP) libc.memset(p, 0xF2, npages * PAGESIZE);

             pool.freePages(pagenum, npages);
         }
         else
         {   // Add to free list
             List *list = cast(List*)p;
 
             pool.freePages(pagenum, npages);
         }
         else
         {   // Add to free list
             List *list = cast(List*)p;
 

-            debug (MEMSTOMP) .memset(p, 0xF2, binsize[bin]);
+            debug (MEMSTOMP) libc.memset(p, 0xF2, binsize[bin]);

 
             list.next = gcx.bucket[bin];
             gcx.bucket[bin] = list;
 
             list.next = gcx.bucket[bin];
             gcx.bucket[bin] = list;


@@ -1272,7 +1277,7 @@ class GC
         size_t bsize = 0;
 
         //debug(PRINTF) printf("getStats()\n");
         size_t bsize = 0;
 
         //debug(PRINTF) printf("getStats()\n");

-        .memset(&stats, 0, GCStats.sizeof);
+        libc.memset(&stats, 0, GCStats.sizeof);

 
         for (n = 0; n < gcx.npools; n++)
         {   Pool *pool = gcx.pooltable[n];
 
         for (n = 0; n < gcx.npools; n++)
         {   Pool *pool = gcx.pooltable[n];


@@ -1369,7 +1374,7 @@ class GC
                    if (wp.reference)
                        rt_detachDisposeEvent(wp.reference, &wp.ondestroy);
                   });
                    if (wp.reference)
                        rt_detachDisposeEvent(wp.reference, &wp.ondestroy);
                   });

-            .free(wp);
+            libc.free(wp);

         }
     }
 
         }
     }
 


@@ -1491,16 +1496,16 @@ struct Gcx
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();

-            .free(pool);
+            libc.free(pool);

         }
         if (pooltable)
         }
         if (pooltable)

-            .free(pooltable);
+            libc.free(pooltable);

 
         if (roots)
 
         if (roots)

-            .free(roots);
+            libc.free(roots);

 
         if (ranges)
 
         if (ranges)

-            .free(ranges);
+            libc.free(ranges);

     }
 
 
     }
 
 


@@ -1571,12 +1576,12 @@ struct Gcx
             size_t newdim = rootdim * 2 + 16;
             void** newroots;
 
             size_t newdim = rootdim * 2 + 16;
             void** newroots;
 

-            newroots = cast(void**) .malloc(newdim * newroots[0].sizeof);
+            newroots = cast(void**) libc.malloc(newdim * newroots[0].sizeof);

             if (!newroots)
                 onOutOfMemoryError();
             if (roots)
             if (!newroots)
                 onOutOfMemoryError();
             if (roots)

-            {   .memcpy(newroots, roots, nroots * newroots[0].sizeof);
-                .free(roots);
+            {   libc.memcpy(newroots, roots, nroots * newroots[0].sizeof);
+                libc.free(roots);

             }
             roots = newroots;
             rootdim = newdim;
             }
             roots = newroots;
             rootdim = newdim;


@@ -1596,7 +1601,8 @@ struct Gcx
             if (roots[i] == p)
             {
                 nroots--;
             if (roots[i] == p)
             {
                 nroots--;

-                .memmove(roots + i, roots + i + 1, (nroots - i) * roots[0].sizeof);
+                libc.memmove(roots + i, roots + i + 1,
+                        (nroots - i) * roots[0].sizeof);

                 return;
             }
         }
                 return;
             }
         }


@@ -1616,12 +1622,12 @@ struct Gcx
             size_t newdim = rangedim * 2 + 16;
             Range *newranges;
 
             size_t newdim = rangedim * 2 + 16;
             Range *newranges;
 

-            newranges = cast(Range*) .malloc(newdim * newranges[0].sizeof);
+            newranges = cast(Range*) libc.malloc(newdim * newranges[0].sizeof);

             if (!newranges)
                 onOutOfMemoryError();
             if (ranges)
             if (!newranges)
                 onOutOfMemoryError();
             if (ranges)

-            {   .memcpy(newranges, ranges, nranges * newranges[0].sizeof);
-                .free(ranges);
+            {   libc.memcpy(newranges, ranges, nranges * newranges[0].sizeof);
+                libc.free(ranges);

             }
             ranges = newranges;
             rangedim = newdim;
             }
             ranges = newranges;
             rangedim = newdim;


@@ -1644,7 +1650,8 @@ struct Gcx
             if (ranges[i].pbot == pbot)
             {
                 nranges--;
             if (ranges[i].pbot == pbot)
             {
                 nranges--;

-                .memmove(ranges + i, ranges + i + 1, (nranges - i) * ranges[0].sizeof);
+                libc.memmove(ranges + i, ranges + i + 1,
+                        (nranges - i) * ranges[0].sizeof);

                 return;
             }
         }
                 return;
             }
         }


@@ -1910,8 +1917,8 @@ struct Gcx
                 continue;
             }
             pool.Dtor();
                 continue;
             }
             pool.Dtor();

-            .free(pool);
-            .memmove(pooltable + n,
+            libc.free(pool);
+            libc.memmove(pooltable + n,

                             pooltable + n + 1,
                             (--npools - n) * (Pool*).sizeof);
             minAddr = pooltable[0].baseAddr;
                             pooltable + n + 1,
                             (--npools - n) * (Pool*).sizeof);
             minAddr = pooltable[0].baseAddr;


@@ -1994,10 +2001,10 @@ struct Gcx
       L1:
         pool.pagetable[pn] = B_PAGE;
         if (npages > 1)
       L1:
         pool.pagetable[pn] = B_PAGE;
         if (npages > 1)

-            .memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
+            libc.memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);

         p = pool.baseAddr + pn * PAGESIZE;
         p = pool.baseAddr + pn * PAGESIZE;

-        .memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
-        debug (MEMSTOMP) .memset(p, 0xF1, size);
+        libc.memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
+        debug (MEMSTOMP) libc.memset(p, 0xF1, size);

         //debug(PRINTF) printf("\tp = %x\n", p);
         return p;
 
         //debug(PRINTF) printf("\tp = %x\n", p);
         return p;
 


@@ -2042,7 +2049,7 @@ struct Gcx
                 npages = n;
         }
 
                 npages = n;
         }
 

-        pool = cast(Pool *) .calloc(1, Pool.sizeof);
+        pool = cast(Pool *) libc.calloc(1, Pool.sizeof);

         if (pool)
         {
             pool.initialize(npages);
         if (pool)
         {
             pool.initialize(npages);


@@ -2050,7 +2057,8 @@ struct Gcx
                 goto Lerr;
 
             newnpools = npools + 1;
                 goto Lerr;
 
             newnpools = npools + 1;

-            newpooltable = cast(Pool **) .realloc(pooltable, newnpools * (Pool *).sizeof);
+            newpooltable = cast(Pool **) libc.realloc(pooltable,
+                    newnpools * (Pool *).sizeof);

             if (!newpooltable)
                 goto Lerr;
 
             if (!newpooltable)
                 goto Lerr;
 


@@ -2060,7 +2068,8 @@ struct Gcx
                 if (pool.opCmp(newpooltable[i]) < 0)
                      break;
             }
                 if (pool.opCmp(newpooltable[i]) < 0)
                      break;
             }

-            .memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * (Pool *).sizeof);
+            libc.memmove(newpooltable + i + 1, newpooltable + i,
+                    (npools - i) * (Pool *).sizeof);

             newpooltable[i] = pool;
 
             pooltable = newpooltable;
             newpooltable[i] = pool;
 
             pooltable = newpooltable;


@@ -2073,7 +2082,7 @@ struct Gcx
 
       Lerr:
         pool.Dtor();
 
       Lerr:
         pool.Dtor();

-        .free(pool);
+        libc.free(pool);

         return null;
     }
 
         return null;
     }
 


@@ -2203,7 +2212,7 @@ struct Gcx
         size_t result;
         version (GNU)
         {
         size_t result;
         version (GNU)
         {

-            __builtin_unwind_init();
+            gcc.builtins.__builtin_unwind_init();

             sp = & sp;
         }
         else version(LDC)
             sp = & sp;
         }
         else version(LDC)


@@ -2448,7 +2457,7 @@ struct Gcx
                             //debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
                             //debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 

-                            debug (MEMSTOMP) .memset(p, 0xF3, size);
+                            debug (MEMSTOMP) libc.memset(p, 0xF3, size);

                         }
                         pool.pagetable[pn] = B_FREE;
                         freed += PAGESIZE;
                         }
                         pool.pagetable[pn] = B_FREE;
                         freed += PAGESIZE;


@@ -2471,7 +2480,7 @@ struct Gcx
                             debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
                             debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 

-                            debug (MEMSTOMP) .memset(p, 0xF3, size);
+                            debug (MEMSTOMP) libc.memset(p, 0xF3, size);

 
                             freed += size;
                         }
 
                             freed += size;
                         }


@@ -2492,7 +2501,7 @@ struct Gcx
                         log_free(sentinel_add(p));
                         pool.pagetable[pn] = B_FREE;
                         freedpages++;
                         log_free(sentinel_add(p));
                         pool.pagetable[pn] = B_FREE;
                         freedpages++;

-                        debug (MEMSTOMP) .memset(p, 0xF3, PAGESIZE);
+                        debug (MEMSTOMP) libc.memset(p, 0xF3, PAGESIZE);

                         while (pn + 1 < pool.npages && pool.pagetable[pn + 1] == B_PAGEPLUS)
                         {
                             pn++;
                         while (pn + 1 < pool.npages && pool.pagetable[pn + 1] == B_PAGEPLUS)
                         {
                             pn++;


@@ -2501,7 +2510,7 @@ struct Gcx
 
                             debug (MEMSTOMP)
                             {   p += PAGESIZE;
 
                             debug (MEMSTOMP)
                             {   p += PAGESIZE;

-                                .memset(p, 0xF3, PAGESIZE);
+                                libc.memset(p, 0xF3, PAGESIZE);

                             }
                         }
                     }
                             }
                         }
                     }


@@ -2779,11 +2788,11 @@ struct Pool
 {
     byte* baseAddr;
     byte* topAddr;
 {
     byte* baseAddr;
     byte* topAddr;

-    GCBits mark;        // entries already scanned, or should not be scanned
-    GCBits scan;        // entries that need to be scanned
-    GCBits freebits;    // entries that are on the free list
-    GCBits finals;      // entries that need finalizer run on them
-    GCBits noscan;      // entries that should not be scanned
+    GCBits mark;     // entries already scanned, or should not be scanned
+    GCBits scan;     // entries that need to be scanned
+    GCBits freebits; // entries that are on the free list
+    GCBits finals;   // entries that need finalizer run on them
+    GCBits noscan;   // entries that should not be scanned

 
     size_t npages;
     ubyte* pagetable;
 
     size_t npages;
     ubyte* pagetable;


@@ -2796,7 +2805,7 @@ struct Pool
         //debug(PRINTF) printf("Pool::Pool(%u)\n", npages);
         poolsize = npages * PAGESIZE;
         assert(poolsize >= POOLSIZE);
         //debug(PRINTF) printf("Pool::Pool(%u)\n", npages);
         poolsize = npages * PAGESIZE;
         assert(poolsize >= POOLSIZE);

-        baseAddr = cast(byte *)os_mem_map(poolsize);
+        baseAddr = cast(byte *) alloc.os_mem_map(poolsize);

 
         // Some of the code depends on page alignment of memory pools
         assert((cast(size_t)baseAddr & (PAGESIZE - 1)) == 0);
 
         // Some of the code depends on page alignment of memory pools
         assert((cast(size_t)baseAddr & (PAGESIZE - 1)) == 0);


@@ -2817,10 +2826,10 @@ struct Pool
         freebits.alloc(cast(size_t)poolsize / 16);
         noscan.alloc(cast(size_t)poolsize / 16);
 
         freebits.alloc(cast(size_t)poolsize / 16);
         noscan.alloc(cast(size_t)poolsize / 16);
 

-        pagetable = cast(ubyte*) .malloc(npages);
+        pagetable = cast(ubyte*) libc.malloc(npages);

         if (!pagetable)
             onOutOfMemoryError();
         if (!pagetable)
             onOutOfMemoryError();

-       .memset(pagetable, B_FREE, npages);
+        libc.memset(pagetable, B_FREE, npages);

 
         this.npages = npages;
     }
 
         this.npages = npages;
     }


@@ -2834,7 +2843,7 @@ struct Pool
 
             if (npages)
             {
 
             if (npages)
             {

-                result = os_mem_unmap(baseAddr, npages * PAGESIZE);
+                result = alloc.os_mem_unmap(baseAddr, npages * PAGESIZE);

                 assert(result);
                 npages = 0;
             }
                 assert(result);
                 npages = 0;
             }


@@ -2843,7 +2852,7 @@ struct Pool
             topAddr = null;
         }
         if (pagetable)
             topAddr = null;
         }
         if (pagetable)

-            .free(pagetable);
+            libc.free(pagetable);

 
         mark.Dtor();
         scan.Dtor();
 
         mark.Dtor();
         scan.Dtor();


@@ -2911,7 +2920,7 @@ struct Pool
      */
     void freePages(size_t pagenum, size_t npages)
     {
      */
     void freePages(size_t pagenum, size_t npages)
     {

-        .memset(&pagetable[pagenum], B_FREE, npages);
+        libc.memset(&pagetable[pagenum], B_FREE, npages);

     }
 
 
     }
 
 

diff --git a/rt/gc/cdgc/iface.d b/rt/gc/cdgc/iface.d
index 7f7843732a01b4c4aa9d505c318755936ea9597e..dfaf9a72e7064afc5930c66068a655326a7c0872 100644 (file)
--- a/rt/gc/cdgc/iface.d
+++ b/rt/gc/cdgc/iface.d
@@ -26,9 +26,9 @@
 
 module rt.gc.cdgc.iface;
 
 
 module rt.gc.cdgc.iface;
 

-import rt.gc.cdgc.gc;
-import rt.gc.cdgc.stats;
-import rt.gc.cdgc.libc;
+import rt.gc.cdgc.gc: GC, BlkInfo;
+import rt.gc.cdgc.stats: GCStats;
+import libc = rt.gc.cdgc.libc;

 
 version=GCCLASS;
 
 
 version=GCCLASS;
 


@@ -67,13 +67,13 @@ extern (C) void gc_init()
     {   void* p;
         ClassInfo ci = GC.classinfo;
 
     {   void* p;
         ClassInfo ci = GC.classinfo;
 

-        p = malloc(ci.init.length);
+        p = libc.malloc(ci.init.length);

         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
         _gc = cast(GC)p;
     }
     else
     {
         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
         _gc = cast(GC)p;
     }
     else
     {

-        _gc = cast(GC*) calloc(1, GC.sizeof);
+        _gc = cast(GC*) libc.calloc(1, GC.sizeof);

     }
     _gc.initialize();
     version (DigitalMars) version(OSX) {
     }
     _gc.initialize();
     version (DigitalMars) version(OSX) {