Add implementation of Objective-C class name uniquifying.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@46226 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

configure

@@ -1657,6 +1657,7 @@ Optional Features:
   --enable-compat26       enable wxWidgets 2.6 compatibility
   --disable-compat28      disable wxWidgets 2.8 compatibility
   --disable-rpath         disable use of rpath for uninstalled builds
+  --enable-objc_uniquifying enable Objective-C class name uniquifying
   --enable-intl           use internationalization system
   --enable-config         use wxConfig (and derived) classes
   --enable-protocols      use wxProtocol and derived classes
@@ -3362,6 +3363,8 @@ else
     DEFAULT_wxUSE_GTK2=yes
 fi
 
+DEFAULT_wxUSE_OBJC_UNIQUIFYING=no
+
 
 
 
@@ -5394,6 +5397,47 @@ echo "${ECHO_T}no" >&6; }
 
 
 
+          enablestring=
+          { echo "$as_me:$LINENO: checking for --${enablestring:-enable}-objc_uniquifying" >&5
+echo $ECHO_N "checking for --${enablestring:-enable}-objc_uniquifying... $ECHO_C" >&6; }
+          no_cache=0
+          # Check whether --enable-objc_uniquifying was given.
+if test "${enable_objc_uniquifying+set}" = set; then
+  enableval=$enable_objc_uniquifying;
+                          if test "$enableval" = yes; then
+                            ac_cv_use_objc_uniquifying='wxUSE_OBJC_UNIQUIFYING=yes'
+                          else
+                            ac_cv_use_objc_uniquifying='wxUSE_OBJC_UNIQUIFYING=no'
+                          fi
+
+else
+
+                          LINE=`grep "^wxUSE_OBJC_UNIQUIFYING=" ${wx_arg_cache_file}`
+                          if test "x$LINE" != x ; then
+                            eval "DEFAULT_$LINE"
+                          else
+                            no_cache=1
+                          fi
+
+                          ac_cv_use_objc_uniquifying='wxUSE_OBJC_UNIQUIFYING='$DEFAULT_wxUSE_OBJC_UNIQUIFYING
+
+fi
+
+
+          eval "$ac_cv_use_objc_uniquifying"
+          if test "$no_cache" != 1; then
+            echo $ac_cv_use_objc_uniquifying >> ${wx_arg_cache_file}.tmp
+          fi
+
+          if test "$wxUSE_OBJC_UNIQUIFYING" = yes; then
+            { echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+          else
+            { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+          fi
+
+
 
 
           enablestring=
@@ -22712,13 +22756,11 @@ _ACEOF
 cat confdefs.h >>conftest.$ac_ext
 cat >>conftest.$ac_ext <<_ACEOF
 /* end confdefs.h.  */
-#include <sys/types.h> /* for off_t */
+#include <stdio.h>
-     #include <stdio.h>
 int
 main ()
 {
-int (*fp) (FILE *, off_t, int) = fseeko;
+return fseeko (stdin, 0, 0) && (fseeko) (stdin, 0, 0);
-     return fseeko (stdin, 0, 0) && fp (stdin, 0, 0);
   ;
   return 0;
 }
@@ -22758,13 +22800,11 @@ cat confdefs.h >>conftest.$ac_ext
 cat >>conftest.$ac_ext <<_ACEOF
 /* end confdefs.h.  */
 #define _LARGEFILE_SOURCE 1
-#include <sys/types.h> /* for off_t */
+#include <stdio.h>
-     #include <stdio.h>
 int
 main ()
 {
-int (*fp) (FILE *, off_t, int) = fseeko;
+return fseeko (stdin, 0, 0) && (fseeko) (stdin, 0, 0);
-     return fseeko (stdin, 0, 0) && fp (stdin, 0, 0);
   ;
   return 0;
 }
@@ -42245,6 +42285,12 @@ _ACEOF
 
 fi
 
+if test "$wxUSE_OBJC_UNIQUIFYING" = "yes"; then
+  cat >>confdefs.h <<\_ACEOF
+#define wxUSE_OBJC_UNIQUIFYING 1
+_ACEOF
+
+fi
 
 
 if test "$wxUSE_DATETIME" = "yes"; then

configure.in

@@ -828,6 +828,9 @@ else
   DEFAULT_wxUSE_GTK2=yes
 fi
 
+dnl Always default to no. Only special cases require this.
+DEFAULT_wxUSE_OBJC_UNIQUIFYING=no
+
 
 dnl WX_ARG_WITH should be used to select whether an external package will be
 dnl used or not, to configure compile-time features of this package itself,
@@ -951,6 +954,7 @@ WX_ARG_ENABLE(compat28,      [  --disable-compat28      disable wxWidgets 2.8 co
 
 WX_ARG_ENABLE(rpath,         [  --disable-rpath         disable use of rpath for uninstalled builds], wxUSE_RPATH)
 
+WX_ARG_ENABLE(objc_uniquifying,[  --enable-objc_uniquifying enable Objective-C class name uniquifying], wxUSE_OBJC_UNIQUIFYING)
 
 dnl ---------------------------------------------------------------------------
 dnl (small) optional non GUI classes
@@ -6073,6 +6077,9 @@ if test "$wxUSE_PRINTF_POS_PARAMS" = "yes"; then
   AC_DEFINE(wxUSE_PRINTF_POS_PARAMS)
 fi
 
+if test "$wxUSE_OBJC_UNIQUIFYING" = "yes"; then
+  AC_DEFINE(wxUSE_OBJC_UNIQUIFYING)
+fi
 
 dnl ---------------------------------------------------------------------------
 dnl time/date functions

include/wx/cocoa/objc/objc_uniquifying.h

@@ -0,0 +1,291 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/cocoa/objc/objc_uniquifying.h
+// Purpose:     Allows wxWidgets code to get a direct pointer to a compiled
+//              Objective-C class and provides a method to fix up the
+//              name to include a unique identifier (currently the address
+//              of the objc_class structure).
+// Author:      David Elliott <dfe@cox.net>
+// Modified by:
+// Created:     2007/05/15
+// RCS-ID:      $Id$
+// Copyright:   (c) 2007 Software 2000 Ltd.
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_OBJC_CLASS_H__
+#define __WX_COCOA_OBJC_CLASS_H__
+
+#if wxUSE_OBJC_UNIQUIFYING
+
+// objc_getClass and stuff
+#include <objc/objc-runtime.h>
+
+////////////// Objective-C uniquifying implementation //////////////
+
+template <typename ObjcType>
+class wxObjcClassInitializer;
+
+template <typename ObjcType>
+class UniquifiedName;
+
+template <typename ObjcType>
+class wxObjcCompilerInformation
+{
+    friend class wxObjcClassInitializer<ObjcType>;
+    friend class UniquifiedName<ObjcType>;
+private:
+    // GetCompiledClass must be partially specialized for an ObjcType
+    // If you're not using it, implement an inline returning NULL
+    inline static struct objc_class * GetCompiledClass();
+
+    // sm_theClassName must be partially specialized for each type
+    static const char sm_theClassName[];
+
+    // GetSuperclass must be specialized. Typically one of two ways:
+    // 1. objc_getClass("SomeRealClassName")
+    // 2. wxGetObjcClass_SomeWxClassName();
+    inline static struct objc_class *GetSuperclass();
+};
+
+
+template <typename ObjcType>
+struct UniquifiedName
+{
+    // We're going for OriginalClassName@ClassStructureAddress
+    // Therefore our size is the sizeof the original class name constant string (which includes the terminating NULL)
+    // plus the sizeof a pointer to struct objc_class times two (two hex digits for each byte) plus 3 for "@0x"
+    typedef char Type[sizeof(wxObjcCompilerInformation<ObjcType>::sm_theClassName) + (sizeof(struct objc_class*)<<1) + 3];
+    static void Init(Type m_theString, const objc_class *aClass)
+    {
+        snprintf(const_cast<char*>(m_theString), sizeof(Type), "%s@%p", wxObjcCompilerInformation<ObjcType>::sm_theClassName, aClass);
+    }
+};
+
+template <typename ObjcType>
+class wxObjcClassInitializer
+{
+public:
+    static struct objc_class* Get()
+    {
+        static wxObjcClassInitializer<ObjcType> s_theInstance;
+        s_theInstance.noop(); // Make the compiler think we need this instance
+        return wxObjcCompilerInformation<ObjcType>::GetCompiledClass();
+    }
+private:
+    void noop()
+    {}
+    // This "constructor" operates solely on static data
+    // It exists so that we can take advantage of a function-static
+    // "instance" of this class to do the static data initialization.
+    wxObjcClassInitializer()
+    {
+        // Objective-C class initialization occurs before C++ static initialization because the
+        // libobjc.dylib gets notified directly by dyld on Tiger.
+        // Therefore, even though we change the name, the class is still registered with the
+        // original name.  We unfortunately can't change that.
+
+        // The first time the class is loaded, Objective-C will already have fixed up the super_class
+        // and isa->isa and isa->super_class variables so much of this won't do anything.  But
+        // the next time the class is loaded, Objective-C will ignore it and thus we need to
+        // initialize the data structures appropriately.
+
+        // Ideally we'd have some sort of lock here, but we depend on the fact that we get called
+        // just before the first time someone wants to send a class message so it should be
+        // reasonably safe to do this without any locks.
+
+        struct objc_class &theClassData = *wxObjcCompilerInformation<ObjcType>::GetCompiledClass();
+        // Initialize the uniquified class name
+        UniquifiedName<ObjcType>::Init(sm_theUniquifiedClassName, &theClassData);
+
+        //////// Class Initialization ////////
+        // Use objc_getClass to fix up the superclass pointer
+        theClassData.super_class = wxObjcCompilerInformation<ObjcType>::GetSuperclass();
+        // Fix up the compiler generated class struct to use the new name
+        theClassData.name = sm_theUniquifiedClassName;
+
+        //////// Meta-Class Initialization ////////
+        // theClassData.isa is the metaclass pointer
+        // Globals on Darwin use PC-relative access (slow) so it's quicker to use theClassData.isa
+
+        // In any object hierarchy a metaclass's metaclass is always the root class's metaclass
+        // Therefore, our superclass's metaclass's metaclass should already be the root class's metaclass
+        theClassData.isa->isa = theClassData.super_class->isa->isa;
+        // A metaclass's superclass is always the superclass's metaclass.
+        theClassData.isa->super_class = theClassData.super_class->isa;
+        // Fix up the compiler generated metaclass struct to use the new name
+        theClassData.isa->name = sm_theUniquifiedClassName;
+
+        // We need to set the initialized flag because after we change the name, Objective-C can't
+        // look us up by name because we're only registered with the original name.
+        theClassData.isa->info |= CLS_INITIALIZED;
+    }
+    wxObjcClassInitializer(const wxObjcClassInitializer&); // NO COPY
+    wxObjcClassInitializer& operator =(const wxObjcClassInitializer&); // NO ASSIGN
+    static typename UniquifiedName<ObjcType>::Type sm_theUniquifiedClassName;
+};
+
+template<typename ObjcType>
+typename UniquifiedName<ObjcType>::Type wxObjcClassInitializer<ObjcType>::sm_theUniquifiedClassName;
+
+// WX_DECLARE_GET_OBJC_CLASS
+// Declares a function to get a direct pointer to an objective-C class.
+// The class is guaranteed to be usable.
+// When wxCocoa is built into a Mach-O bundle this function allows the wxCocoa
+// code to get a reference to the Objective-C class structure located in the
+// same bundle.  This allows a static wxCocoa library to be built into
+// two different Mach-O bundles without having one bundle's Objective-C
+// classes trample on the other's.
+// Right now we toss the ObjcSuperClass parameter, but we might use it later.
+#define WX_DECLARE_GET_OBJC_CLASS(ObjcClass,ObjcSuperClass) \
+struct objc_class* wx_GetObjcClass_ ## ObjcClass();
+
+// WX_IMPLEMENT_OBJC_GET_COMPILED_CLASS(ObjcClass)
+// Provides an architecture-dependent way to get the direct pointer to the
+// objc_class structure in the __OBJC segment.
+// This takes advantage of the fact that the Objective-C compiler uses guessable
+// local assembler labels for the class structures.
+// Those class structures are only available on the Objective-C file containing the
+// @implementation block.
+
+#if 1
+// Generic implementation - Tested on i386 and PPC.  Should work in all cases.
+// This is a hack that depends on GCC asm symbol names.
+// The static variable winds up being initialized with a direct reference to the appropriate
+// L_OBJC_CLASS and no global symbol reference is generated because nothing uses the global symbol
+// except for the static initializer which does it directly.
+// The generated assembler for s_objc_class_ptr is basically like this:
+// _s_objc_class_ptr_ObjcClass:
+//     .long L_OBJC_CLASS_ObjcClass
+// Once that static symbol is defined, the function implementation is easy for GCC to generate.
+// Do note that return &s_objc_class_data_ObjcClass won't work.  The code is wrong in the case.
+#define WX_IMPLEMENT_OBJC_GET_COMPILED_CLASS(ObjcClass) \
+extern "C" objc_class s_objc_class_data_ ## ObjcClass asm("L_OBJC_CLASS_" #ObjcClass); \
+static objc_class * s_objc_class_ptr_ ## ObjcClass = &s_objc_class_data_ ## ObjcClass; \
+template<> \
+inline objc_class * wxObjcCompilerInformation<ObjcClass>::GetCompiledClass() \
+{ \
+    return s_objc_class_ptr_## ObjcClass; \
+}
+
+#elif defined(__i386__)
+// Not used because the generic implementation seems to work fine.
+// But this is here since it was written beforehand and it also works.
+
+// This is based on the code GCC generates for accessing file-static data on i386.
+// The i386 PC-relative addressing happens in this manner
+// 1. The program counter is placed into ecx using the code that GCC should have
+//    already generated.
+// 2. A label is placed directly after the call to get the program counter.
+// 3. The Load Effective Address instruction is used to add the offset of the
+//    local assembler label we're interested in minus the local assembler label
+//    from step 2 to the program counter register in ecx and place the result
+//    into the result register (typically eax if not inlined).
+#define WX_IMPLEMENT_OBJC_GET_COMPILED_CLASS(ObjcClass) \
+template<> \
+inline objc_class * wxObjcCompilerInformation<ObjcClass>::GetCompiledClass() \
+{ \
+    register struct objc_class *retval; \
+    asm \
+    (   "call ___i686.get_pc_thunk.cx\n" \
+        "\"LPC_FOR_GET_CLASS_" #ObjcClass "\":\n\t" \
+        "leal L_OBJC_CLASS_" #ObjcClass "-\"LPC_FOR_GET_CLASS_" #ObjcClass "\"(%%ecx), %0" \
+    :   "=r"(retval) \
+    :    \
+    :   "ecx" \
+    ); \
+    return retval; \
+}
+
+#elif defined(__ppc__)
+// Not used because the generic implementation seems to work fine.
+// But this is here since it was written beforehand and it also works.
+
+// This is based on the code GCC generates for accessing file-static data on PPC.
+// The PowerPC PC-relative addressing happens in this manner
+// 1. The link register is saved (mflr) to a temporary (we re-use the output register for this)
+// 2. An unconditional branch instruction (bcl) "branches" to the following address (labeled)
+// 3. The link register (filled in by bcl) is saved to r10 (a temporary)
+// 4. The previous link register is restored (mtlr) (from the output register we were using as a temporary)
+// 5. The address of the LPC label as executed is added to the high 16 bits of the offset between that label and the static data we want
+//    and stored in a temporary register (r2)
+// 6. That temporary register plus the low 16 bits of the offset are stored into the result register.
+#define WX_IMPLEMENT_OBJC_GET_COMPILED_CLASS(ObjcClass) \
+template<> \
+inline objc_class * wxObjcCompilerInformation<ObjcClass>::GetCompiledClass() \
+{ \
+    register struct objc_class *retval; \
+    asm \
+    (   "mflr %0" \
+        "\n\tbcl 20, 31, \"LPC_FOR_GET_CLASS_" #ObjcClass "\"" \
+        "\n\"LPC_FOR_GET_CLASS_" #ObjcClass "\":" \
+        "\n\tmflr r10" \
+        "\n\tmtlr %0" \
+        "\n\taddis r2,r10,ha16(L_OBJC_CLASS_" #ObjcClass "-\"LPC_FOR_GET_CLASS_" #ObjcClass "\")" \
+        "\n\tla %0,lo16(L_OBJC_CLASS_" #ObjcClass "-\"LPC_FOR_GET_CLASS_" #ObjcClass "\")(r2)" \
+    :   "=r" (retval) \
+    : \
+    :   "r10","r2" \
+    ); \
+    return retval; \
+}
+
+// TODO: __x86_64__, __ppc64__
+#else // Can't wrie inline asm to bust into __OBJC segment
+// This won't be used since the generic implementation takes precedence.
+
+#warning "Don't know how to implement wxObjcCompilerInformation<ObjcClass>::GetCompiledClass on this platform"
+
+#endif // platforms
+
+// The WX_IMPLEMENT_OBJC_GET_SUPERCLASS macro implements the template specialization
+// to get the superclass.  This only works if it's a real superclass.  If you are
+// deriving from a class that's already being uniquified then you'd need to
+// implement the specialization to call the appropriate get method instead.
+#define WX_IMPLEMENT_OBJC_GET_SUPERCLASS(ObjcClass,ObjcSuperClass) \
+    template <> \
+    inline objc_class* wxObjcCompilerInformation<ObjcClass>::GetSuperclass() \
+    { \
+        return objc_getClass(#ObjcSuperClass); \
+    }
+
+// The WX_IMPLEMENT_OBJC_CLASS_NAME macro implements the template specialization
+// of the sm_theClassName constant.  As soon as this specialization is in place
+// sizeof(sm_theClassName) will return the number of bytes at compile time.
+#define WX_IMPLEMENT_OBJC_CLASS_NAME(ObjcClass) \
+    template <> \
+    const char wxObjcCompilerInformation<ObjcClass>::sm_theClassName[] = #ObjcClass;
+
+// The WX_IMPLEMENT_GET_OBJC_CLASS macro combines all of these together and adds
+// a global wx_GetObjcClass_ObjcClass() function.
+#define WX_IMPLEMENT_GET_OBJC_CLASS(ObjcClass,ObjcSuperClass) \
+    WX_IMPLEMENT_OBJC_GET_COMPILED_CLASS(ObjcClass) \
+    WX_IMPLEMENT_OBJC_GET_SUPERCLASS(ObjcClass,ObjcSuperClass) \
+    WX_IMPLEMENT_OBJC_CLASS_NAME(ObjcClass) \
+    objc_class* wx_GetObjcClass_ ## ObjcClass() \
+    { \
+        return wxObjcClassInitializer<ObjcClass>::Get(); \
+    }
+
+// The WX_GET_OBJC_CLASS macro is intended to wrap the class name when the class
+// is used as a message receiver (e.g. for calling class methods).  When
+// class name uniquifying is used, this calls the global function implemented
+// in the Objective-C file containing the class @implementation.
+#define WX_GET_OBJC_CLASS(ObjcClass) wx_GetObjcClass_ ## ObjcClass()
+
+#else // wxUSE_OBJC_UNIQUIFYING
+
+// Define WX_DECLARE_GET_OBJC_CLASS as nothing
+#define WX_DECLARE_GET_OBJC_CLASS(ObjcClass,ObjcSuperClass)
+// Define WX_IMPLEMENT_GET_OBJC_CLASS as nothing
+#define WX_IMPLEMENT_GET_OBJC_CLASS(ObjcClass,ObjcSuperClass)
+
+// Define WX_GET_OBJC_CLASS macro to output the class name and let the compiler do the normal thing
+// The WX_GET_OBJC_CLASS macro is intended to wrap the class name when the class
+// is used as a message receiver (e.g. for calling class methods).  When
+// class name uniquifying is not used, this is simply defined to be the class
+// name which will allow the compiler to do the normal thing.
+#define WX_GET_OBJC_CLASS(ObjcClass) ObjcClass
+
+#endif // wxUSE_OBJC_UNIQUIFYING
+
+#endif //ndef __WX_COCOA_OBJC_CLASS_H__

setup.h.in

@@ -752,6 +752,11 @@
  */
 #define wxUSE_WEBKIT 0
 
+/*
+ * Objective-C class name uniquifying
+ */
+#define wxUSE_OBJC_UNIQUIFYING 0
+
 /*
  * The const keyword is being introduced more in wxWindows.
  * You can use this setting to maintain backward compatibility.