Annotation of OpenXM_contrib2/asir2000/gc/include/gc_cpp.h, Revision 1.5
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
1.2 noro 23: (ftp://ftp.parc.xerox.com/pub/ellis/gc).
1.1 noro 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
1.2 noro 40: (or UseGC) placement:
1.1 noro 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
1.4 noro 86: add -DGC_OPERATOR_NEW_ARRAY to the Makefile.
1.1 noro 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:
1.2 noro 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:
1.1 noro 132: ****************************************************************************/
133:
134: #include "gc.h"
135:
136: #ifndef THINK_CPLUS
1.5 ! noro 137: # define GC_cdecl
! 138: #else
! 139: # define GC_cdecl _cdecl
1.1 noro 140: #endif
141:
1.4 noro 142: #if ! defined( GC_NO_OPERATOR_NEW_ARRAY ) \
143: && !defined(_ENABLE_ARRAYNEW) /* Digimars */ \
144: && (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \
145: || (defined(__GNUC__) && \
146: (__GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 6)) \
147: || (defined(__WATCOMC__) && __WATCOMC__ < 1050))
148: # define GC_NO_OPERATOR_NEW_ARRAY
149: #endif
150:
151: #if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY)
152: # define GC_OPERATOR_NEW_ARRAY
1.1 noro 153: #endif
154:
1.2 noro 155: enum GCPlacement {UseGC,
156: #ifndef GC_NAME_CONFLICT
157: GC=UseGC,
158: #endif
159: NoGC, PointerFreeGC};
1.1 noro 160:
161: class gc {public:
162: inline void* operator new( size_t size );
163: inline void* operator new( size_t size, GCPlacement gcp );
1.4 noro 164: inline void* operator new( size_t size, void *p );
165: /* Must be redefined here, since the other overloadings */
166: /* hide the global definition. */
1.1 noro 167: inline void operator delete( void* obj );
1.5 ! noro 168: # ifndef __BORLANDC__ /* Confuses the Borland compiler. */
! 169: inline void operator delete( void*, void* );
! 170: # endif
1.1 noro 171:
1.4 noro 172: #ifdef GC_OPERATOR_NEW_ARRAY
1.1 noro 173: inline void* operator new[]( size_t size );
174: inline void* operator new[]( size_t size, GCPlacement gcp );
1.4 noro 175: inline void* operator new[]( size_t size, void *p );
1.1 noro 176: inline void operator delete[]( void* obj );
1.5 ! noro 177: # ifndef __BORLANDC__
! 178: inline void gc::operator delete[]( void*, void* );
! 179: # endif
1.4 noro 180: #endif /* GC_OPERATOR_NEW_ARRAY */
1.1 noro 181: };
182: /*
183: Instances of classes derived from "gc" will be allocated in the
184: collected heap by default, unless an explicit NoGC placement is
185: specified. */
186:
187: class gc_cleanup: virtual public gc {public:
188: inline gc_cleanup();
189: inline virtual ~gc_cleanup();
190: private:
1.5 ! noro 191: inline static void GC_cdecl cleanup( void* obj, void* clientData );};
1.1 noro 192: /*
193: Instances of classes derived from "gc_cleanup" will be allocated
194: in the collected heap by default. When the collector discovers an
195: inaccessible object derived from "gc_cleanup" or containing a
196: member derived from "gc_cleanup", its destructors will be
197: invoked. */
198:
199: extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
200:
1.2 noro 201: #ifdef _MSC_VER
202: // Disable warning that "no matching operator delete found; memory will
203: // not be freed if initialization throws an exception"
204: # pragma warning(disable:4291)
205: #endif
206:
1.1 noro 207: inline void* operator new(
208: size_t size,
209: GCPlacement gcp,
210: GCCleanUpFunc cleanup = 0,
211: void* clientData = 0 );
212: /*
213: Allocates a collectable or uncollected object, according to the
214: value of "gcp".
215:
216: For collectable objects, if "cleanup" is non-null, then when the
217: allocated object "obj" becomes inaccessible, the collector will
218: invoke the function "cleanup( obj, clientData )" but will not
219: invoke the object's destructors. It is an error to explicitly
220: delete an object allocated with a non-null "cleanup".
221:
222: It is an error to specify a non-null "cleanup" with NoGC or for
223: classes derived from "gc_cleanup" or containing members derived
224: from "gc_cleanup". */
225:
226:
1.2 noro 227: #ifdef _MSC_VER
228: /** This ensures that the system default operator new[] doesn't get
229: * undefined, which is what seems to happen on VC++ 6 for some reason
230: * if we define a multi-argument operator new[].
231: * There seems to be really redirect new in this environment without
232: * including this everywhere.
233: */
1.4 noro 234: void *operator new[]( size_t size );
235:
236: void operator delete[](void* obj);
237:
238: void* operator new( size_t size);
1.2 noro 239:
1.4 noro 240: void operator delete(void* obj);
1.2 noro 241:
1.4 noro 242: // This new operator is used by VC++ in case of Debug builds !
243: void* operator new( size_t size,
1.2 noro 244: int ,//nBlockUse,
245: const char * szFileName,
1.4 noro 246: int nLine );
247: #endif /* _MSC_VER */
248:
1.2 noro 249:
1.4 noro 250: #ifdef GC_OPERATOR_NEW_ARRAY
1.2 noro 251:
1.1 noro 252: inline void* operator new[](
253: size_t size,
254: GCPlacement gcp,
255: GCCleanUpFunc cleanup = 0,
256: void* clientData = 0 );
257: /*
258: The operator new for arrays, identical to the above. */
259:
1.4 noro 260: #endif /* GC_OPERATOR_NEW_ARRAY */
1.1 noro 261:
262: /****************************************************************************
263:
264: Inline implementation
265:
266: ****************************************************************************/
267:
268: inline void* gc::operator new( size_t size ) {
269: return GC_MALLOC( size );}
270:
271: inline void* gc::operator new( size_t size, GCPlacement gcp ) {
1.2 noro 272: if (gcp == UseGC)
1.1 noro 273: return GC_MALLOC( size );
274: else if (gcp == PointerFreeGC)
275: return GC_MALLOC_ATOMIC( size );
276: else
277: return GC_MALLOC_UNCOLLECTABLE( size );}
278:
1.4 noro 279: inline void* gc::operator new( size_t size, void *p ) {
280: return p;}
281:
1.1 noro 282: inline void gc::operator delete( void* obj ) {
283: GC_FREE( obj );}
284:
1.5 ! noro 285: #ifndef __BORLANDC__
! 286: inline void gc::operator delete( void*, void* ) {}
! 287: #endif
1.1 noro 288:
1.4 noro 289: #ifdef GC_OPERATOR_NEW_ARRAY
1.1 noro 290:
291: inline void* gc::operator new[]( size_t size ) {
292: return gc::operator new( size );}
293:
294: inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
295: return gc::operator new( size, gcp );}
296:
1.4 noro 297: inline void* gc::operator new[]( size_t size, void *p ) {
298: return p;}
299:
1.1 noro 300: inline void gc::operator delete[]( void* obj ) {
301: gc::operator delete( obj );}
1.4 noro 302:
1.5 ! noro 303: #ifndef __BORLANDC__
! 304: inline void gc::operator delete[]( void*, void* ) {}
! 305: #endif
1.1 noro 306:
1.4 noro 307: #endif /* GC_OPERATOR_NEW_ARRAY */
1.1 noro 308:
309:
310: inline gc_cleanup::~gc_cleanup() {
1.5 ! noro 311: GC_register_finalizer_ignore_self( GC_base(this), 0, 0, 0, 0 );}
1.1 noro 312:
313: inline void gc_cleanup::cleanup( void* obj, void* displ ) {
314: ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup();}
315:
316: inline gc_cleanup::gc_cleanup() {
317: GC_finalization_proc oldProc;
318: void* oldData;
319: void* base = GC_base( (void *) this );
1.2 noro 320: if (0 != base) {
1.4 noro 321: // Don't call the debug version, since this is a real base address.
322: GC_register_finalizer_ignore_self(
1.2 noro 323: base, (GC_finalization_proc)cleanup, (void*) ((char*) this - (char*) base),
1.1 noro 324: &oldProc, &oldData );
1.2 noro 325: if (0 != oldProc) {
1.4 noro 326: GC_register_finalizer_ignore_self( base, oldProc, oldData, 0, 0 );}}}
1.1 noro 327:
328: inline void* operator new(
329: size_t size,
330: GCPlacement gcp,
331: GCCleanUpFunc cleanup,
332: void* clientData )
333: {
334: void* obj;
335:
1.2 noro 336: if (gcp == UseGC) {
1.1 noro 337: obj = GC_MALLOC( size );
338: if (cleanup != 0)
339: GC_REGISTER_FINALIZER_IGNORE_SELF(
340: obj, cleanup, clientData, 0, 0 );}
341: else if (gcp == PointerFreeGC) {
342: obj = GC_MALLOC_ATOMIC( size );}
343: else {
344: obj = GC_MALLOC_UNCOLLECTABLE( size );};
345: return obj;}
346:
347:
1.4 noro 348: #ifdef GC_OPERATOR_NEW_ARRAY
1.1 noro 349:
350: inline void* operator new[](
351: size_t size,
352: GCPlacement gcp,
353: GCCleanUpFunc cleanup,
354: void* clientData )
355: {
356: return ::operator new( size, gcp, cleanup, clientData );}
357:
1.4 noro 358: #endif /* GC_OPERATOR_NEW_ARRAY */
1.1 noro 359:
360:
361: #endif /* GC_CPP_H */
362:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gc_cpp.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc / include