Remove Tango dependency

To avoid Tango dependency, we need to write our own C-API interface. This
is done in the new gc.libc module. In the future, maybe this module will
use Tango or Phobos accordly, but for now we stay free of dependencies (at
the expense of some extra work).

diff --git a/Makefile b/Makefile
index b41b9a0adb45f98cde55fea98c01f1507a2d0376..32232ef218aca16d062661c683ce6d2ad97bebd0 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -36,6 +36,7 @@ sources := \
        gc/alloc.d \
        gc/bits.d \
        gc/stats.d \
+       gc/libc.d \
        gc/gc.d
 
 # Default target

diff --git a/gc/alloc.d b/gc/alloc.d
index cad30f2cd62faed18e7eabd52d15666ecd0e610e..55d0497a7296e541008e7c09bd0ca97f5733f7b9 100644 (file)
--- a/gc/alloc.d
+++ b/gc/alloc.d
@@ -26,31 +26,57 @@
 
 module gc.alloc;
 
-version (Win32)
-{
-    import tango.sys.win32.UserGdi;
-
-    alias int pthread_t;
-
-    pthread_t pthread_self()
-    {
-        return cast(pthread_t) GetCurrentThreadId();
+// C OS-specific API
+private extern (C) {
+    version (Win32) {
+        alias void* POINTER;
+        alias POINTER LPVOID;
+        alias uint DWORD;
+        alias int WINBOOL;
+        enum: DWORD {
+            PAGE_READWRITE = 4,
+            MEM_RESERVE = 8192,
+            MEM_COMMIT = 4096,
+            MEM_DECOMMIT = 16384,
+            MEM_RELEASE = 32768,
+        }
+        LPVOID VirtualAlloc(LPVOID, DWORD, DWORD, DWORD);
+        WINBOOL VirtualFree(LPVOID, DWORD, DWORD);
+    }
+    else version (Posix) {
+        version (linux) enum: bool { OPTIONAL_LARGEFILE_SUPPORT = true }
+        else version (solaris) enum: bool { OPTIONAL_LARGEFILE_SUPPORT = true }
+        else enum: bool { OPTIONAL_LARGEFILE_SUPPORT = false }
+        static if (OPTIONAL_LARGEFILE_SUPPORT)
+            enum: bool { USE_LARGEFILE64 = ((void*).sizeof == 4) }
+        else
+            enum: bool { USE_LARGEFILE64 = false }
+        static if (USE_LARGEFILE64 || (void*).sizeof > int.sizeof)
+            alias long off_t;
+        else
+            alias int off_t;
+        enum: int {
+            PROT_NONE = 0x0,
+            PROT_READ = 0x1,
+            PROT_WRITE = 0x2,
+            PROT_EXEC = 0x4,
+            MAP_SHARED = 0x01,
+            MAP_PRIVATE = 0x02,
+            MAP_FIXED = 0x10,
+        }
+        const MAP_FAILED = cast(void*) -1;
+        // Non-standard, but needed
+        version (linux) { enum: int { MAP_ANON = 0x20 } }
+        else version (darwin) { enum: int { MAP_ANON = 0x1000 } }
+        else version (freebsd) { enum: int { MAP_ANON = 0x1000 } }
+        else version (solaris) { enum: int { MAP_ANON = 0x100 } }
+        void* mmap(void*, size_t, int, int, int, off_t);
+        int munmap(void*, size_t);
+    }
+    else {
+        // Standard C library
+        import gc.libc;
     }
-
-    //version = GC_Use_Alloc_Win32;
-}
-else version (Posix)
-{
-    import tango.stdc.posix.sys.mman;
-    import tango.stdc.stdlib;
-
-    //version = GC_Use_Alloc_MMap;
-}
-else
-{
-    import tango.stdc.stdlib;
-
-    //version = GC_Use_Alloc_Malloc;
 }
 
 /+

diff --git a/gc/bits.d b/gc/bits.d
index e8e926327f3849a8bc6c60aed920c49920cdcb0f..e9ece9bb6aa16db57e0044d836eb215d2d3ddf96 100644 (file)
--- a/gc/bits.d
+++ b/gc/bits.d
@@ -26,9 +26,7 @@
 
 module gc.bits;
 
-import tango.core.BitManip;
-import tango.stdc.string;
-import tango.stdc.stdlib;
+import gc.libc;
 
 private extern (C) void onOutOfMemoryError();
 

diff --git a/gc/gc.d b/gc/gc.d
index 7915a1144a80cc70284d3e12eaaca77691353fa3..8cd56095b98dd4d42b08b149097f107f0e7dc405 100644 (file)
--- a/gc/gc.d
+++ b/gc/gc.d
@@ -50,11 +50,8 @@ version = MULTI_THREADED;       // produce multithreaded version
 import gc.bits;
 import gc.stats;
 import gc.alloc;
+import gc.libc;
 
-import cstdlib = tango.stdc.stdlib : calloc, free, malloc, realloc;
-import cstring = tango.stdc.string : memcpy, memmove, memset;
-
-debug import tango.stdc.stdio : printf;
 
 version (GNU)
 {
@@ -147,7 +144,7 @@ debug (LOGGING)
         void Dtor()
         {
             if (data)
-                cstdlib.free(data);
+                .free(data);
             data = null;
         }
 
@@ -160,18 +157,18 @@ debug (LOGGING)
                 assert(dim + nentries <= allocdim);
                 if (!data)
                 {
-                    data = cast(Log*)cstdlib.malloc(allocdim * Log.sizeof);
+                    data = cast(Log*) .malloc(allocdim * Log.sizeof);
                     if (!data && allocdim)
                         onOutOfMemoryError();
                 }
                 else
                 {   Log *newdata;
 
-                    newdata = cast(Log*)cstdlib.malloc(allocdim * Log.sizeof);
+                    newdata = cast(Log*) .malloc(allocdim * Log.sizeof);
                     if (!newdata && allocdim)
                         onOutOfMemoryError();
-                    cstring.memcpy(newdata, data, dim * Log.sizeof);
-                    cstdlib.free(data);
+                    .memcpy(newdata, data, dim * Log.sizeof);
+                    .free(data);
                     data = newdata;
                 }
             }
@@ -186,7 +183,7 @@ debug (LOGGING)
 
         void remove(size_t i)
         {
-            cstring.memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);
+            .memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);
             dim--;
         }
 
@@ -206,7 +203,7 @@ debug (LOGGING)
         {
             reserve(from.dim - dim);
             assert(from.dim <= allocdim);
-            cstring.memcpy(data, from.data, from.dim * Log.sizeof);
+            .memcpy(data, from.data, from.dim * Log.sizeof);
             dim = from.dim;
         }
     }
@@ -237,7 +234,7 @@ class GC
     void initialize()
     {
         gcLock = GCLock.classinfo;
-        gcx = cast(Gcx*)cstdlib.calloc(1, Gcx.sizeof);
+        gcx = cast(Gcx*) .calloc(1, Gcx.sizeof);
         if (!gcx)
             onOutOfMemoryError();
         gcx.initialize();
@@ -250,7 +247,7 @@ class GC
         if (gcx)
         {
             gcx.Dtor();
-            cstdlib.free(gcx);
+            .free(gcx);
             gcx = null;
         }
     }
@@ -483,9 +480,9 @@ class GC
             // Return next item from free list
             gcx.bucket[bin] = (cast(List*)p).next;
             if( !(bits & BlkAttr.NO_SCAN) )
-                cstring.memset(p + size, 0, binsize[bin] - size);
+                .memset(p + size, 0, binsize[bin] - size);
             //debug(PRINTF) printf("\tmalloc => %x\n", p);
-            debug (MEMSTOMP) cstring.memset(p, 0xF0, size);
+            debug (MEMSTOMP) .memset(p, 0xF0, size);
         }
         else
         {
@@ -539,7 +536,7 @@ class GC
 
         //debug(PRINTF) printf("calloc: %x len %d\n", p, len);
         void *p = mallocNoSync(size, bits);
-        cstring.memset(p, 0, size);
+        .memset(p, 0, size);
         return p;
     }
 
@@ -609,7 +606,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);
                     p = p2;
                 }
             }
@@ -630,7 +627,7 @@ class GC
                     {   // Shrink in place
                         synchronized (gcLock)
                         {
-                            debug (MEMSTOMP) cstring.memset(p + size, 0xF2, psize - size);
+                            debug (MEMSTOMP) .memset(p + size, 0xF2, psize - size);
                             pool.freePages(pagenum + newsz, psz - newsz);
                         }
                         return p;
@@ -644,8 +641,8 @@ class GC
                             {
                                 if (i == pagenum + newsz)
                                 {
-                                    debug (MEMSTOMP) cstring.memset(p + psize, 0xF0, size - psize);
-                                    cstring.memset(&pool.pagetable[pagenum + psz], B_PAGEPLUS, newsz - psz);
+                                    debug (MEMSTOMP) .memset(p + psize, 0xF0, size - psize);
+                                    .memset(&pool.pagetable[pagenum + psz], B_PAGEPLUS, newsz - psz);
                                     return p;
                                 }
                                 if (i == pool.ncommitted)
@@ -689,7 +686,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);
                     p = p2;
                 }
             }
@@ -770,8 +767,8 @@ class GC
         }
         else
             return 0;
-        debug (MEMSTOMP) cstring.memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
-        cstring.memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
+        debug (MEMSTOMP) .memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
+        .memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
         gcx.p_cache = null;
         gcx.size_cache = 0;
         return (psz + sz) * PAGESIZE;
@@ -864,14 +861,14 @@ class GC
             n = pagenum;
             while (++n < pool.ncommitted && pool.pagetable[n] == B_PAGEPLUS)
                 npages++;
-            debug (MEMSTOMP) cstring.memset(p, 0xF2, npages * PAGESIZE);
+            debug (MEMSTOMP) .memset(p, 0xF2, npages * PAGESIZE);
             pool.freePages(pagenum, npages);
         }
         else
         {   // Add to free list
             List *list = cast(List*)p;
 
-            debug (MEMSTOMP) cstring.memset(p, 0xF2, binsize[bin]);
+            debug (MEMSTOMP) .memset(p, 0xF2, binsize[bin]);
 
             list.next = gcx.bucket[bin];
             gcx.bucket[bin] = list;
@@ -1288,7 +1285,7 @@ class GC
         size_t bsize = 0;
 
         //debug(PRINTF) printf("getStats()\n");
-        cstring.memset(&stats, 0, GCStats.sizeof);
+        .memset(&stats, 0, GCStats.sizeof);
 
         for (n = 0; n < gcx.npools; n++)
         {   Pool *pool = gcx.pooltable[n];
@@ -1424,16 +1421,16 @@ struct Gcx
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();
-            cstdlib.free(pool);
+            .free(pool);
         }
         if (pooltable)
-            cstdlib.free(pooltable);
+            .free(pooltable);
 
         if (roots)
-            cstdlib.free(roots);
+            .free(roots);
 
         if (ranges)
-            cstdlib.free(ranges);
+            .free(ranges);
     }
 
 
@@ -1504,12 +1501,12 @@ struct Gcx
             size_t newdim = rootdim * 2 + 16;
             void** newroots;
 
-            newroots = cast(void**)cstdlib.malloc(newdim * newroots[0].sizeof);
+            newroots = cast(void**) .malloc(newdim * newroots[0].sizeof);
             if (!newroots)
                 onOutOfMemoryError();
             if (roots)
-            {   cstring.memcpy(newroots, roots, nroots * newroots[0].sizeof);
-                cstdlib.free(roots);
+            {   .memcpy(newroots, roots, nroots * newroots[0].sizeof);
+                .free(roots);
             }
             roots = newroots;
             rootdim = newdim;
@@ -1529,7 +1526,7 @@ struct Gcx
             if (roots[i] == p)
             {
                 nroots--;
-                cstring.memmove(roots + i, roots + i + 1, (nroots - i) * roots[0].sizeof);
+                .memmove(roots + i, roots + i + 1, (nroots - i) * roots[0].sizeof);
                 return;
             }
         }
@@ -1549,12 +1546,12 @@ struct Gcx
             size_t newdim = rangedim * 2 + 16;
             Range *newranges;
 
-            newranges = cast(Range*)cstdlib.malloc(newdim * newranges[0].sizeof);
+            newranges = cast(Range*) .malloc(newdim * newranges[0].sizeof);
             if (!newranges)
                 onOutOfMemoryError();
             if (ranges)
-            {   cstring.memcpy(newranges, ranges, nranges * newranges[0].sizeof);
-                cstdlib.free(ranges);
+            {   .memcpy(newranges, ranges, nranges * newranges[0].sizeof);
+                .free(ranges);
             }
             ranges = newranges;
             rangedim = newdim;
@@ -1577,7 +1574,7 @@ struct Gcx
             if (ranges[i].pbot == pbot)
             {
                 nranges--;
-                cstring.memmove(ranges + i, ranges + i + 1, (nranges - i) * ranges[0].sizeof);
+                .memmove(ranges + i, ranges + i + 1, (nranges - i) * ranges[0].sizeof);
                 return;
             }
         }
@@ -1845,8 +1842,8 @@ struct Gcx
                 continue;
             }
             pool.Dtor();
-            cstdlib.free(pool);
-            cstring.memmove(pooltable + n,
+            .free(pool);
+            .memmove(pooltable + n,
                             pooltable + n + 1,
                             (--npools - n) * (Pool*).sizeof);
             minAddr = pooltable[0].baseAddr;
@@ -1929,10 +1926,10 @@ struct Gcx
       L1:
         pool.pagetable[pn] = B_PAGE;
         if (npages > 1)
-            cstring.memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
+            .memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
         p = pool.baseAddr + pn * PAGESIZE;
-        cstring.memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
-        debug (MEMSTOMP) cstring.memset(p, 0xF1, size);
+        .memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
+        debug (MEMSTOMP) .memset(p, 0xF1, size);
         //debug(PRINTF) printf("\tp = %x\n", p);
         return p;
 
@@ -1980,7 +1977,7 @@ struct Gcx
                 npages = n;
         }
 
-        pool = cast(Pool *)cstdlib.calloc(1, Pool.sizeof);
+        pool = cast(Pool *) .calloc(1, Pool.sizeof);
         if (pool)
         {
             pool.initialize(npages);
@@ -1988,7 +1985,7 @@ struct Gcx
                 goto Lerr;
 
             newnpools = npools + 1;
-            newpooltable = cast(Pool **)cstdlib.realloc(pooltable, newnpools * (Pool *).sizeof);
+            newpooltable = cast(Pool **) .realloc(pooltable, newnpools * (Pool *).sizeof);
             if (!newpooltable)
                 goto Lerr;
 
@@ -1998,7 +1995,7 @@ struct Gcx
                 if (pool.opCmp(newpooltable[i]) < 0)
                      break;
             }
-            cstring.memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * (Pool *).sizeof);
+            .memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * (Pool *).sizeof);
             newpooltable[i] = pool;
 
             pooltable = newpooltable;
@@ -2011,7 +2008,7 @@ struct Gcx
 
       Lerr:
         pool.Dtor();
-        cstdlib.free(pool);
+        .free(pool);
         return null;
     }
 
@@ -2403,7 +2400,7 @@ struct Gcx
                             //debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
-                            debug (MEMSTOMP) cstring.memset(p, 0xF3, size);
+                            debug (MEMSTOMP) .memset(p, 0xF3, size);
                         }
                         pool.pagetable[pn] = B_FREE;
                         freed += PAGESIZE;
@@ -2426,7 +2423,7 @@ struct Gcx
                             debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
-                            debug (MEMSTOMP) cstring.memset(p, 0xF3, size);
+                            debug (MEMSTOMP) .memset(p, 0xF3, size);
 
                             freed += size;
                         }
@@ -2447,7 +2444,7 @@ struct Gcx
                         log_free(sentinel_add(p));
                         pool.pagetable[pn] = B_FREE;
                         freedpages++;
-                        debug (MEMSTOMP) cstring.memset(p, 0xF3, PAGESIZE);
+                        debug (MEMSTOMP) .memset(p, 0xF3, PAGESIZE);
                         while (pn + 1 < ncommitted && pool.pagetable[pn + 1] == B_PAGEPLUS)
                         {
                             pn++;
@@ -2456,7 +2453,7 @@ struct Gcx
 
                             debug (MEMSTOMP)
                             {   p += PAGESIZE;
-                                cstring.memset(p, 0xF3, PAGESIZE);
+                                .memset(p, 0xF3, PAGESIZE);
                             }
                         }
                     }
@@ -2775,10 +2772,10 @@ struct Pool
         freebits.alloc(cast(size_t)poolsize / 16);
         noscan.alloc(cast(size_t)poolsize / 16);
 
-        pagetable = cast(ubyte*)cstdlib.malloc(npages);
+        pagetable = cast(ubyte*) .malloc(npages);
         if (!pagetable)
             onOutOfMemoryError();
-        cstring.memset(pagetable, B_UNCOMMITTED, npages);
+        .memset(pagetable, B_UNCOMMITTED, npages);
 
         this.npages = npages;
         ncommitted = 0;
@@ -2809,7 +2806,7 @@ struct Pool
             topAddr = null;
         }
         if (pagetable)
-            cstdlib.free(pagetable);
+            .free(pagetable);
 
         mark.Dtor();
         scan.Dtor();
@@ -2890,7 +2887,7 @@ struct Pool
             //fflush(stdout);
             if (os_mem_commit(baseAddr, ncommitted * PAGESIZE, tocommit * PAGESIZE) == 0)
             {
-                cstring.memset(pagetable + ncommitted, B_FREE, tocommit);
+                .memset(pagetable + ncommitted, B_FREE, tocommit);
                 auto i = ncommitted;
                 ncommitted += tocommit;
 
@@ -2911,7 +2908,7 @@ struct Pool
      */
     void freePages(size_t pagenum, size_t npages)
     {
-        cstring.memset(&pagetable[pagenum], B_FREE, npages);
+        .memset(&pagetable[pagenum], B_FREE, npages);
     }
 
 

diff --git a/gc/iface.d b/gc/iface.d
index efef61b4b3afea38c87d4acbdb462c6d5519ffd5..6f95c5d1e091a5c2823b5ddc73ef79f59e7bdc11 100644 (file)
--- a/gc/iface.d
+++ b/gc/iface.d
@@ -28,7 +28,7 @@ module gc.iface;
 
 import gc.gc;
 import gc.stats;
-import tango.stdc.stdlib;
+import gc.c;
 
 version=GCCLASS;
 
@@ -67,13 +67,13 @@ extern (C) void gc_init()
     {   void* p;
         ClassInfo ci = GC.classinfo;
 
-        p = tango.stdc.stdlib.malloc(ci.init.length);
+        p = malloc(ci.init.length);
         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
         _gc = cast(GC)p;
     }
     else
     {
-        _gc = cast(GC*) tango.stdc.stdlib.calloc(1, GC.sizeof);
+        _gc = cast(GC*) calloc(1, GC.sizeof);
     }
     _gc.initialize();
     version (DigitalMars) version(OSX) {
@@ -96,7 +96,7 @@ extern (C) void gc_term()
         //       Often this probably doesn't matter much since the app is
         //       supposed to be shutting down anyway, but for example tests might
         //       crash (and be considerd failed even if the test was ok).
-        //       thus this is not the default and should be enabled by 
+        //       thus this is not the default and should be enabled by
         //       I'm disabling cleanup for now until I can think about it some
         //       more.
         //

diff --git a/gc/libc.d b/gc/libc.d
new file mode 100644 (file)
index 0000000..e0cd23e
--- /dev/null
+++ b/gc/libc.d
@@ -0,0 +1,29 @@
+
+module gc.c;
+
+version (Windows) {
+    alias int   c_long;
+    alias uint  c_ulong;
+}
+else {
+    static if ((void*).sizeof > int.sizeof) {
+        alias long c_long;
+        alias ulong c_ulong;
+    }
+    else {
+        alias int c_long;
+        alias uint c_ulong;
+    }
+}
+
+// C standard library
+extern (C):
+void* realloc(void*, size_t);
+void* malloc(size_t);
+void* calloc(size_t, size_t);
+void free(void*);
+void* memset(void*, int, size_t);
+void* memcpy(void*, void*, size_t);
+void* memmove(void*, void*, size_t);
+void printf(char* fmt, ...);
+