Attempt to cleanup fast enumeration handling and improve support for gcc on mingw

Author: rfm

Headers/GNUstepBase/GNUstep.h

@@ -24,29 +24,8 @@
 #ifndef __GNUSTEP_GNUSTEP_H_INCLUDED_
 #define __GNUSTEP_GNUSTEP_H_INCLUDED_
 
-/* Check to see if this is a MINGW build
- */
-#if	defined(__MINGW32__) || defined(__MINGW64__)
-#  if	!defined(__MINGW__)
-#    define __MINGW__
-#  endif
-#endif
-
-#if !defined(GS_GCC_MINREQ)
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && !defined(__clang__)
-#  define GS_GCC_MINREQ(maj, min) \
-  ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
-#else
-#  define GS_GCC_MINREQ(maj, min) 0
-#endif
-
-#if defined(__clang__)
-#  define GS_CLANG_MINREQ(maj, min) \
-  ((__clang_major__ << 16) + __clang_minor__ >= ((maj) << 16) + (min))
-#else
-#  define GS_CLANG_MINREQ(maj, min) 0
-#endif
-#endif /* GS_GCC_MINREQ */
+#import	"GNUstepBase/GSConfig.h"
+#import	"GNUstepBase/GSVersionMacros.h"
 
 /* The contents of this file are designed to be usable with either
  * GNUstep-base or MacOS-X Foundation.
@@ -465,9 +444,14 @@ void *__object = (void*)(object);\
 #define GSLocalizedStaticString(key, comment) key
 
 /**
+ * <p>
+ *   This function (macro) is a GNUstep extension.
+ * </p>
+ * <p>
  * To be used inside a method for making sure that a range does not specify
  * anything outside the size of an array/string.  Raises exception if range
  * extends beyond [0,size]. Size must be an unsigned integer (NSUInteger).
+ * </p>
  */
 #define GS_RANGE_CHECK(RANGE, SIZE) \
   if (RANGE.location > (NSUInteger)SIZE \
@@ -486,37 +470,40 @@ if ((NSUInteger)INDEX >= (NSUInteger)OVER) \
     GSNameFromSelector(_cmd), (NSUInteger)INDEX]
 
 
-#if	defined(__clang__) || (GS_GCC_MINREQ(6,1) && !defined(__MINGW__))
-/** Macro to support fast enumeration on older compilers.  The argument are
+#if	defined(__clang__) \
+  || (GS_HAVE_FAST_ENUMERATION \
+    && (GS_HAVE_FAST_ENUMERATION_SETTER || !defined(__MINGW__)))
+/** <p>This function (macro) is a GNUstep extension.</p>
+ * <p>
+ * Macro to support fast enumeration on platforms where the compiler or
+ * runtime do not support fast enumeration directly. The argument are
  * a type specification for the value returned by the iteration, the name of
  * a variable to hold that value, and the collection to be iterated over
- * (may also be an instance of [NSEnumerator] rather than a collection).
+ * (may also be an instance of [NSEnumerator] rather than a collection).<br />
+ * On a compiler/runtime with fast enumeration support, this macro starts
+ * the fast enumeration block.
+ * </p>
  */
 #define GS_FOR_IN(type, var, collection) \
   for (type var in collection)\
   {
-/** Macro to end a fast enumeration block on older compilers.  Its argument
- * must be identical to that of the corresponding GS_FOR_IN macro. 
- * On a more modern compiler this just ends the fast enumeration block.
+/** <p>This function (macro) is a GNUstep extension.</p>
+ * <p>
+ * Macro to end a fast enumeration block on older compilers.  Its argument
+ * must be identical to that of the corresponding GS_FOR_IN macro.<br />
+ * On a compiler/runtime with fast enumeration support, this just ends
+ * the fast enumeration block.
+ * </p>
  */
 #define GS_END_FOR(collection) }
 #else
 
-/* This is the code for the older compilers (and for systems where we can't
- * override the mutation handling function safely).
- * We declare the function to be called when a mutation of a collection is
- * detected during fast enumeration.  If possible we use the standard one
- * provided by the runtime, otherwise we use one provided by GNUstep-base.
+/* We declare the function to be called when a mutation of a collection is
+ * detected during fast enumeration; provided by GNUstep-base.
  */
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wattributes"
-#if	defined(__MINGW__)
-#define	USE_GSEnumerationMutation	1	/* Tells NSObject.m */ 
 void GSEnumerationMutation(id);
-#else
-void objc_enumerationMutation(id);
-#define	GSEnumerationMutation(X) objc_enumerationMutation(X)
-#endif
 #pragma GCC diagnostic pop
 
 #define GS_FOR_IN(type, var, c) \

Headers/GNUstepBase/GSConfig.h.in

@@ -272,6 +272,8 @@ typedef	struct {
 #define GS_USE_LIBCURL @HAVE_LIBCURL@
 #define GS_USE_LIBDISPATCH @HAVE_LIBDISPATCH@
 #define GS_USE_LIBDISPATCH_RUNLOOP @HAVE_LIBDISPATCH_RUNLOOP@
+#define GS_HAVE_FAST_ENUMERATION @OBJCFASTENUMERATION@
+#define GS_HAVE_FAST_ENUMERATION_SETTER @OBJCSETFASTENUMERATION@
 #define GS_HAVE_NSURLSESSION @GS_HAVE_NSURLSESSION@
 #define GS_HAVE_OBJC_ROOT_CLASS_ATTR @GS_HAVE_OBJC_ROOT_CLASS_ATTR@
 #define GS_USE_WIN32_THREADS_AND_LOCKS @HAVE_WIN32_THREADS_AND_LOCKS@

Headers/GNUstepBase/GSVersionMacros.h

@@ -24,6 +24,8 @@
 #ifndef __GNUSTEP_GSVERSIONMACROS_H_INCLUDED_
 #define __GNUSTEP_GSVERSIONMACROS_H_INCLUDED_
 
+#import	"GNUstepBase/GSConfig.h"
+
 /* By default we defined NO_GNUSTEP to 0 so that we will include extensions.
  */
 #if	!defined(NO_GNUSTEP)

Source/NSObject.m

@@ -84,30 +84,37 @@
 #endif
 #endif
 
-#if	defined(USE_GSEnumerationMutation)
 /* GSEnumerationMutation() is called whenever a collection mutates in the
- * middle of fast enumeration which was not supported by the compiler and
- * where we need to use our own function name because the runtime library
- * contains a symbol which would conflict with the normal name (platforms
- * where weak symbols don't work reliably).
+ * middle of fast enumeration.
  */
 void GSEnumerationMutation(id obj)
 {
   [NSException raise: NSGenericException 
     format: @"Collection %@ was mutated while being enumerated", obj];
 }
-#else
-/* objc_enumerationMutation() is called whenever a collection mutates in the
- * middle of fast enumeration.  We need to have this defined and linked into
- * any code that uses fast enumeration, so we define it in NSObject.h
- * This symbol is exported to take precedence over the weak symbol provided
- * by the runtime library.
- */
-GS_EXPORT void objc_enumerationMutation(id obj)
-{
-  [NSException raise: NSGenericException 
-    format: @"Collection %@ was mutated while being enumerated", obj];
-}
+
+#if	GS_HAVE_FAST_ENUMERATION
+  /* If possible we will ask the runtime to call our handler.
+   */
+# if	GS_HAVE_FAST_ENUMERATION_SETTER
+    extern void objc_setEnumerationMutationHandler(void (*handler)(id));
+# else
+    /* Otherwise, we can override a weak symbol in the runtime on platforms
+     * which support it (not reliable with DLLs in mingw).
+     */
+#   if	!defined(__MINGW__)
+      /* objc_enumerationMutation() is called whenever a collection mutates
+       * in the middle of fast enumeration.  We need to have this defined
+       * and linked into any code that uses fast enumeration.
+       * This symbol is exported to take precedence over the weak symbol
+       * provided by the runtime library.
+       */
+      GS_EXPORT void objc_enumerationMutation(id obj)
+      {
+	GSEnumerationMutation(obj);
+      }
+#   endif
+# endif
 #endif
 
 /* platforms which do not support weak */
@@ -1021,6 +1028,12 @@ + (void) initialize
 {
   if (self == [NSObject class])
     {
+#if	GS_HAVE_FAST_ENUMERATION_SETTER
+      /* Tell runtime to pass enumeration mutation detection handling to us.
+       */
+      objc_setEnumerationMutationHandler(GSEnumerationMutation);
+#endif
+
 #ifdef _WIN32
       /* Start of sockets so we can get host name and other info */
       WORD wVersionRequested = MAKEWORD(2, 2);