Commits

Ronald Oussoren committed 7b349a2

Fix a number of issues on OSX 10.5

There still are some test failures in pyobjc-core and I haven't tested
the framework wrappers yet. The failures in core are fairly obscure, and
might even be due to platform limitations.

Comments (0)

Files changed (59)

pyobjc-core/Modules/objc/OC_PythonObject.m

     return self;
 }
 
--(NSObject*)replacementObjectForArchiver:(NSObject*)archiver
+-(NSObject*)replacementObjectForArchiver:(NSArchiver*)archiver
 {
     (void)archiver;
     return (NSObject*)self;

pyobjc-core/Modules/objc/method-signature.m

 static PyObjCMethodSignature*
 new_methodsignature(const char* signature)
 {
-    Py_ssize_t nargs;
+    Py_ssize_t nargs, i;
     const char* cur;
     PyObjCMethodSignature* retval;
 
         return NULL;
     }
 
-    for (Py_ssize_t i = 0; i < nargs; i++) {
+    for (i = 0; i < nargs; i++) {
         retval->argtype[i] = NULL;
     }
 

pyobjc-core/Modules/objc/objc-runtime-compat.m

     while (protocol_list != NULL) {
         Protocol** tmp;
         tmp = realloc(list, (count + protocol_list->count)*sizeof(Protocol*));
-        if (tmplist == NULL) {
+        if (tmp == NULL) {
             free(list);
             *outCount = 0;
             return NULL;
 const char* (*PyObjC_object_getClassName)(id obj) = NULL;
 Method* (*PyObjC_class_copyMethodList)(Class, unsigned int*) = NULL;
 const char*  (*PyObjC_class_getName)(Class) = NULL;
-const size_t  (*PyObjC_class_getInstanceSize)(Class) = NULL;
+size_t  (*PyObjC_class_getInstanceSize)(Class) = NULL;
 Class (*PyObjC_class_getSuperclass)(Class) = NULL;
 BOOL (*PyObjC_class_addMethod)(Class, SEL, IMP, const char*) = NULL;
 BOOL (*PyObjC_class_addMethodList)(Class, struct PyObjC_method*, unsigned int) = NULL;

pyobjc-core/Modules/objc/objc_support.m

             if (tmp != NULL) {
                 double dblval = PyFloat_AsDouble(tmp);
                 Py_DECREF(tmp);
-                *(float*) datum = dblval;
+                *(float*) datum = (float)dblval;
                 return 0;
             }
 

pyobjc-core/Modules/objc/pyobjc-compat.h

 #  define __has_extension(x) __has_feature(x)
 #endif
 
+#if !__has_feature(objc_instancetype)
+#  define instancetype id
+#endif
+
 /*
  *
  * Start of Cocoa definitions
 
 
 
-#ifndef __has_feature
-#  define __has_feature(x) 0
-#endif
-
-#if !__has_feature(objc_instancetype)
-#  define instancetype id
-#endif
 
 /* On some versions of GCC <limits.h> defines LONG_LONG_MAX but not LLONG_MAX, compensate.  */
 #ifndef LLONG_MIN

pyobjc-core/Modules/objc/test/metadata.m

 
 -(void)swapX:(double*)x andY:(double*)y /* inout */
 {
-    int t = *x;
+    double t = *x;
     *x = *y;
     *y = t;
 }

pyobjc-core/Modules/objc/test/metadatafunction.m

 
 static void swapX_andY_(double* x, double* y)
 {
-    int t = *x;
+    double t = *x;
     *x = *y;
     *y = t;
 }

pyobjc-core/Modules/objc/test/methres1.m

 #import <Foundation/Foundation.h>
 
 @interface NSObject (MethodResolution1)
-{
-}
 -(id)oc_method1;
 -(id)ocmethod2;
 @end

pyobjc-core/Modules/objc/test/methres2.m

 #import <Foundation/Foundation.h>
 
 @interface NSURL (MethodResolution2)
-{
-}
 -(id)oc_method1;
 -(id)ocmethod2;
 @end

pyobjc-core/PyObjCTest/dump-nsarchive.m

         return 2;
     }
 
+#if PyObjC_BUILD_RELEASE >= 1006
     NSError* error = nil;
     NSData* data = [NSPropertyListSerialization
         dataWithPropertyList:value
                       format:NSPropertyListXMLFormat_v1_0
                      options:NSPropertyListMutableContainersAndLeaves
                        error:&error];
+#else
+    NSString* error = nil;
+    NSData* data = [NSPropertyListSerialization
+        dataFromPropertyList:value
+                      format:NSPropertyListXMLFormat_v1_0
+                       errorDescription:&error];
+#endif
+
     if (data == nil) {
         /* Some types we test cannot be represented as a plist */
         printf("%s\n", [[value description] UTF8String]);

pyobjc-core/PyObjCTest/test_archiving_interop.py

 from distutils.sysconfig import get_config_var
 import os
 import sys
+import platform
 
 if sys.version_info[0] == 2:
     from plistlib import readPlistFromString as readPlistFromBytes, Data
         dst = cls.progpath = os.path.join(MYDIR, 'dump-nsarchive')
 
         subprocess.check_call([
-            'cc', '-o', dst, src, '-framework', 'Foundation'])
+            'cc', '-o', dst, src, '-framework', 'Foundation',
+            '-DPyObjC_BUILD_RELEASE=%02d%02d'%(tuple(map(int, platform.mac_ver()[0].split('.')[:2]))),
+        ])
 
     @classmethod
     def tearDownClass(cls):

pyobjc-core/PyObjCTest/test_lazy_import.py

 else:
     def sel32or64(a, b): return a
 
+def lookupClasses(*names):
+    result = []
+    for nm in names:
+        try:
+            result.append(objc.lookUpClass(nm))
+        except objc.nosuchclass_error:
+            pass
+    return tuple(result)
 
 class TestLazyImport (TestCase):
     def test_exports(self):
         # Type validation:
         self.assertIn('NSCFType', mod.CFAllocatorRef.__bases__[0].__name__)
         self.assertIs(mod.CFArrayRef, objc.lookUpClass('NSArray'))
-        self.assertIn(mod.CFAttributedStringRef, (objc.lookUpClass('NSCFAttributedString'), objc.lookUpClass('__NSCFAttributedString')))
+        self.assertIn(mod.CFAttributedStringRef, lookupClasses('NSCFAttributedString', '__NSCFAttributedString'))
         self.assertIn('NSCFType', mod.CFBagRef.__name__)
         self.assertIsNot(mod.CFBagRef, mod.CFAllocatorRef)
 

pyobjc-core/Tools/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-core/libffi-src/powerpc/ppc-ffi_darwin.c

 
 	Note: ppc64 CR is saved in the low word of a long on the stack.
 */
+void
+ffi_prep_args(extended_cif*, unsigned *const);
 
 /*@-exportheader@*/
 void
 	contain parameters to be passed into the stack frame and setting up space
 	for a return value, ffi_closure_ASM invokes the following helper function
 	to do most of the work.  */
+int ffi_closure_helper_DARWIN(ffi_closure*, void*, unsigned long*, ffi_dblfl*);
+
 int
 ffi_closure_helper_DARWIN(
 	ffi_closure*	closure,
 #endif
 
 	double				temp;
-	unsigned int		i;
+	long i;
 	unsigned int		nf = 0;	/* number of FPRs already used.  */
 	unsigned int		ng = 0;	/* number of GPRs already used.  */
 	ffi_cif*			cif = closure->cif;
 					avalue[i] = alloca(arg_types[i]->size);
 					ffi64_struct_to_ram_form(arg_types[i], (const char*)pgr,
 						&gprSize, (const char*)pfr, &fprSize, &nf, avalue[i], NULL);
- 
+
 					ng	+= gprSize / sizeof(long);
 					pgr	+= gprSize / sizeof(long);
 					pfr	+= (fprSize - savedFPRSize) / sizeof(double);
 						size_al = ALIGN(arg_types[i]->size, 8);
 
 					if (size_al < 3)
-						avalue[i] = (void*)pgr + MODE_CHOICE(4,8) - size_al;
+						avalue[i] = (void*)((char*)pgr + MODE_CHOICE(4,8) - size_al);
 					else
 						avalue[i] = (void*)pgr;
 
 								memcpy(&outGPRs[destGMarker],
 									&inStruct[srcMarker], inType->size);
 						}
-						
+
 						srcMarker += inType->size;
 						destGMarker += inType->size;
 						i += inType->size - 1;
 			case FFI_TYPE_STRUCT:
 				recurseCount++;
 				ffi64_struct_to_reg_form(inType->elements[i],
-					inStruct, &srcMarker, &fprsUsed, outGPRs, 
+					inStruct, &srcMarker, &fprsUsed, outGPRs,
 					&destGMarker, outFPRs, &destFMarker);
 				recurseCount--;
 				break;

pyobjc-core/libffi-src/x86/x86-ffi_darwin.c

            Copyright (c) 2002  Ranjit Mathew
            Copyright (c) 2002  Bo Thorsen
            Copyright (c) 2002  Roger Sayle
-   
-   x86 Foreign Function Interface 
+
+   x86 Foreign Function Interface
 
    Permission is hereby granted, free of charge, to any person obtaining
    a copy of this software and associated documentation files (the
     register void **p_argv;
     register char *argp;
     register ffi_type **p_arg;
-    
+
     argp = stack;
-    
+
     if (ecif->cif->flags == FFI_TYPE_STRUCT)
     {
         *(void **) argp = ecif->rvalue;
         argp += 4;
     }
-    
+
     p_argv = ecif->avalue;
-    
+
     for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
          i != 0;
          i--, p_arg++)
     {
         size_t z;
-        
+
         /* Align if necessary */
         if ((sizeof(int) - 1) & (unsigned) argp)
             argp = (char *) ALIGN(argp, sizeof(int));
-        
+
         z = (*p_arg)->size;
         if (z < sizeof(int))
         {
                 case FFI_TYPE_SINT8:
                     *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_UINT8:
                     *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_SINT16:
                     *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_UINT16:
                     *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_SINT32:
                     *(signed int *) argp = (signed int)*(SINT32 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_UINT32:
                     *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
                     break;
-                    
+
                 case FFI_TYPE_STRUCT:
                     *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
                     break;
-                    
+
                 default:
                     FFI_ASSERT(0);
             }
         p_argv++;
         argp += z;
     }
-    
+
     return;
 }
 
         case FFI_TYPE_SINT8:
         case FFI_TYPE_SINT16:
 #endif
-            
+
         case FFI_TYPE_SINT64:
         case FFI_TYPE_FLOAT:
         case FFI_TYPE_DOUBLE:
         case FFI_TYPE_LONGDOUBLE:
             cif->flags = (unsigned) cif->rtype->type;
             break;
-            
+
         case FFI_TYPE_UINT64:
             cif->flags = FFI_TYPE_SINT64;
             break;
-            
+
 #ifndef X86
         case FFI_TYPE_STRUCT:
             if (cif->rtype->size == 1)
             }
             break;
 #endif
-            
+
         default:
             cif->flags = FFI_TYPE_INT;
             break;
     }
-    
+
 #ifdef X86_DARWIN
     cif->bytes = (cif->bytes + 15) & ~0xF;
 #endif
-    
+
     return FFI_OK;
 }
 
 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *,
-                          unsigned, unsigned, unsigned *, void (*fn)());
+                          unsigned, unsigned, unsigned *, void (*fn)(void));
 
 #ifdef X86_WIN32
 extern void ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *,
 
 #endif /* X86_WIN32 */
 
-void ffi_call(ffi_cif *cif, void (*fn)(), void *rvalue, void **avalue)
+void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 {
     extended_cif ecif;
-    
+
     ecif.cif = cif;
     ecif.avalue = avalue;
-    
+
     /* If the return value is a struct and we don't have a return	*/
     /* value address then we need to make one		        */
-    
-    if ((rvalue == NULL) && 
+
+    if ((rvalue == NULL) &&
         (cif->flags == FFI_TYPE_STRUCT))
     {
         ecif.rvalue = alloca(cif->rtype->size);
     }
     else
         ecif.rvalue = rvalue;
-    
-    
-    switch (cif->abi) 
+
+
+    switch (cif->abi)
     {
         case FFI_SYSV:
             ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
     // our various things...
     ffi_cif       *cif;
     void         **arg_area;
-    
+
     cif         = closure->cif;
-    arg_area    = (void**) alloca (cif->nargs * sizeof (void*));  
-    
+    arg_area    = (void**) alloca (cif->nargs * sizeof (void*));
+
     /* this call will initialize ARG_AREA, such that each
-     * element in that array points to the corresponding 
+     * element in that array points to the corresponding
      * value on the stack; and if the function returns
      * a structure, it will re-set RESP to point to the
      * structure return address.  */
-    
+
     ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif);
-    
+
     (closure->fun) (cif, *respp, arg_area, closure->user_data);
-    
+
     return cif->flags;
 }
 
     register void **p_argv;
     register char *argp;
     register ffi_type **p_arg;
-    
+
     argp = stack;
-    
+
     if ( cif->flags == FFI_TYPE_STRUCT ) {
         *rvalue = *(void **) argp;
         argp += 4;
     }
-    
+
     p_argv = avalue;
-    
+
     for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
     {
         size_t z;
-        
+
         /* Align if necessary */
         if ((sizeof(int) - 1) & (unsigned) argp) {
             argp = (char *) ALIGN(argp, sizeof(int));
         }
-        
+
         z = (*p_arg)->size;
-        
+
         /* because we're little endian, this is what it turns into.   */
-        
+
         *p_argv = (void*) argp;
-        
+
         p_argv++;
         argp += z;
     }
-    
+
     return;
 }
 
 {
 	if (cif->abi != FFI_SYSV)
 		return FFI_BAD_ABI;
-    
+
     FFI_INIT_TRAMPOLINE (&closure->tramp[0], \
                          &ffi_closure_SYSV,  \
                          (void*)closure);
-    
+
     closure->cif  = cif;
     closure->user_data = user_data;
     closure->fun  = fun;
-    
+
     return FFI_OK;
 }
 
                           void *codeloc)
 {
     int i;
-    
+
     FFI_ASSERT (cif->abi == FFI_SYSV);
-    
+
     // we currently don't support certain kinds of arguments for raw
     // closures.  This should be implemented by a separate assembly language
     // routine, since it would require argument processing, something we
     // don't do now for performance.
-    
+
     for (i = cif->nargs-1; i >= 0; i--)
     {
         FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_STRUCT);
         FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_LONGDOUBLE);
     }
-    
-    
+
+
     FFI_INIT_TRAMPOLINE (&closure->tramp[0], &ffi_closure_raw_SYSV,
                          codeloc);
-    
+
     closure->cif  = cif;
     closure->user_data = user_data;
     closure->fun  = fun;
-    
+
     return FFI_OK;
 }
 
-static void 
+static void
 ffi_prep_args_raw(char *stack, extended_cif *ecif)
 {
     memcpy (stack, ecif->avalue, ecif->cif->bytes);
  */
 
 extern void
-ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, unsigned, 
+ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, unsigned,
               unsigned, unsigned *, void (*fn)());
 
 #ifdef X86_WIN32
 {
     extended_cif ecif;
     void **avalue = (void **)fake_avalue;
-    
+
     ecif.cif = cif;
     ecif.avalue = avalue;
-    
+
     /* If the return value is a struct and we don't have a return	*/
     /* value address then we need to make one		        */
-    
-    if ((rvalue == NULL) && 
+
+    if ((rvalue == NULL) &&
         (cif->rtype->type == FFI_TYPE_STRUCT))
     {
         ecif.rvalue = alloca(cif->rtype->size);
     }
     else
         ecif.rvalue = rvalue;
-    
-    
-    switch (cif->abi) 
+
+
+    switch (cif->abi)
     {
         case FFI_SYSV:
             ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,

pyobjc-core/setup.py

     "-Wnested-externs",
     "-W",
     "-Wno-import",
+    "-Wno-unknown-pragmas",
     #"-fvisibility=protected",
     "-Wshorten-64-to-32",
-    "-Werror",
+    #"-Werror",
 ]
 
 # CFLAGS for other (test) extensions:
         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):
             if os.path.exists('/usr/bin/xcodebuild'):
                 self.sdk_root = subprocess.check_output(
                         ['/usr/bin/xcodebuild', '-version', '-sdk', 'macosx', 'Path'],
-                        universal_newlines=True)[:-1]
+                        universal_newlines=True).strip()
 
             else:
                 self.sdk_root = '/'

pyobjc-framework-Accounts/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-AddressBook/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-AppleScriptKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-AppleScriptObjC/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Automator/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CFNetwork/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CalendarStore/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Cocoa/Modules/_AppKit_protocols.m

-/* 
+/*
  * This file is generated by objective.metadata
  *
  * Last update: Wed Jan 16 13:13:20 2013
 
 static void __attribute__((__used__)) use_protocols(void)
 {
-    PyObject* p;
 #if PyObjC_BUILD_RELEASE >= 1006
+    PyObject* p ;
     p = PyObjC_IdToPython(@protocol(NSAlertDelegate)); Py_XDECREF(p);
     p = PyObjC_IdToPython(@protocol(NSAnimatablePropertyContainer)); Py_XDECREF(p);
     p = PyObjC_IdToPython(@protocol(NSAnimationDelegate)); Py_XDECREF(p);

pyobjc-framework-Cocoa/Modules/_CoreFoundation_CFMachPort.m

 	}
 
 	if (context.version != 0) {
-		PyErr_Format(PyExc_ValueError, "retrieved context with version %d is not valid", context.version);
+		PyErr_Format(PyExc_ValueError, "retrieved context with version %ld is not valid", (long)context.version);
 		return NULL;
 	}
 	if (context.copyDescription != mod_machport_copyDescription) {

pyobjc-framework-Cocoa/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Collaboration/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CoreData/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CoreLocation/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CoreText/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-CoreWLAN/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-DictionaryServices/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-DiskArbitration/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-EventKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-ExceptionHandling/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-FSEvents/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-InputMethodKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-InstallerPlugins/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-InstantMessage/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-InterfaceBuilderKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-LatentSemanticMapping/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-LaunchServices/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Message/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-OpenDirectory/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-PreferencePanes/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-PubSub/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-QTKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Quartz/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-ScreenSaver/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-ScriptingBridge/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-SearchKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-ServerNotification/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-ServiceManagement/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-Social/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-StoreKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-SyncServices/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-SystemConfiguration/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-WebKit/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):

pyobjc-framework-XgridFoundation/pyobjc_setup.py

         for p in os.environ['PATH'].split(os.pathsep):
             f = os.path.join(p, executable)
             if os.path.isfile(f):
-                return f
+                return executable
     return None
 
 def _working_compiler(executable):