===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/gc/include/gc_cpp.h,v
retrieving revision 1.1.1.1
retrieving revision 1.5
diff -u -p -r1.1.1.1 -r1.5
--- OpenXM_contrib2/asir2000/gc/include/gc_cpp.h	1999/12/03 07:39:10	1.1.1.1
+++ OpenXM_contrib2/asir2000/gc/include/gc_cpp.h	2003/06/24 05:11:40	1.5
@@ -16,12 +16,11 @@ the code was modified is included with the above copyr
 C++ Interface to the Boehm Collector
 
     John R. Ellis and Jesse Hull 
-    Last modified on Mon Jul 24 15:43:42 PDT 1995 by ellis
 
 This interface provides access to the Boehm collector.  It provides
 basic facilities similar to those described in "Safe, Efficient
 Garbage Collection for C++", by John R. Elis and David L. Detlefs
-(ftp.parc.xerox.com:/pub/ellis/gc).
+(ftp://ftp.parc.xerox.com/pub/ellis/gc).
 
 All heap-allocated objects are either "collectable" or
 "uncollectable".  Programs must explicitly delete uncollectable
@@ -38,7 +37,7 @@ Objects derived from class "gc" are collectable.  For 
     A* a = new A;       // a is collectable. 
 
 Collectable instances of non-class types can be allocated using the GC
-placement:
+(or UseGC) placement:
 
     typedef int A[ 10 ];
     A* a = new (GC) A;
@@ -84,7 +83,7 @@ Cautions:
 1. Be sure the collector has been augmented with "make c++".
 
 2.  If your compiler supports the new "operator new[]" syntax, then
-add -DOPERATOR_NEW_ARRAY to the Makefile.
+add -DGC_OPERATOR_NEW_ARRAY to the Makefile.
 
 If your compiler doesn't support "operator new[]", beware that an
 array of type T, where T is derived from "gc", may or may not be
@@ -124,32 +123,61 @@ invoked using the ANSI-conforming syntax t->~T().  If 
 cfront 3.0, you'll have to comment out the class gc_cleanup, which
 uses explicit invocation.
 
+5. GC name conflicts:
+
+Many other systems seem to use the identifier "GC" as an abbreviation
+for "Graphics Context".  Since version 5.0, GC placement has been replaced
+by UseGC.  GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined.
+
 ****************************************************************************/
 
 #include "gc.h"
 
 #ifndef THINK_CPLUS
-#define _cdecl
+#  define GC_cdecl
+#else
+#  define GC_cdecl _cdecl
 #endif
 
-#if ! defined( OPERATOR_NEW_ARRAY ) \
-    && (__BORLANDC__ >= 0x450 || (__GNUC__ >= 2 && __GNUC_MINOR__ >= 6) \
-        || __WATCOMC__ >= 1050)
-#   define OPERATOR_NEW_ARRAY
+#if ! defined( GC_NO_OPERATOR_NEW_ARRAY ) \
+    && !defined(_ENABLE_ARRAYNEW) /* Digimars */ \
+    && (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \
+	|| (defined(__GNUC__) && \
+	    (__GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 6)) \
+	|| (defined(__WATCOMC__) && __WATCOMC__ < 1050))
+#   define GC_NO_OPERATOR_NEW_ARRAY
 #endif
 
-enum GCPlacement {GC, NoGC, PointerFreeGC};
+#if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY)
+#   define GC_OPERATOR_NEW_ARRAY
+#endif
 
+enum GCPlacement {UseGC,
+#ifndef GC_NAME_CONFLICT
+		  GC=UseGC,
+#endif
+                  NoGC, PointerFreeGC};
+
 class gc {public:
     inline void* operator new( size_t size );
     inline void* operator new( size_t size, GCPlacement gcp );
+    inline void* operator new( size_t size, void *p );
+    	/* Must be redefined here, since the other overloadings	*/
+    	/* hide the global definition.				*/
     inline void operator delete( void* obj );
+#   ifndef __BORLANDC__  /* Confuses the Borland compiler. */
+      inline void operator delete( void*, void* );
+#   endif
 
-#ifdef OPERATOR_NEW_ARRAY
+#ifdef GC_OPERATOR_NEW_ARRAY
     inline void* operator new[]( size_t size );
     inline void* operator new[]( size_t size, GCPlacement gcp );
+    inline void* operator new[]( size_t size, void *p );
     inline void operator delete[]( void* obj );
-#endif /* OPERATOR_NEW_ARRAY */
+#   ifndef __BORLANDC__
+      inline void gc::operator delete[]( void*, void* );
+#   endif
+#endif /* GC_OPERATOR_NEW_ARRAY */
     };    
     /*
     Instances of classes derived from "gc" will be allocated in the 
@@ -160,7 +188,7 @@ class gc_cleanup: virtual public gc {public:
     inline gc_cleanup();
     inline virtual ~gc_cleanup();
 private:
-    inline static void _cdecl cleanup( void* obj, void* clientData );};
+    inline static void GC_cdecl cleanup( void* obj, void* clientData );};
     /*
     Instances of classes derived from "gc_cleanup" will be allocated
     in the collected heap by default.  When the collector discovers an
@@ -170,6 +198,12 @@ class gc_cleanup: virtual public gc {public:
 
 extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
 
+#ifdef _MSC_VER
+  // Disable warning that "no matching operator delete found; memory will
+  // not be freed if initialization throws an exception"
+# pragma warning(disable:4291)
+#endif
+
 inline void* operator new( 
     size_t size, 
     GCPlacement gcp,
@@ -189,8 +223,32 @@ inline void* operator new( 
     classes derived from "gc_cleanup" or containing members derived
     from "gc_cleanup". */
 
-#ifdef OPERATOR_NEW_ARRAY
 
+#ifdef _MSC_VER
+ /** This ensures that the system default operator new[] doesn't get
+  *  undefined, which is what seems to happen on VC++ 6 for some reason
+  *  if we define a multi-argument operator new[].
+  *  There seems to be really redirect new in this environment without
+  *  including this everywhere. 
+  */
+ void *operator new[]( size_t size );
+ 
+ void operator delete[](void* obj);
+
+ void* operator new( size_t size);
+
+ void operator delete(void* obj);
+
+ // This new operator is used by VC++ in case of Debug builds !
+ void* operator new(  size_t size,
+		      int ,//nBlockUse,
+		      const char * szFileName,
+		      int nLine );
+#endif /* _MSC_VER */
+
+
+#ifdef GC_OPERATOR_NEW_ARRAY
+
 inline void* operator new[](
     size_t size, 
     GCPlacement gcp,
@@ -199,7 +257,7 @@ inline void* operator new[](
     /*
     The operator new for arrays, identical to the above. */
 
-#endif /* OPERATOR_NEW_ARRAY */
+#endif /* GC_OPERATOR_NEW_ARRAY */
 
 /****************************************************************************
 
@@ -211,18 +269,24 @@ inline void* gc::operator new( size_t size ) {
     return GC_MALLOC( size );}
     
 inline void* gc::operator new( size_t size, GCPlacement gcp ) {
-    if (gcp == GC) 
+    if (gcp == UseGC) 
         return GC_MALLOC( size );
     else if (gcp == PointerFreeGC)
 	return GC_MALLOC_ATOMIC( size );
     else
         return GC_MALLOC_UNCOLLECTABLE( size );}
 
+inline void* gc::operator new( size_t size, void *p ) {
+    return p;}
+
 inline void gc::operator delete( void* obj ) {
     GC_FREE( obj );}
     
+#ifndef __BORLANDC__
+  inline void gc::operator delete( void*, void* ) {}
+#endif
 
-#ifdef OPERATOR_NEW_ARRAY
+#ifdef GC_OPERATOR_NEW_ARRAY
 
 inline void* gc::operator new[]( size_t size ) {
     return gc::operator new( size );}
@@ -230,14 +294,21 @@ inline void* gc::operator new[]( size_t size ) {
 inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
     return gc::operator new( size, gcp );}
 
+inline void* gc::operator new[]( size_t size, void *p ) {
+    return p;}
+
 inline void gc::operator delete[]( void* obj ) {
     gc::operator delete( obj );}
+
+#ifndef __BORLANDC__
+  inline void gc::operator delete[]( void*, void* ) {}
+#endif
     
-#endif /* OPERATOR_NEW_ARRAY */
+#endif /* GC_OPERATOR_NEW_ARRAY */
 
 
 inline gc_cleanup::~gc_cleanup() {
-    GC_REGISTER_FINALIZER_IGNORE_SELF( GC_base(this), 0, 0, 0, 0 );}
+    GC_register_finalizer_ignore_self( GC_base(this), 0, 0, 0, 0 );}
 
 inline void gc_cleanup::cleanup( void* obj, void* displ ) {
     ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup();}
@@ -246,12 +317,13 @@ inline gc_cleanup::gc_cleanup() {
     GC_finalization_proc oldProc;
     void* oldData;
     void* base = GC_base( (void *) this );
-    if (0 == base) return;
-    GC_REGISTER_FINALIZER_IGNORE_SELF( 
-        base, cleanup, (void*) ((char*) this - (char*) base), 
+    if (0 != base)  {
+      // Don't call the debug version, since this is a real base address.
+      GC_register_finalizer_ignore_self( 
+        base, (GC_finalization_proc)cleanup, (void*) ((char*) this - (char*) base), 
         &oldProc, &oldData );
-    if (0 != oldProc) {
-        GC_REGISTER_FINALIZER_IGNORE_SELF( base, oldProc, oldData, 0, 0 );}}
+      if (0 != oldProc) {
+        GC_register_finalizer_ignore_self( base, oldProc, oldData, 0, 0 );}}}
 
 inline void* operator new( 
     size_t size, 
@@ -261,7 +333,7 @@ inline void* operator new( 
 {
     void* obj;
 
-    if (gcp == GC) {
+    if (gcp == UseGC) {
         obj = GC_MALLOC( size );
         if (cleanup != 0) 
             GC_REGISTER_FINALIZER_IGNORE_SELF( 
@@ -273,7 +345,7 @@ inline void* operator new( 
     return obj;}
         
 
-#ifdef OPERATOR_NEW_ARRAY
+#ifdef GC_OPERATOR_NEW_ARRAY
 
 inline void* operator new[]( 
     size_t size, 
@@ -283,7 +355,7 @@ inline void* operator new[]( 
 {
     return ::operator new( size, gcp, cleanup, clientData );}
 
-#endif /* OPERATOR_NEW_ARRAY */
+#endif /* GC_OPERATOR_NEW_ARRAY */
 
 
 #endif /* GC_CPP_H */