Move the entire application into a dylib (framework)

build/mac/strip_save_dsym

 #!/usr/bin/python
 
 # Copyright (c) 2008 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Usage: strip_save_dsym <whatever-arguments-you-would-pass-to-strip>
 #
 # strip_save_dsym is a wrapper around the standard strip utility.  Given an
 # input Mach-O file, strip_save_dsym will save a copy of the file in a "fake"
@@ skipping 25 matching lines @@
 import sys
 import time
 
 # Returns a list of architectures contained in a Mach-O file.  The file can be
 # a universal (fat) file, in which case there will be one list element for
 # each contained architecture, or it can be a thin single-architecture Mach-O
 # file, in which case the list will contain a single element identifying the
 # architecture.  On error, returns an empty list.  Determines the architecture
 # list by calling file.
 def macho_archs(macho):
+  macho_types = ["executable",
+                 "dynamically linked shared library",
+                 "bundle"]
+  macho_types_re = "Mach-O (?:64-bit )?(?:" + "|".join(macho_types) + ")"
+
   file_cmd = subprocess.Popen(["/usr/bin/file", "-b", "--", macho],
-                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                              stdout=subprocess.PIPE)
 
   archs = []
 
   type_line = file_cmd.stdout.readline()
-  type_match = re.match("^Mach-O executable (.*)$", type_line)
+  type_match = re.match("^%s (.*)$" % macho_types_re, type_line)
   if type_match:
     archs.append(type_match.group(1))
     return [type_match.group(1)]
   else:
     type_match = re.match("^Mach-O universal binary with (.*) architectures$",
                           type_line)
     if type_match:
       for i in range(0, int(type_match.group(1))):
         arch_line = file_cmd.stdout.readline()
         arch_match = re.match(
-                     "^.* \(for architecture (.*)\):\tMach-O executable .*$",
+                     "^.* \(for architecture (.*)\):\t%s .*$" % macho_types_re,
                      arch_line)
         if arch_match:
           archs.append(arch_match.group(1))
 
   if file_cmd.wait() != 0:
     archs = []
 
+  if len(archs) == 0:
+    print >> sys.stderr, "No architectures in %s" % macho
+
   return archs
 
 # Returns a dictionary mapping architectures contained in the file as returned
 # by macho_archs to the LC_UUID load command for that architecture.
 # Architectures with no LC_UUID load command are omitted from the dictionary.
 # Determines the UUID value by calling otool.
 def macho_uuids(macho):
+  uuids = {}
+
   archs = macho_archs(macho)
-
-  uuids = {} 
+  if len(archs) == 0:
+    return uuids
 
   for arch in archs:
     if arch == "":
       continue
 
     otool_cmd = subprocess.Popen(["/usr/bin/otool", "-arch", arch, "-l", "-",
                                   macho],
-                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                                 stdout=subprocess.PIPE)
     # state 0 is when nothing UUID-related has been seen yet.  State 1 is
     # entered after a load command begins, but it may not be an LC_UUID load
     # command.  States 2, 3, and 4 are intermediate states while reading an
     # LC_UUID command.  State 5 is the terminal state for a successful LC_UUID
     # read.  State 6 is the error state.
     state = 0
     uuid = ""
     for otool_line in otool_cmd.stdout:
       if state == 0:
         if re.match("^Load command .*$", otool_line):
@@ skipping 32 matching lines @@
                   uuid_match.group(7) + uuid_match.group(8)
         else:
           state = 6
 
     if otool_cmd.wait() != 0:
       state = 6
 
     if state == 5:
       uuids[arch] = uuid.upper()
 
+  if len(uuids) == 0:
+    print >> sys.stderr, "No UUIDs in %s" % macho
+
   return uuids
 
 # Given a path to a Mach-O file and possible information from the environment,
 # determines the desired path to the .dSYM.
 def dsym_path(macho):
   # If building a bundle, the .dSYM should be placed next to the bundle.  Use
   # WRAPPER_NAME to make this determination.  If called from xcodebuild,
   # WRAPPER_NAME will be set to the name of the bundle.
   dsym = ""
   if "WRAPPER_NAME" in os.environ:
@@ skipping 151 matching lines @@
 
   if macho is None:
     print >> sys.stderr, "Nothing to strip"
     return 1
 
   if not strip_and_make_fake_dsym(macho):
     return 1
 
   return 0
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main(sys.argv))