[BACK]Return to gc_cpp.h CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3

Annotation of OpenXM_contrib2/asir2000/gc5.3/gc_cpp.h, Revision 1.1.1.1

1.1       noro        1: #ifndef GC_CPP_H
                      2: #define GC_CPP_H
                      3: /****************************************************************************
                      4: Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
                      5:
                      6: THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
                      7: OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
                      8:
                      9: Permission is hereby granted to use or copy this program for any
                     10: purpose, provided the above notices are retained on all copies.
                     11: Permission to modify the code and to distribute modified code is
                     12: granted, provided the above notices are retained, and a notice that
                     13: the code was modified is included with the above copyright notice.
                     14: ****************************************************************************
                     15:
                     16: C++ Interface to the Boehm Collector
                     17:
                     18:     John R. Ellis and Jesse Hull
                     19:
                     20: This interface provides access to the Boehm collector.  It provides
                     21: basic facilities similar to those described in "Safe, Efficient
                     22: Garbage Collection for C++", by John R. Elis and David L. Detlefs
                     23: (ftp://ftp.parc.xerox.com/pub/ellis/gc).
                     24:
                     25: All heap-allocated objects are either "collectable" or
                     26: "uncollectable".  Programs must explicitly delete uncollectable
                     27: objects, whereas the garbage collector will automatically delete
                     28: collectable objects when it discovers them to be inaccessible.
                     29: Collectable objects may freely point at uncollectable objects and vice
                     30: versa.
                     31:
                     32: Objects allocated with the built-in "::operator new" are uncollectable.
                     33:
                     34: Objects derived from class "gc" are collectable.  For example:
                     35:
                     36:     class A: public gc {...};
                     37:     A* a = new A;       // a is collectable.
                     38:
                     39: Collectable instances of non-class types can be allocated using the GC
                     40: (or UseGC) placement:
                     41:
                     42:     typedef int A[ 10 ];
                     43:     A* a = new (GC) A;
                     44:
                     45: Uncollectable instances of classes derived from "gc" can be allocated
                     46: using the NoGC placement:
                     47:
                     48:     class A: public gc {...};
                     49:     A* a = new (NoGC) A;   // a is uncollectable.
                     50:
                     51: Both uncollectable and collectable objects can be explicitly deleted
                     52: with "delete", which invokes an object's destructors and frees its
                     53: storage immediately.
                     54:
                     55: A collectable object may have a clean-up function, which will be
                     56: invoked when the collector discovers the object to be inaccessible.
                     57: An object derived from "gc_cleanup" or containing a member derived
                     58: from "gc_cleanup" has a default clean-up function that invokes the
                     59: object's destructors.  Explicit clean-up functions may be specified as
                     60: an additional placement argument:
                     61:
                     62:     A* a = ::new (GC, MyCleanup) A;
                     63:
                     64: An object is considered "accessible" by the collector if it can be
                     65: reached by a path of pointers from static variables, automatic
                     66: variables of active functions, or from some object with clean-up
                     67: enabled; pointers from an object to itself are ignored.
                     68:
                     69: Thus, if objects A and B both have clean-up functions, and A points at
                     70: B, B is considered accessible.  After A's clean-up is invoked and its
                     71: storage released, B will then become inaccessible and will have its
                     72: clean-up invoked.  If A points at B and B points to A, forming a
                     73: cycle, then that's considered a storage leak, and neither will be
                     74: collectable.  See the interface gc.h for low-level facilities for
                     75: handling such cycles of objects with clean-up.
                     76:
                     77: The collector cannot guarrantee that it will find all inaccessible
                     78: objects.  In practice, it finds almost all of them.
                     79:
                     80:
                     81: Cautions:
                     82:
                     83: 1. Be sure the collector has been augmented with "make c++".
                     84:
                     85: 2.  If your compiler supports the new "operator new[]" syntax, then
                     86: add -DOPERATOR_NEW_ARRAY to the Makefile.
                     87:
                     88: If your compiler doesn't support "operator new[]", beware that an
                     89: array of type T, where T is derived from "gc", may or may not be
                     90: allocated as a collectable object (it depends on the compiler).  Use
                     91: the explicit GC placement to make the array collectable.  For example:
                     92:
                     93:     class A: public gc {...};
                     94:     A* a1 = new A[ 10 ];        // collectable or uncollectable?
                     95:     A* a2 = new (GC) A[ 10 ];   // collectable
                     96:
                     97: 3. The destructors of collectable arrays of objects derived from
                     98: "gc_cleanup" will not be invoked properly.  For example:
                     99:
                    100:     class A: public gc_cleanup {...};
                    101:     A* a = new (GC) A[ 10 ];    // destructors not invoked correctly
                    102:
                    103: Typically, only the destructor for the first element of the array will
                    104: be invoked when the array is garbage-collected.  To get all the
                    105: destructors of any array executed, you must supply an explicit
                    106: clean-up function:
                    107:
                    108:     A* a = new (GC, MyCleanUp) A[ 10 ];
                    109:
                    110: (Implementing clean-up of arrays correctly, portably, and in a way
                    111: that preserves the correct exception semantics requires a language
                    112: extension, e.g. the "gc" keyword.)
                    113:
                    114: 4. Compiler bugs:
                    115:
                    116: * Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the
                    117: destructors of classes derived from gc_cleanup won't be invoked.
                    118: You'll have to explicitly register a clean-up function with
                    119: new-placement syntax.
                    120:
                    121: * Evidently cfront 3.0 does not allow destructors to be explicitly
                    122: invoked using the ANSI-conforming syntax t->~T().  If you're using
                    123: cfront 3.0, you'll have to comment out the class gc_cleanup, which
                    124: uses explicit invocation.
                    125:
                    126: 5. GC name conflicts:
                    127:
                    128: Many other systems seem to use the identifier "GC" as an abbreviation
                    129: for "Graphics Context".  Since version 5.0, GC placement has been replaced
                    130: by UseGC.  GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined.
                    131:
                    132: ****************************************************************************/
                    133:
                    134: #include "gc.h"
                    135:
                    136: #ifndef THINK_CPLUS
                    137: #define _cdecl
                    138: #endif
                    139:
                    140: #if ! defined( OPERATOR_NEW_ARRAY ) \
                    141:     && (__BORLANDC__ >= 0x450 || (__GNUC__ >= 2 && __GNUC_MINOR__ >= 6) \
                    142:         || __WATCOMC__ >= 1050 || _MSC_VER >= 1100)
                    143: #   define OPERATOR_NEW_ARRAY
                    144: #endif
                    145:
                    146: enum GCPlacement {UseGC,
                    147: #ifndef GC_NAME_CONFLICT
                    148:                  GC=UseGC,
                    149: #endif
                    150:                   NoGC, PointerFreeGC};
                    151:
                    152: class gc {public:
                    153:     inline void* operator new( size_t size );
                    154:     inline void* operator new( size_t size, GCPlacement gcp );
                    155:     inline void operator delete( void* obj );
                    156:
                    157: #ifdef OPERATOR_NEW_ARRAY
                    158:     inline void* operator new[]( size_t size );
                    159:     inline void* operator new[]( size_t size, GCPlacement gcp );
                    160:     inline void operator delete[]( void* obj );
                    161: #endif /* OPERATOR_NEW_ARRAY */
                    162:     };
                    163:     /*
                    164:     Instances of classes derived from "gc" will be allocated in the
                    165:     collected heap by default, unless an explicit NoGC placement is
                    166:     specified. */
                    167:
                    168: class gc_cleanup: virtual public gc {public:
                    169:     inline gc_cleanup();
                    170:     inline virtual ~gc_cleanup();
                    171: private:
                    172:     inline static void _cdecl cleanup( void* obj, void* clientData );};
                    173:     /*
                    174:     Instances of classes derived from "gc_cleanup" will be allocated
                    175:     in the collected heap by default.  When the collector discovers an
                    176:     inaccessible object derived from "gc_cleanup" or containing a
                    177:     member derived from "gc_cleanup", its destructors will be
                    178:     invoked. */
                    179:
                    180: extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
                    181:
                    182: inline void* operator new(
                    183:     size_t size,
                    184:     GCPlacement gcp,
                    185:     GCCleanUpFunc cleanup = 0,
                    186:     void* clientData = 0 );
                    187:     /*
                    188:     Allocates a collectable or uncollected object, according to the
                    189:     value of "gcp".
                    190:
                    191:     For collectable objects, if "cleanup" is non-null, then when the
                    192:     allocated object "obj" becomes inaccessible, the collector will
                    193:     invoke the function "cleanup( obj, clientData )" but will not
                    194:     invoke the object's destructors.  It is an error to explicitly
                    195:     delete an object allocated with a non-null "cleanup".
                    196:
                    197:     It is an error to specify a non-null "cleanup" with NoGC or for
                    198:     classes derived from "gc_cleanup" or containing members derived
                    199:     from "gc_cleanup". */
                    200:
                    201: #ifdef OPERATOR_NEW_ARRAY
                    202:
                    203: #ifdef _MSC_VER
                    204:  /** This ensures that the system default operator new[] doesn't get
                    205:   *  undefined, which is what seems to happen on VC++ 6 for some reason
                    206:   *  if we define a multi-argument operator new[].
                    207:   */
                    208:  inline void *operator new[]( size_t size )
                    209:  {
                    210:     return ::operator new( size );
                    211:  }
                    212: #endif /* _MSC_VER */
                    213:
                    214: inline void* operator new[](
                    215:     size_t size,
                    216:     GCPlacement gcp,
                    217:     GCCleanUpFunc cleanup = 0,
                    218:     void* clientData = 0 );
                    219:     /*
                    220:     The operator new for arrays, identical to the above. */
                    221:
                    222: #endif /* OPERATOR_NEW_ARRAY */
                    223:
                    224: /****************************************************************************
                    225:
                    226: Inline implementation
                    227:
                    228: ****************************************************************************/
                    229:
                    230: inline void* gc::operator new( size_t size ) {
                    231:     return GC_MALLOC( size );}
                    232:
                    233: inline void* gc::operator new( size_t size, GCPlacement gcp ) {
                    234:     if (gcp == UseGC)
                    235:         return GC_MALLOC( size );
                    236:     else if (gcp == PointerFreeGC)
                    237:        return GC_MALLOC_ATOMIC( size );
                    238:     else
                    239:         return GC_MALLOC_UNCOLLECTABLE( size );}
                    240:
                    241: inline void gc::operator delete( void* obj ) {
                    242:     GC_FREE( obj );}
                    243:
                    244:
                    245: #ifdef OPERATOR_NEW_ARRAY
                    246:
                    247: inline void* gc::operator new[]( size_t size ) {
                    248:     return gc::operator new( size );}
                    249:
                    250: inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
                    251:     return gc::operator new( size, gcp );}
                    252:
                    253: inline void gc::operator delete[]( void* obj ) {
                    254:     gc::operator delete( obj );}
                    255:
                    256: #endif /* OPERATOR_NEW_ARRAY */
                    257:
                    258:
                    259: inline gc_cleanup::~gc_cleanup() {
                    260:     GC_REGISTER_FINALIZER_IGNORE_SELF( GC_base(this), 0, 0, 0, 0 );}
                    261:
                    262: inline void gc_cleanup::cleanup( void* obj, void* displ ) {
                    263:     ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup();}
                    264:
                    265: inline gc_cleanup::gc_cleanup() {
                    266:     GC_finalization_proc oldProc;
                    267:     void* oldData;
                    268:     void* base = GC_base( (void *) this );
                    269:     if (0 != base)  {
                    270:       GC_REGISTER_FINALIZER_IGNORE_SELF(
                    271:         base, (GC_finalization_proc)cleanup, (void*) ((char*) this - (char*) base),
                    272:         &oldProc, &oldData );
                    273:       if (0 != oldProc) {
                    274:         GC_REGISTER_FINALIZER_IGNORE_SELF( base, oldProc, oldData, 0, 0 );}}}
                    275:
                    276: inline void* operator new(
                    277:     size_t size,
                    278:     GCPlacement gcp,
                    279:     GCCleanUpFunc cleanup,
                    280:     void* clientData )
                    281: {
                    282:     void* obj;
                    283:
                    284:     if (gcp == UseGC) {
                    285:         obj = GC_MALLOC( size );
                    286:         if (cleanup != 0)
                    287:             GC_REGISTER_FINALIZER_IGNORE_SELF(
                    288:                 obj, cleanup, clientData, 0, 0 );}
                    289:     else if (gcp == PointerFreeGC) {
                    290:         obj = GC_MALLOC_ATOMIC( size );}
                    291:     else {
                    292:         obj = GC_MALLOC_UNCOLLECTABLE( size );};
                    293:     return obj;}
                    294:
                    295:
                    296: #ifdef OPERATOR_NEW_ARRAY
                    297:
                    298: inline void* operator new[](
                    299:     size_t size,
                    300:     GCPlacement gcp,
                    301:     GCCleanUpFunc cleanup,
                    302:     void* clientData )
                    303: {
                    304:     return ::operator new( size, gcp, cleanup, clientData );}
                    305:
                    306: #endif /* OPERATOR_NEW_ARRAY */
                    307:
                    308:
                    309: #endif /* GC_CPP_H */
                    310:

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>