- GTM_INLINE will make sure a function gets inlined, and provides a consistent

  way for all GTM code to do it.

- Added GTMDebugThreadValidation to allow you to enforce the fact that your
  code must run in the main thread in DEBUG builds.

- Updated some internals of the iPhone unittesting so it doesn't double print
  the test descriptions, file names, or lines numbers of a test failure line.
  Also includes the test names in the error output.

- Changed the xcconfigs so that know it's easier to set different settings at
  the different levels and not accidentally overwrite settings set at lower
  levels in the "settings collapse". Also tightened up warnings significantly.

- Changed how gtm_unitTestExposedBindingsTestValues works. If you have an
  implementation of gtm_unitTestExposedBindingsTestValues in your own code
  you will need to update to the new way of calling. See implementations in
  GTMNSObject+BindingUnitTesting.m for details.

- Added support for grabbing the build number for a particular OS in
  GTMSystemVersion and easily comparing it to known build numbers, and switched 
  some types from in GTMSystemVersion from "int" to SInt32 to make 64 bit work 
  better.
   
- Added support for SnowLeopard (10A96). We build cleanly with the 10.6 SDKs and
  all radar checks were updated accordingly. Build All script was also updated
  to build on SnowLeopard if you have the SDK available.
  
- Turned off building ppc64 GTM because the SnowLeopard SDK currently
  doesn't have ppc64 support, so SenTestCase isn't defined. This makes it
  impossible to build the ppc64 10.5 config on SnowLeopard. We have left the
  setting in the xcconfig for those of you who need it, but have disabled
  it in the GTM project settings.
  
- Turned on stack smashing protection on the debug builds for all Leopard 
  and above.

- Added ability to easily do leak checking by defining the GTM_ENABLE_LEAKS
  environment variable. It isn't on by default because several of Apple's
  frameworks leak. You can work around these false positives by using the
  GTM_LEAKS_SYMBOLS_TO_IGNORE environment variable. Also if you turn on leaks
  make sure to turn off zombies by defining the GTM_DISABLE_ZOMBIES variable,
  otherwise every memory allocation you do will look like a leak.

1 files changed, 114 insertions, 6 deletions

diff --git a/Foundation/GTMSystemVersion.m b/Foundation/GTMSystemVersion.m
index da767ae..868f6b8 100644
--- a/Foundation/GTMSystemVersion.m
+++ b/Foundation/GTMSystemVersion.m
@@ -17,6 +17,7 @@
 //
 
 #import "GTMSystemVersion.h"
+#import "GTMGarbageCollection.h"
 #if GTM_MACOS_SDK
 #import <Carbon/Carbon.h>
 #endif
@@ -24,6 +25,18 @@
 static SInt32 sGTMSystemVersionMajor = 0;
 static SInt32 sGTMSystemVersionMinor = 0;
 static SInt32 sGTMSystemVersionBugFix = 0;
+static NSString *sBuild = nil;
+
+NSString *const kGTMArch_iPhone = @"iPhone";
+NSString *const kGTMArch_ppc = @"ppc";
+NSString *const kGTMArch_ppc64 = @"ppc64";
+NSString *const kGTMArch_x86_64 = @"x86_64";
+NSString *const kGTMArch_i386 = @"i386";
+
+static NSString *const kSystemVersionPlistPath = @"/System/Library/CoreServices/SystemVersion.plist";
+
+NSString *const kGTMSystemBuild10_5_5 = @"9F33";
+NSString *const kGTMSystemBuild10_6_0_WWDC = @"10A96";
 
 @implementation GTMSystemVersion
 + (void)initialize {
@@ -51,9 +64,9 @@ static SInt32 sGTMSystemVersionBugFix = 0;
     // Note that this code will return x.9.9 for any system rev parts that are
     // greater than 9 (i.e., 10.10.10 will be 10.9.9). This shouldn't ever be a
     // problem as the code above takes care of 10.4+.
-    int msb = (binaryCodedDec & 0x0000F000L) >> 12;
+    SInt32 msb = (binaryCodedDec & 0x0000F000L) >> 12;
     msb *= 10;
-    int lsb = (binaryCodedDec & 0x00000F00L) >> 8;
+    SInt32 lsb = (binaryCodedDec & 0x00000F00L) >> 8;
     sGTMSystemVersionMajor = msb + lsb;
     sGTMSystemVersionMinor = (binaryCodedDec & 0x000000F0L) >> 4;
     sGTMSystemVersionBugFix = (binaryCodedDec & 0x0000000FL);
@@ -61,14 +74,17 @@ static SInt32 sGTMSystemVersionBugFix = 0;
 
 #else // GTM_MACOS_SDK
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    NSDictionary *systemVersionPlist = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/CoreServices/SystemVersion.plist"];
+    NSDictionary *systemVersionPlist 
+      = [NSDictionary dictionaryWithContentsOfFile:kSystemVersionPlistPath];
     NSString *version = [systemVersionPlist objectForKey:@"ProductVersion"];
     _GTMDevAssert(version, @"Unable to get version");
     NSArray *versionInfo = [version componentsSeparatedByString:@"."];
     NSUInteger length = [versionInfo count];
-    _GTMDevAssert(length > 1 && length < 4, @"Unparseable version %@", version);
+    _GTMDevAssert(length > 1 && length < 4, 
+                  @"Unparseable version %@", version);
     sGTMSystemVersionMajor = [[versionInfo objectAtIndex:0] intValue];
-    _GTMDevAssert(sGTMSystemVersionMajor != 0, @"Unknown version for %@", version);
+    _GTMDevAssert(sGTMSystemVersionMajor != 0, 
+                  @"Unknown version for %@", version);
     sGTMSystemVersionMinor = [[versionInfo objectAtIndex:1] intValue];
     if (length == 3) {
       sGTMSystemVersionBugFix = [[versionInfo objectAtIndex:2] intValue];
@@ -78,7 +94,7 @@ static SInt32 sGTMSystemVersionBugFix = 0;
   }
 }
 
-+ (void)getMajor:(long*)major minor:(long*)minor bugFix:(long*)bugFix {
++ (void)getMajor:(SInt32*)major minor:(SInt32*)minor bugFix:(SInt32*)bugFix {
   if (major) {
     *major = sGTMSystemVersionMajor;
   }
@@ -90,6 +106,57 @@ static SInt32 sGTMSystemVersionBugFix = 0;
   }
 }
 
++ (NSString*)build {
+  @synchronized(self) {
+    // Not cached at initialization time because we don't expect "real"
+    // software to want this, and it costs a bit to get at startup.
+    // This will mainly be for unit test cases.
+    if (!sBuild) {
+      NSDictionary *systemVersionPlist 
+        = [NSDictionary dictionaryWithContentsOfFile:kSystemVersionPlistPath];
+      sBuild = [[systemVersionPlist objectForKey:@"ProductBuildVersion"] retain];
+      GTMNSMakeUncollectable(sBuild);
+      _GTMDevAssert(sBuild, @"Unable to get build version");
+    }
+  }
+  return sBuild;
+}
+
++ (BOOL)isBuildLessThan:(NSString*)build {
+  NSComparisonResult result 
+    = [[self build] compare:build 
+                    options:NSNumericSearch | NSCaseInsensitiveSearch];
+  return result == NSOrderedAscending;
+}
+  
++ (BOOL)isBuildLessThanOrEqualTo:(NSString*)build {
+  NSComparisonResult result 
+    = [[self build] compare:build 
+                    options:NSNumericSearch | NSCaseInsensitiveSearch];
+  return result != NSOrderedDescending;
+}
+
++ (BOOL)isBuildGreaterThan:(NSString*)build {
+  NSComparisonResult result 
+    = [[self build] compare:build 
+                    options:NSNumericSearch | NSCaseInsensitiveSearch];
+  return result == NSOrderedDescending;
+}
+
++ (BOOL)isBuildGreaterThanOrEqualTo:(NSString*)build {
+  NSComparisonResult result 
+    = [[self build] compare:build 
+                    options:NSNumericSearch | NSCaseInsensitiveSearch];
+  return result != NSOrderedAscending;
+}
+
++ (BOOL)isBuildEqualTo:(NSString *)build {
+  NSComparisonResult result 
+    = [[self build] compare:build 
+                    options:NSNumericSearch | NSCaseInsensitiveSearch];
+  return result == NSOrderedSame;
+}
+
 #if GTM_MACOS_SDK
 + (BOOL)isPanther {
   return sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor == 3;
@@ -103,6 +170,10 @@ static SInt32 sGTMSystemVersionBugFix = 0;
   return sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor == 5;
 }
 
++ (BOOL)isSnowLeopard {
+  return sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor == 6;
+}
+
 + (BOOL)isPantherOrGreater {
   return (sGTMSystemVersionMajor > 10) || 
           (sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor >= 3);
@@ -118,6 +189,43 @@ static SInt32 sGTMSystemVersionBugFix = 0;
           (sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor >= 5);
 }
 
++ (BOOL)isSnowLeopardOrGreater {
+  return (sGTMSystemVersionMajor > 10) || 
+          (sGTMSystemVersionMajor == 10 && sGTMSystemVersionMinor >= 6);
+}
+
 #endif // GTM_MACOS_SDK
 
++ (NSString *)runtimeArchitecture {
+  NSString *architecture = nil;
+#if GTM_IPHONE_SDK
+  architecture = kGTMArch_iPhone;
+#else // !GTM_IPHONE_SDK
+  // In reading arch(3) you'd thing this would work:
+  //
+  // const NXArchInfo *localInfo = NXGetLocalArchInfo();
+  // _GTMDevAssert(localInfo && localInfo->name, @"Couldn't get NXArchInfo");
+  // const NXArchInfo *genericInfo = NXGetArchInfoFromCpuType(localInfo->cputype, 0);
+  // _GTMDevAssert(genericInfo && genericInfo->name, @"Couldn't get generic NXArchInfo");
+  // extensions[0] = [NSString stringWithFormat:@".%s", genericInfo->name];
+  //
+  // but on 64bit it returns the same things as on 32bit, so...
+#if __POWERPC__
+#if __LP64__
+  architecture = kGTMArch_ppc64;
+#else // !__LP64__
+  architecture = kGTMArch_ppc;
+#endif // __LP64__
+#else // !__POWERPC__
+#if __LP64__
+  architecture = kGTMArch_x86_64;
+#else // !__LP64__
+  architecture = kGTMArch_i386;
+#endif // __LP64__
+#endif // !__POWERPC__
+  
+#endif // GTM_IPHONE_SDK
+  return architecture;
+}  
+
 @end