PageRenderTime 347ms CodeModel.GetById 121ms app.highlight 18ms RepoModel.GetById 123ms app.codeStats 0ms

/libs/headers/gc/gc_cpp.h

http://github.com/nddrylliog/ooc
C++ Header | 398 lines | 167 code | 51 blank | 180 comment | 29 complexity | 35d6dd56ba86a96c20ed3e5f31faa069 MD5 | raw file
  1#ifndef GC_CPP_H
  2#define GC_CPP_H
  3/****************************************************************************
  4Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
  5 
  6THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
  7OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
  8 
  9Permission is hereby granted to use or copy this program for any
 10purpose, provided the above notices are retained on all copies.
 11Permission to modify the code and to distribute modified code is
 12granted, provided the above notices are retained, and a notice that
 13the code was modified is included with the above copyright notice.
 14****************************************************************************
 15
 16C++ Interface to the Boehm Collector
 17
 18    John R. Ellis and Jesse Hull 
 19
 20This interface provides access to the Boehm collector.  It provides
 21basic facilities similar to those described in "Safe, Efficient
 22Garbage Collection for C++", by John R. Elis and David L. Detlefs
 23(ftp://ftp.parc.xerox.com/pub/ellis/gc).
 24
 25All heap-allocated objects are either "collectable" or
 26"uncollectable".  Programs must explicitly delete uncollectable
 27objects, whereas the garbage collector will automatically delete
 28collectable objects when it discovers them to be inaccessible.
 29Collectable objects may freely point at uncollectable objects and vice
 30versa.
 31
 32Objects allocated with the built-in "::operator new" are uncollectable.
 33
 34Objects derived from class "gc" are collectable.  For example:
 35
 36    class A: public gc {...};
 37    A* a = new A;       // a is collectable. 
 38
 39Collectable 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
 45Uncollectable instances of classes derived from "gc" can be allocated
 46using the NoGC placement:
 47
 48    class A: public gc {...};
 49    A* a = new (NoGC) A;   // a is uncollectable.
 50
 51The new(PointerFreeGC) syntax allows the allocation of collectable
 52objects that are not scanned by the collector.  This useful if you
 53are allocating compressed data, bitmaps, or network packets.  (In
 54the latter case, it may remove danger of unfriendly network packets
 55intentionally containing values that cause spurious memory retention.)
 56
 57Both uncollectable and collectable objects can be explicitly deleted
 58with "delete", which invokes an object's destructors and frees its
 59storage immediately.
 60
 61A collectable object may have a clean-up function, which will be
 62invoked when the collector discovers the object to be inaccessible.
 63An object derived from "gc_cleanup" or containing a member derived
 64from "gc_cleanup" has a default clean-up function that invokes the
 65object's destructors.  Explicit clean-up functions may be specified as
 66an additional placement argument:
 67
 68    A* a = ::new (GC, MyCleanup) A;
 69
 70An object is considered "accessible" by the collector if it can be
 71reached by a path of pointers from static variables, automatic
 72variables of active functions, or from some object with clean-up
 73enabled; pointers from an object to itself are ignored.
 74
 75Thus, if objects A and B both have clean-up functions, and A points at
 76B, B is considered accessible.  After A's clean-up is invoked and its
 77storage released, B will then become inaccessible and will have its
 78clean-up invoked.  If A points at B and B points to A, forming a
 79cycle, then that's considered a storage leak, and neither will be
 80collectable.  See the interface gc.h for low-level facilities for
 81handling such cycles of objects with clean-up.
 82
 83The collector cannot guarantee that it will find all inaccessible
 84objects.  In practice, it finds almost all of them.
 85
 86
 87Cautions:
 88
 891. Be sure the collector has been augmented with "make c++" or
 90"--enable-cplusplus".
 91
 922.  If your compiler supports the new "operator new[]" syntax, then
 93add -DGC_OPERATOR_NEW_ARRAY to the Makefile.
 94
 95If your compiler doesn't support "operator new[]", beware that an
 96array of type T, where T is derived from "gc", may or may not be
 97allocated as a collectable object (it depends on the compiler).  Use
 98the explicit GC placement to make the array collectable.  For example:
 99
100    class A: public gc {...};
101    A* a1 = new A[ 10 ];        // collectable or uncollectable?
102    A* a2 = new (GC) A[ 10 ];   // collectable
103
1043. The destructors of collectable arrays of objects derived from
105"gc_cleanup" will not be invoked properly.  For example:
106
107    class A: public gc_cleanup {...};
108    A* a = new (GC) A[ 10 ];    // destructors not invoked correctly
109
110Typically, only the destructor for the first element of the array will
111be invoked when the array is garbage-collected.  To get all the
112destructors of any array executed, you must supply an explicit
113clean-up function:
114
115    A* a = new (GC, MyCleanUp) A[ 10 ];
116
117(Implementing clean-up of arrays correctly, portably, and in a way
118that preserves the correct exception semantics requires a language
119extension, e.g. the "gc" keyword.)
120
1214. Compiler bugs (now hopefully history):
122
123* Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the
124destructors of classes derived from gc_cleanup won't be invoked.
125You'll have to explicitly register a clean-up function with
126new-placement syntax.
127
128* Evidently cfront 3.0 does not allow destructors to be explicitly
129invoked using the ANSI-conforming syntax t->~T().  If you're using
130cfront 3.0, you'll have to comment out the class gc_cleanup, which
131uses explicit invocation.
132
1335. GC name conflicts:
134
135Many other systems seem to use the identifier "GC" as an abbreviation
136for "Graphics Context".  Since version 5.0, GC placement has been replaced
137by UseGC.  GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined.
138
139****************************************************************************/
140
141#include "gc.h"
142
143#ifndef THINK_CPLUS
144#  define GC_cdecl
145#else
146#  define GC_cdecl _cdecl
147#endif
148
149#if ! defined( GC_NO_OPERATOR_NEW_ARRAY ) \
150    && !defined(_ENABLE_ARRAYNEW) /* Digimars */ \
151    && (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \
152	|| (defined(__GNUC__) && \
153	    (__GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 6)) \
154	|| (defined(__WATCOMC__) && __WATCOMC__ < 1050))
155#   define GC_NO_OPERATOR_NEW_ARRAY
156#endif
157
158#if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY)
159#   define GC_OPERATOR_NEW_ARRAY
160#endif
161
162#if    ! defined ( __BORLANDC__ )  /* Confuses the Borland compiler. */ \
163    && ! defined ( __sgi )
164#  define GC_PLACEMENT_DELETE
165#endif
166
167enum GCPlacement {UseGC,
168#ifndef GC_NAME_CONFLICT
169		  GC=UseGC,
170#endif
171                  NoGC, PointerFreeGC};
172
173class gc {public:
174    inline void* operator new( size_t size );
175    inline void* operator new( size_t size, GCPlacement gcp );
176    inline void* operator new( size_t size, void *p );
177    	/* Must be redefined here, since the other overloadings	*/
178    	/* hide the global definition.				*/
179    inline void operator delete( void* obj );
180#   ifdef GC_PLACEMENT_DELETE
181      inline void operator delete( void*, GCPlacement );
182      	/* called if construction fails.	*/
183      inline void operator delete( void*, void* );
184#   endif
185
186#ifdef GC_OPERATOR_NEW_ARRAY
187    inline void* operator new[]( size_t size );
188    inline void* operator new[]( size_t size, GCPlacement gcp );
189    inline void* operator new[]( size_t size, void *p );
190    inline void operator delete[]( void* obj );
191#   ifdef GC_PLACEMENT_DELETE
192      inline void operator delete[]( void*, GCPlacement );
193      inline void operator delete[]( void*, void* );
194#   endif
195#endif /* GC_OPERATOR_NEW_ARRAY */
196    };    
197    /*
198    Instances of classes derived from "gc" will be allocated in the 
199    collected heap by default, unless an explicit NoGC placement is
200    specified. */
201
202class gc_cleanup: virtual public gc {public:
203    inline gc_cleanup();
204    inline virtual ~gc_cleanup();
205private:
206    inline static void GC_cdecl cleanup( void* obj, void* clientData );};
207    /*
208    Instances of classes derived from "gc_cleanup" will be allocated
209    in the collected heap by default.  When the collector discovers an
210    inaccessible object derived from "gc_cleanup" or containing a
211    member derived from "gc_cleanup", its destructors will be
212    invoked. */
213
214extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
215
216#ifdef _MSC_VER
217  // Disable warning that "no matching operator delete found; memory will
218  // not be freed if initialization throws an exception"
219# pragma warning(disable:4291)
220#endif
221
222inline void* operator new( 
223    size_t size, 
224    GCPlacement gcp,
225    GCCleanUpFunc cleanup = 0,
226    void* clientData = 0 );
227    /*
228    Allocates a collectable or uncollected object, according to the
229    value of "gcp".
230
231    For collectable objects, if "cleanup" is non-null, then when the
232    allocated object "obj" becomes inaccessible, the collector will
233    invoke the function "cleanup( obj, clientData )" but will not
234    invoke the object's destructors.  It is an error to explicitly
235    delete an object allocated with a non-null "cleanup".
236
237    It is an error to specify a non-null "cleanup" with NoGC or for
238    classes derived from "gc_cleanup" or containing members derived
239    from "gc_cleanup". */
240
241#   ifdef GC_PLACEMENT_DELETE
242      inline void operator delete( void*, GCPlacement, GCCleanUpFunc, void * );
243#   endif
244
245#ifdef _MSC_VER
246 /** This ensures that the system default operator new[] doesn't get
247  *  undefined, which is what seems to happen on VC++ 6 for some reason
248  *  if we define a multi-argument operator new[].
249  *  There seems to be no way to redirect new in this environment without
250  *  including this everywhere. 
251  */
252 void *operator new[]( size_t size );
253 
254 void operator delete[](void* obj);
255
256 void* operator new( size_t size);
257
258 void operator delete(void* obj);
259
260 // This new operator is used by VC++ in case of Debug builds !
261 void* operator new(  size_t size,
262		      int ,//nBlockUse,
263		      const char * szFileName,
264		      int nLine );
265#endif /* _MSC_VER */
266
267
268#ifdef GC_OPERATOR_NEW_ARRAY
269
270inline void* operator new[](
271    size_t size, 
272    GCPlacement gcp,
273    GCCleanUpFunc cleanup = 0,
274    void* clientData = 0 );
275    /*
276    The operator new for arrays, identical to the above. */
277
278#endif /* GC_OPERATOR_NEW_ARRAY */
279
280/****************************************************************************
281
282Inline implementation
283
284****************************************************************************/
285
286inline void* gc::operator new( size_t size ) {
287    return GC_MALLOC( size );}
288    
289inline void* gc::operator new( size_t size, GCPlacement gcp ) {
290    if (gcp == UseGC) 
291        return GC_MALLOC( size );
292    else if (gcp == PointerFreeGC)
293	return GC_MALLOC_ATOMIC( size );
294    else
295        return GC_MALLOC_UNCOLLECTABLE( size );}
296
297inline void* gc::operator new( size_t size, void *p ) {
298    return p;}
299
300inline void gc::operator delete( void* obj ) {
301    GC_FREE( obj );}
302    
303#ifdef GC_PLACEMENT_DELETE
304  inline void gc::operator delete( void*, void* ) {}
305
306  inline void gc::operator delete( void* p, GCPlacement gcp ) {
307    GC_FREE(p);
308  }
309#endif
310
311#ifdef GC_OPERATOR_NEW_ARRAY
312
313inline void* gc::operator new[]( size_t size ) {
314    return gc::operator new( size );}
315    
316inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
317    return gc::operator new( size, gcp );}
318
319inline void* gc::operator new[]( size_t size, void *p ) {
320    return p;}
321
322inline void gc::operator delete[]( void* obj ) {
323    gc::operator delete( obj );}
324
325#ifdef GC_PLACEMENT_DELETE
326  inline void gc::operator delete[]( void*, void* ) {}
327
328  inline void gc::operator delete[]( void* p, GCPlacement gcp ) {
329    gc::operator delete(p); }
330
331#endif
332    
333#endif /* GC_OPERATOR_NEW_ARRAY */
334
335
336inline gc_cleanup::~gc_cleanup() {
337    GC_register_finalizer_ignore_self( GC_base(this), 0, 0, 0, 0 );}
338
339inline void gc_cleanup::cleanup( void* obj, void* displ ) {
340    ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup();}
341
342inline gc_cleanup::gc_cleanup() {
343    GC_finalization_proc oldProc;
344    void* oldData;
345    void* base = GC_base( (void *) this );
346    if (0 != base)  {
347      // Don't call the debug version, since this is a real base address.
348      GC_register_finalizer_ignore_self( 
349        base, (GC_finalization_proc)cleanup, (void*) ((char*) this - (char*) base), 
350        &oldProc, &oldData );
351      if (0 != oldProc) {
352        GC_register_finalizer_ignore_self( base, oldProc, oldData, 0, 0 );}}}
353
354inline void* operator new( 
355    size_t size, 
356    GCPlacement gcp,
357    GCCleanUpFunc cleanup,
358    void* clientData )
359{
360    void* obj;
361
362    if (gcp == UseGC) {
363        obj = GC_MALLOC( size );
364        if (cleanup != 0) 
365            GC_REGISTER_FINALIZER_IGNORE_SELF( 
366                obj, cleanup, clientData, 0, 0 );}
367    else if (gcp == PointerFreeGC) {
368        obj = GC_MALLOC_ATOMIC( size );}
369    else {
370        obj = GC_MALLOC_UNCOLLECTABLE( size );};
371    return obj;}
372        
373# ifdef GC_PLACEMENT_DELETE
374inline void operator delete ( 
375    void *p, 
376    GCPlacement gcp,
377    GCCleanUpFunc cleanup,
378    void* clientData )
379{
380    GC_FREE(p);
381}
382# endif
383
384#ifdef GC_OPERATOR_NEW_ARRAY
385
386inline void* operator new[]( 
387    size_t size, 
388    GCPlacement gcp,
389    GCCleanUpFunc cleanup,
390    void* clientData )
391{
392    return ::operator new( size, gcp, cleanup, clientData );}
393
394#endif /* GC_OPERATOR_NEW_ARRAY */
395
396
397#endif /* GC_CPP_H */
398