First attempt at support for dynamic library loading and unloading. Currently, only...

[software/druntime.git] / src / gc / basic / gc.d

diff --git a/src/gc/basic/gc.d b/src/gc/basic/gc.d
index 3f8a642e6bd34bc0900da9184f302ac19797f209..6b2418299c7cbfbaa3ab60b0a865823d37b85d26 100644 (file)
--- a/src/gc/basic/gc.d
+++ b/src/gc/basic/gc.d
@@ -79,133 +79,241 @@ extern (C) void gc_term()
 
 extern (C) void gc_enable()
 {
 
 extern (C) void gc_enable()
 {

-    _gc.enable();
+    if( proxy is null )
+        return _gc.enable();
+    return proxy.gc_enable();

 }
 
 extern (C) void gc_disable()
 {
 }
 
 extern (C) void gc_disable()
 {

-    _gc.disable();
+    if( proxy is null )
+        return _gc.disable();
+    return proxy.gc_disable();

 }
 
 extern (C) void gc_collect()
 {
 }
 
 extern (C) void gc_collect()
 {

-    _gc.fullCollect();
+    if( proxy is null )
+        return _gc.fullCollect();
+    return proxy.gc_collect();

 }
 
 
 extern (C) void gc_minimize()
 {
 }
 
 
 extern (C) void gc_minimize()
 {

-    _gc.minimize();
+    if( proxy is null )
+        return _gc.minimize();
+    return proxy.gc_minimize();

 }
 
 extern (C) uint gc_getAttr( void* p )
 {
 }
 
 extern (C) uint gc_getAttr( void* p )
 {

-    return _gc.getAttr( p );
+    if( proxy is null )
+        return _gc.getAttr( p );
+    return proxy.gc_getAttr( p );

 }
 
 extern (C) uint gc_setAttr( void* p, uint a )
 {
 }
 
 extern (C) uint gc_setAttr( void* p, uint a )
 {

-    return _gc.setAttr( p, a );
+    if( proxy is null )
+        return _gc.setAttr( p, a );
+    return proxy.gc_setAttr( p, a );

 }
 
 extern (C) uint gc_clrAttr( void* p, uint a )
 {
 }
 
 extern (C) uint gc_clrAttr( void* p, uint a )
 {

-    return _gc.clrAttr( p, a );
+    if( proxy is null )
+        return _gc.clrAttr( p, a );
+    return proxy.gc_clrAttr( p, a );

 }
 
 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 {
 }
 
 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 {

-    return _gc.malloc( sz, ba );
+    if( proxy is null )
+        return _gc.malloc( sz, ba );
+    return proxy.gc_malloc( sz, ba );

 }
 
 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 {
 }
 
 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 {

-    return _gc.calloc( sz, ba );
+    if( proxy is null )
+        return _gc.calloc( sz, ba );
+    return proxy.gc_calloc( sz, ba );

 }
 
 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 {
 }
 
 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 {

-    return _gc.realloc( p, sz, ba );
+    if( proxy is null )
+        return _gc.realloc( p, sz, ba );
+    return proxy.gc_realloc( p, sz, ba );

 }
 
 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 {
 }
 
 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 {

-    return _gc.extend( p, mx, sz );
+    if( proxy is null )
+        return _gc.extend( p, mx, sz );
+    return proxy.gc_extend( p, mx, sz );

 }
 
 extern (C) size_t gc_reserve( size_t sz )
 {
 }
 
 extern (C) size_t gc_reserve( size_t sz )
 {

-    return _gc.reserve( sz );
+    if( proxy is null )
+        return _gc.reserve( sz );
+    return proxy.gc_reserve( sz );

 }
 
 extern (C) void gc_free( void* p )
 {
 }
 
 extern (C) void gc_free( void* p )
 {

-    _gc.free( p );
+    if( proxy is null )
+        return _gc.free( p );
+    return proxy.gc_free( p );

 }
 
 extern (C) void* gc_addrOf( void* p )
 {
 }
 
 extern (C) void* gc_addrOf( void* p )
 {

-    return _gc.addrOf( p );
+    if( proxy is null )
+        return _gc.addrOf( p );
+    return proxy.gc_addrOf( p );

 }
 
 extern (C) size_t gc_sizeOf( void* p )
 {
 }
 
 extern (C) size_t gc_sizeOf( void* p )
 {

-    return _gc.sizeOf( p );
+    if( proxy is null )
+        return _gc.sizeOf( p );
+    return proxy.gc_sizeOf( p );

 }
 
 extern (C) BlkInfo gc_query( void* p )
 {
 }
 
 extern (C) BlkInfo gc_query( void* p )
 {

-    return _gc.query( p );
+    if( proxy is null )
+        return _gc.query( p );
+    return proxy.gc_query( p );

 }
 
 // NOTE: This routine is experimental.  The stats or function name may change
 //       before it is made officially available.
 extern (C) GCStats gc_stats()
 {
 }
 
 // NOTE: This routine is experimental.  The stats or function name may change
 //       before it is made officially available.
 extern (C) GCStats gc_stats()
 {

-    GCStats stats = void;
-    _gc.getStats( stats );
-    return stats;
+    if( proxy is null )
+    {
+        GCStats stats = void;
+        _gc.getStats( stats );
+        return stats;
+    }
+    // TODO: Add proxy support for this once the layout of GCStats is
+    //       finalized.
+    //return proxy.gc_stats();
+    return GCStats.init;

 }
 
 extern (C) void gc_addRoot( void* p )
 {
 }
 
 extern (C) void gc_addRoot( void* p )
 {

-    _gc.addRoot( p );
+    if( proxy is null )
+        return _gc.addRoot( p );
+    return proxy.gc_addRoot( p );

 }
 
 extern (C) void gc_addRange( void* p, size_t sz )
 {
 }
 
 extern (C) void gc_addRange( void* p, size_t sz )
 {

-    _gc.addRange( p, sz );
+    if( proxy is null )
+        return _gc.addRange( p, sz );
+    return proxy.gc_addRange( p, sz );

 }
 
 }
 

-extern (C) void gc_removeRoot( void *p )
+extern (C) void gc_removeRoot( void* p )

 {
 {

-    _gc.removeRoot( p );
+    if( proxy is null )
+        return _gc.removeRoot( p );
+    return proxy.gc_removeRoot( p );

 }
 
 }
 

-extern (C) void gc_removeRange( void *p )
+extern (C) void gc_removeRange( void* p )

 {
 {

-    _gc.removeRange( p );
+    if( proxy is null )
+        return _gc.removeRange( p );
+    return proxy.gc_removeRange( p );

 }
 
 }
 

-extern (C) void* gc_getHandle()
+struct Proxy

 {
 {

-    return cast(void*)_gc;
+    extern (C) void function() gc_enable;
+    extern (C) void function() gc_disable;
+    extern (C) void function() gc_collect;
+    extern (C) void function() gc_minimize;
+
+    extern (C) uint function(void*) gc_getAttr;
+    extern (C) uint function(void*, uint) gc_setAttr;
+    extern (C) uint function(void*, uint) gc_clrAttr;
+
+    extern (C) void*  function(size_t, uint) gc_malloc;
+    extern (C) void*  function(size_t, uint) gc_calloc;
+    extern (C) void*  function(void*, size_t, uint ba) gc_realloc;
+    extern (C) size_t function(void*, size_t, size_t) gc_extend;
+    extern (C) size_t function(size_t) gc_reserve;
+    extern (C) void   function(void*) gc_free;
+
+    extern (C) void*   function(void*) gc_addrOf;
+    extern (C) size_t  function(void*) gc_sizeOf;
+
+    extern (C) BlkInfo function(void*) gc_query;
+
+    extern (C) void function(void*) gc_addRoot;
+    extern (C) void function(void*, size_t) gc_addRange;
+
+    extern (C) void function(void*) gc_removeRoot;
+    extern (C) void function(void*) gc_removeRange;

 }
 
 }
 

-extern (C) void gc_setHandle(void* p)
+Proxy  pthis;
+Proxy* proxy;
+
+static this()

 {
 {

-    void* oldp = gc_getHandle();
-    gc_t g = cast(gc_t)p;
-    if (g.gcversion != gcx.GCVERSION)
-        throw new Error("incompatible gc versions");
+    pthis.gc_enable = &gc_enable;
+    pthis.gc_disable = &gc_disable;
+    pthis.gc_collect = &gc_collect;
+    pthis.gc_minimize = &gc_minimize;
+
+    pthis.gc_getAttr = &gc_getAttr;
+    pthis.gc_setAttr = &gc_setAttr;
+    pthis.gc_clrAttr = &gc_clrAttr;
+
+    pthis.gc_malloc = &gc_malloc;
+    pthis.gc_calloc = &gc_calloc;
+    pthis.gc_realloc = &gc_realloc;
+    pthis.gc_extend = &gc_extend;
+    pthis.gc_reserve = &gc_reserve;
+    pthis.gc_free = &gc_free;

 
 

-    // Add our static data to the new gc
-    GC.scanStaticData(g);
+    pthis.gc_addrOf = &gc_addrOf;
+    pthis.gc_sizeOf = &gc_sizeOf;

 
 

-    _gc = g;
+    pthis.gc_query = &gc_query;
+
+    pthis.gc_addRoot = &gc_addRoot;
+    pthis.gc_addRange = &gc_addRange;
+
+    pthis.gc_removeRoot = &gc_removeRoot;
+    pthis.gc_removeRange = &gc_removeRange;
+}
+
+extern (C) Proxy* gc_getProxy()
+{
+    return &pthis;
+}
+
+export extern (C) void gc_setProxy( Proxy* p )
+{
+    if( proxy !is null )
+    {
+        // TODO: Decide if this is an error condition.
+    }
+    proxy = p;
+    // TODO: Add known ranges and roots to the proxy.

 }
 
 }
 

-extern (C) void gc_endHandle()
+export extern (C) void gc_clrProxy()

 {
 {

-    GC.unscanStaticData(_gc);
+    // TODO: Remove known ranges and roots from the proxy.
+    proxy = null;

 }
 }