www.aleph1.co.uk Git - yaffs-website/blob - node_modules/node-gyp/gyp/pylib/gyp/xcode_emulation.py

   1 # Copyright (c) 2012 Google Inc. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """
   6 This module contains classes that help to emulate xcodebuild behavior on top of
   7 other build systems, such as make and ninja.
   8 """
   9
  10 import copy
  11 import gyp.common
  12 import os
  13 import os.path
  14 import re
  15 import shlex
  16 import subprocess
  17 import sys
  18 import tempfile
  19 from gyp.common import GypError
  20
  21 # Populated lazily by XcodeVersion, for efficiency, and to fix an issue when
  22 # "xcodebuild" is called too quickly (it has been found to return incorrect
  23 # version number).
  24 XCODE_VERSION_CACHE = None
  25
  26 # Populated lazily by GetXcodeArchsDefault, to an |XcodeArchsDefault| instance
  27 # corresponding to the installed version of Xcode.
  28 XCODE_ARCHS_DEFAULT_CACHE = None
  29
  30
  31 def XcodeArchsVariableMapping(archs, archs_including_64_bit=None):
  32   """Constructs a dictionary with expansion for $(ARCHS_STANDARD) variable,
  33   and optionally for $(ARCHS_STANDARD_INCLUDING_64_BIT)."""
  34   mapping = {'$(ARCHS_STANDARD)': archs}
  35   if archs_including_64_bit:
  36     mapping['$(ARCHS_STANDARD_INCLUDING_64_BIT)'] = archs_including_64_bit
  37   return mapping
  38
  39 class XcodeArchsDefault(object):
  40   """A class to resolve ARCHS variable from xcode_settings, resolving Xcode
  41   macros and implementing filtering by VALID_ARCHS. The expansion of macros
  42   depends on the SDKROOT used ("macosx", "iphoneos", "iphonesimulator") and
  43   on the version of Xcode.
  44   """
  45
  46   # Match variable like $(ARCHS_STANDARD).
  47   variable_pattern = re.compile(r'\$\([a-zA-Z_][a-zA-Z0-9_]*\)$')
  48
  49   def __init__(self, default, mac, iphonesimulator, iphoneos):
  50     self._default = (default,)
  51     self._archs = {'mac': mac, 'ios': iphoneos, 'iossim': iphonesimulator}
  52
  53   def _VariableMapping(self, sdkroot):
  54     """Returns the dictionary of variable mapping depending on the SDKROOT."""
  55     sdkroot = sdkroot.lower()
  56     if 'iphoneos' in sdkroot:
  57       return self._archs['ios']
  58     elif 'iphonesimulator' in sdkroot:
  59       return self._archs['iossim']
  60     else:
  61       return self._archs['mac']
  62
  63   def _ExpandArchs(self, archs, sdkroot):
  64     """Expands variables references in ARCHS, and remove duplicates."""
  65     variable_mapping = self._VariableMapping(sdkroot)
  66     expanded_archs = []
  67     for arch in archs:
  68       if self.variable_pattern.match(arch):
  69         variable = arch
  70         try:
  71           variable_expansion = variable_mapping[variable]
  72           for arch in variable_expansion:
  73             if arch not in expanded_archs:
  74               expanded_archs.append(arch)
  75         except KeyError as e:
  76           print 'Warning: Ignoring unsupported variable "%s".' % variable
  77       elif arch not in expanded_archs:
  78         expanded_archs.append(arch)
  79     return expanded_archs
  80
  81   def ActiveArchs(self, archs, valid_archs, sdkroot):
  82     """Expands variables references in ARCHS, and filter by VALID_ARCHS if it
  83     is defined (if not set, Xcode accept any value in ARCHS, otherwise, only
  84     values present in VALID_ARCHS are kept)."""
  85     expanded_archs = self._ExpandArchs(archs or self._default, sdkroot or '')
  86     if valid_archs:
  87       filtered_archs = []
  88       for arch in expanded_archs:
  89         if arch in valid_archs:
  90           filtered_archs.append(arch)
  91       expanded_archs = filtered_archs
  92     return expanded_archs
  93
  94
  95 def GetXcodeArchsDefault():
  96   """Returns the |XcodeArchsDefault| object to use to expand ARCHS for the
  97   installed version of Xcode. The default values used by Xcode for ARCHS
  98   and the expansion of the variables depends on the version of Xcode used.
  99
 100   For all version anterior to Xcode 5.0 or posterior to Xcode 5.1 included
 101   uses $(ARCHS_STANDARD) if ARCHS is unset, while Xcode 5.0 to 5.0.2 uses
 102   $(ARCHS_STANDARD_INCLUDING_64_BIT). This variable was added to Xcode 5.0
 103   and deprecated with Xcode 5.1.
 104
 105   For "macosx" SDKROOT, all version starting with Xcode 5.0 includes 64-bit
 106   architecture as part of $(ARCHS_STANDARD) and default to only building it.
 107
 108   For "iphoneos" and "iphonesimulator" SDKROOT, 64-bit architectures are part
 109   of $(ARCHS_STANDARD_INCLUDING_64_BIT) from Xcode 5.0. From Xcode 5.1, they
 110   are also part of $(ARCHS_STANDARD).
 111
 112   All thoses rules are coded in the construction of the |XcodeArchsDefault|
 113   object to use depending on the version of Xcode detected. The object is
 114   for performance reason."""
 115   global XCODE_ARCHS_DEFAULT_CACHE
 116   if XCODE_ARCHS_DEFAULT_CACHE:
 117     return XCODE_ARCHS_DEFAULT_CACHE
 118   xcode_version, _ = XcodeVersion()
 119   if xcode_version < '0500':
 120     XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
 121         '$(ARCHS_STANDARD)',
 122         XcodeArchsVariableMapping(['i386']),
 123         XcodeArchsVariableMapping(['i386']),
 124         XcodeArchsVariableMapping(['armv7']))
 125   elif xcode_version < '0510':
 126     XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
 127         '$(ARCHS_STANDARD_INCLUDING_64_BIT)',
 128         XcodeArchsVariableMapping(['x86_64'], ['x86_64']),
 129         XcodeArchsVariableMapping(['i386'], ['i386', 'x86_64']),
 130         XcodeArchsVariableMapping(
 131             ['armv7', 'armv7s'],
 132             ['armv7', 'armv7s', 'arm64']))
 133   else:
 134     XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
 135         '$(ARCHS_STANDARD)',
 136         XcodeArchsVariableMapping(['x86_64'], ['x86_64']),
 137         XcodeArchsVariableMapping(['i386', 'x86_64'], ['i386', 'x86_64']),
 138         XcodeArchsVariableMapping(
 139             ['armv7', 'armv7s', 'arm64'],
 140             ['armv7', 'armv7s', 'arm64']))
 141   return XCODE_ARCHS_DEFAULT_CACHE
 142
 143
 144 class XcodeSettings(object):
 145   """A class that understands the gyp 'xcode_settings' object."""
 146
 147   # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
 148   # at class-level for efficiency.
 149   _sdk_path_cache = {}
 150   _sdk_root_cache = {}
 151
 152   # Populated lazily by GetExtraPlistItems(). Shared by all XcodeSettings, so
 153   # cached at class-level for efficiency.
 154   _plist_cache = {}
 155
 156   # Populated lazily by GetIOSPostbuilds.  Shared by all XcodeSettings, so
 157   # cached at class-level for efficiency.
 158   _codesigning_key_cache = {}
 159
 160   def __init__(self, spec):
 161     self.spec = spec
 162
 163     self.isIOS = False
 164
 165     # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
 166     # This means self.xcode_settings[config] always contains all settings
 167     # for that config -- the per-target settings as well. Settings that are
 168     # the same for all configs are implicitly per-target settings.
 169     self.xcode_settings = {}
 170     configs = spec['configurations']
 171     for configname, config in configs.iteritems():
 172       self.xcode_settings[configname] = config.get('xcode_settings', {})
 173       self._ConvertConditionalKeys(configname)
 174       if self.xcode_settings[configname].get('IPHONEOS_DEPLOYMENT_TARGET',
 175                                              None):
 176         self.isIOS = True
 177
 178     # This is only non-None temporarily during the execution of some methods.
 179     self.configname = None
 180
 181     # Used by _AdjustLibrary to match .a and .dylib entries in libraries.
 182     self.library_re = re.compile(r'^lib([^/]+)\.(a|dylib)$')
 183
 184   def _ConvertConditionalKeys(self, configname):
 185     """Converts or warns on conditional keys.  Xcode supports conditional keys,
 186     such as CODE_SIGN_IDENTITY[sdk=iphoneos*].  This is a partial implementation
 187     with some keys converted while the rest force a warning."""
 188     settings = self.xcode_settings[configname]
 189     conditional_keys = [key for key in settings if key.endswith(']')]
 190     for key in conditional_keys:
 191       # If you need more, speak up at http://crbug.com/122592
 192       if key.endswith("[sdk=iphoneos*]"):
 193         if configname.endswith("iphoneos"):
 194           new_key = key.split("[")[0]
 195           settings[new_key] = settings[key]
 196       else:
 197         print 'Warning: Conditional keys not implemented, ignoring:', \
 198               ' '.join(conditional_keys)
 199       del settings[key]
 200
 201   def _Settings(self):
 202     assert self.configname
 203     return self.xcode_settings[self.configname]
 204
 205   def _Test(self, test_key, cond_key, default):
 206     return self._Settings().get(test_key, default) == cond_key
 207
 208   def _Appendf(self, lst, test_key, format_str, default=None):
 209     if test_key in self._Settings():
 210       lst.append(format_str % str(self._Settings()[test_key]))
 211     elif default:
 212       lst.append(format_str % str(default))
 213
 214   def _WarnUnimplemented(self, test_key):
 215     if test_key in self._Settings():
 216       print 'Warning: Ignoring not yet implemented key "%s".' % test_key
 217
 218   def IsBinaryOutputFormat(self, configname):
 219     default = "binary" if self.isIOS else "xml"
 220     format = self.xcode_settings[configname].get('INFOPLIST_OUTPUT_FORMAT',
 221                                                  default)
 222     return format == "binary"
 223
 224   def _IsBundle(self):
 225     return int(self.spec.get('mac_bundle', 0)) != 0
 226
 227   def _IsIosAppExtension(self):
 228     return int(self.spec.get('ios_app_extension', 0)) != 0
 229
 230   def _IsIosWatchKitExtension(self):
 231     return int(self.spec.get('ios_watchkit_extension', 0)) != 0
 232
 233   def _IsIosWatchApp(self):
 234     return int(self.spec.get('ios_watch_app', 0)) != 0
 235
 236   def GetFrameworkVersion(self):
 237     """Returns the framework version of the current target. Only valid for
 238     bundles."""
 239     assert self._IsBundle()
 240     return self.GetPerTargetSetting('FRAMEWORK_VERSION', default='A')
 241
 242   def GetWrapperExtension(self):
 243     """Returns the bundle extension (.app, .framework, .plugin, etc).  Only
 244     valid for bundles."""
 245     assert self._IsBundle()
 246     if self.spec['type'] in ('loadable_module', 'shared_library'):
 247       default_wrapper_extension = {
 248         'loadable_module': 'bundle',
 249         'shared_library': 'framework',
 250       }[self.spec['type']]
 251       wrapper_extension = self.GetPerTargetSetting(
 252           'WRAPPER_EXTENSION', default=default_wrapper_extension)
 253       return '.' + self.spec.get('product_extension', wrapper_extension)
 254     elif self.spec['type'] == 'executable':
 255       if self._IsIosAppExtension() or self._IsIosWatchKitExtension():
 256         return '.' + self.spec.get('product_extension', 'appex')
 257       else:
 258         return '.' + self.spec.get('product_extension', 'app')
 259     else:
 260       assert False, "Don't know extension for '%s', target '%s'" % (
 261           self.spec['type'], self.spec['target_name'])
 262
 263   def GetProductName(self):
 264     """Returns PRODUCT_NAME."""
 265     return self.spec.get('product_name', self.spec['target_name'])
 266
 267   def GetFullProductName(self):
 268     """Returns FULL_PRODUCT_NAME."""
 269     if self._IsBundle():
 270       return self.GetWrapperName()
 271     else:
 272       return self._GetStandaloneBinaryPath()
 273
 274   def GetWrapperName(self):
 275     """Returns the directory name of the bundle represented by this target.
 276     Only valid for bundles."""
 277     assert self._IsBundle()
 278     return self.GetProductName() + self.GetWrapperExtension()
 279
 280   def GetBundleContentsFolderPath(self):
 281     """Returns the qualified path to the bundle's contents folder. E.g.
 282     Chromium.app/Contents or Foo.bundle/Versions/A. Only valid for bundles."""
 283     if self.isIOS:
 284       return self.GetWrapperName()
 285     assert self._IsBundle()
 286     if self.spec['type'] == 'shared_library':
 287       return os.path.join(
 288           self.GetWrapperName(), 'Versions', self.GetFrameworkVersion())
 289     else:
 290       # loadable_modules have a 'Contents' folder like executables.
 291       return os.path.join(self.GetWrapperName(), 'Contents')
 292
 293   def GetBundleResourceFolder(self):
 294     """Returns the qualified path to the bundle's resource folder. E.g.
 295     Chromium.app/Contents/Resources. Only valid for bundles."""
 296     assert self._IsBundle()
 297     if self.isIOS:
 298       return self.GetBundleContentsFolderPath()
 299     return os.path.join(self.GetBundleContentsFolderPath(), 'Resources')
 300
 301   def GetBundlePlistPath(self):
 302     """Returns the qualified path to the bundle's plist file. E.g.
 303     Chromium.app/Contents/Info.plist. Only valid for bundles."""
 304     assert self._IsBundle()
 305     if self.spec['type'] in ('executable', 'loadable_module'):
 306       return os.path.join(self.GetBundleContentsFolderPath(), 'Info.plist')
 307     else:
 308       return os.path.join(self.GetBundleContentsFolderPath(),
 309                           'Resources', 'Info.plist')
 310
 311   def GetProductType(self):
 312     """Returns the PRODUCT_TYPE of this target."""
 313     if self._IsIosAppExtension():
 314       assert self._IsBundle(), ('ios_app_extension flag requires mac_bundle '
 315           '(target %s)' % self.spec['target_name'])
 316       return 'com.apple.product-type.app-extension'
 317     if self._IsIosWatchKitExtension():
 318       assert self._IsBundle(), ('ios_watchkit_extension flag requires '
 319           'mac_bundle (target %s)' % self.spec['target_name'])
 320       return 'com.apple.product-type.watchkit-extension'
 321     if self._IsIosWatchApp():
 322       assert self._IsBundle(), ('ios_watch_app flag requires mac_bundle '
 323           '(target %s)' % self.spec['target_name'])
 324       return 'com.apple.product-type.application.watchapp'
 325     if self._IsBundle():
 326       return {
 327         'executable': 'com.apple.product-type.application',
 328         'loadable_module': 'com.apple.product-type.bundle',
 329         'shared_library': 'com.apple.product-type.framework',
 330       }[self.spec['type']]
 331     else:
 332       return {
 333         'executable': 'com.apple.product-type.tool',
 334         'loadable_module': 'com.apple.product-type.library.dynamic',
 335         'shared_library': 'com.apple.product-type.library.dynamic',
 336         'static_library': 'com.apple.product-type.library.static',
 337       }[self.spec['type']]
 338
 339   def GetMachOType(self):
 340     """Returns the MACH_O_TYPE of this target."""
 341     # Weird, but matches Xcode.
 342     if not self._IsBundle() and self.spec['type'] == 'executable':
 343       return ''
 344     return {
 345       'executable': 'mh_execute',
 346       'static_library': 'staticlib',
 347       'shared_library': 'mh_dylib',
 348       'loadable_module': 'mh_bundle',
 349     }[self.spec['type']]
 350
 351   def _GetBundleBinaryPath(self):
 352     """Returns the name of the bundle binary of by this target.
 353     E.g. Chromium.app/Contents/MacOS/Chromium. Only valid for bundles."""
 354     assert self._IsBundle()
 355     if self.spec['type'] in ('shared_library') or self.isIOS:
 356       path = self.GetBundleContentsFolderPath()
 357     elif self.spec['type'] in ('executable', 'loadable_module'):
 358       path = os.path.join(self.GetBundleContentsFolderPath(), 'MacOS')
 359     return os.path.join(path, self.GetExecutableName())
 360
 361   def _GetStandaloneExecutableSuffix(self):
 362     if 'product_extension' in self.spec:
 363       return '.' + self.spec['product_extension']
 364     return {
 365       'executable': '',
 366       'static_library': '.a',
 367       'shared_library': '.dylib',
 368       'loadable_module': '.so',
 369     }[self.spec['type']]
 370
 371   def _GetStandaloneExecutablePrefix(self):
 372     return self.spec.get('product_prefix', {
 373       'executable': '',
 374       'static_library': 'lib',
 375       'shared_library': 'lib',
 376       # Non-bundled loadable_modules are called foo.so for some reason
 377       # (that is, .so and no prefix) with the xcode build -- match that.
 378       'loadable_module': '',
 379     }[self.spec['type']])
 380
 381   def _GetStandaloneBinaryPath(self):
 382     """Returns the name of the non-bundle binary represented by this target.
 383     E.g. hello_world. Only valid for non-bundles."""
 384     assert not self._IsBundle()
 385     assert self.spec['type'] in (
 386         'executable', 'shared_library', 'static_library', 'loadable_module'), (
 387         'Unexpected type %s' % self.spec['type'])
 388     target = self.spec['target_name']
 389     if self.spec['type'] == 'static_library':
 390       if target[:3] == 'lib':
 391         target = target[3:]
 392     elif self.spec['type'] in ('loadable_module', 'shared_library'):
 393       if target[:3] == 'lib':
 394         target = target[3:]
 395
 396     target_prefix = self._GetStandaloneExecutablePrefix()
 397     target = self.spec.get('product_name', target)
 398     target_ext = self._GetStandaloneExecutableSuffix()
 399     return target_prefix + target + target_ext
 400
 401   def GetExecutableName(self):
 402     """Returns the executable name of the bundle represented by this target.
 403     E.g. Chromium."""
 404     if self._IsBundle():
 405       return self.spec.get('product_name', self.spec['target_name'])
 406     else:
 407       return self._GetStandaloneBinaryPath()
 408
 409   def GetExecutablePath(self):
 410     """Returns the directory name of the bundle represented by this target. E.g.
 411     Chromium.app/Contents/MacOS/Chromium."""
 412     if self._IsBundle():
 413       return self._GetBundleBinaryPath()
 414     else:
 415       return self._GetStandaloneBinaryPath()
 416
 417   def GetActiveArchs(self, configname):
 418     """Returns the architectures this target should be built for."""
 419     config_settings = self.xcode_settings[configname]
 420     xcode_archs_default = GetXcodeArchsDefault()
 421     return xcode_archs_default.ActiveArchs(
 422         config_settings.get('ARCHS'),
 423         config_settings.get('VALID_ARCHS'),
 424         config_settings.get('SDKROOT'))
 425
 426   def _GetSdkVersionInfoItem(self, sdk, infoitem):
 427     # xcodebuild requires Xcode and can't run on Command Line Tools-only
 428     # systems from 10.7 onward.
 429     # Since the CLT has no SDK paths anyway, returning None is the
 430     # most sensible route and should still do the right thing.
 431     try:
 432       return GetStdout(['xcodebuild', '-version', '-sdk', sdk, infoitem])
 433     except:
 434       pass
 435
 436   def _SdkRoot(self, configname):
 437     if configname is None:
 438       configname = self.configname
 439     return self.GetPerConfigSetting('SDKROOT', configname, default='')
 440
 441   def _SdkPath(self, configname=None):
 442     sdk_root = self._SdkRoot(configname)
 443     if sdk_root.startswith('/'):
 444       return sdk_root
 445     return self._XcodeSdkPath(sdk_root)
 446
 447   def _XcodeSdkPath(self, sdk_root):
 448     if sdk_root not in XcodeSettings._sdk_path_cache:
 449       sdk_path = self._GetSdkVersionInfoItem(sdk_root, 'Path')
 450       XcodeSettings._sdk_path_cache[sdk_root] = sdk_path
 451       if sdk_root:
 452         XcodeSettings._sdk_root_cache[sdk_path] = sdk_root
 453     return XcodeSettings._sdk_path_cache[sdk_root]
 454
 455   def _AppendPlatformVersionMinFlags(self, lst):
 456     self._Appendf(lst, 'MACOSX_DEPLOYMENT_TARGET', '-mmacosx-version-min=%s')
 457     if 'IPHONEOS_DEPLOYMENT_TARGET' in self._Settings():
 458       # TODO: Implement this better?
 459       sdk_path_basename = os.path.basename(self._SdkPath())
 460       if sdk_path_basename.lower().startswith('iphonesimulator'):
 461         self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
 462                       '-mios-simulator-version-min=%s')
 463       else:
 464         self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
 465                       '-miphoneos-version-min=%s')
 466
 467   def GetCflags(self, configname, arch=None):
 468     """Returns flags that need to be added to .c, .cc, .m, and .mm
 469     compilations."""
 470     # This functions (and the similar ones below) do not offer complete
 471     # emulation of all xcode_settings keys. They're implemented on demand.
 472
 473     self.configname = configname
 474     cflags = []
 475
 476     sdk_root = self._SdkPath()
 477     if 'SDKROOT' in self._Settings() and sdk_root:
 478       cflags.append('-isysroot %s' % sdk_root)
 479
 480     if self._Test('CLANG_WARN_CONSTANT_CONVERSION', 'YES', default='NO'):
 481       cflags.append('-Wconstant-conversion')
 482
 483     if self._Test('GCC_CHAR_IS_UNSIGNED_CHAR', 'YES', default='NO'):
 484       cflags.append('-funsigned-char')
 485
 486     if self._Test('GCC_CW_ASM_SYNTAX', 'YES', default='YES'):
 487       cflags.append('-fasm-blocks')
 488
 489     if 'GCC_DYNAMIC_NO_PIC' in self._Settings():
 490       if self._Settings()['GCC_DYNAMIC_NO_PIC'] == 'YES':
 491         cflags.append('-mdynamic-no-pic')
 492     else:
 493       pass
 494       # TODO: In this case, it depends on the target. xcode passes
 495       # mdynamic-no-pic by default for executable and possibly static lib
 496       # according to mento
 497
 498     if self._Test('GCC_ENABLE_PASCAL_STRINGS', 'YES', default='YES'):
 499       cflags.append('-mpascal-strings')
 500
 501     self._Appendf(cflags, 'GCC_OPTIMIZATION_LEVEL', '-O%s', default='s')
 502
 503     if self._Test('GCC_GENERATE_DEBUGGING_SYMBOLS', 'YES', default='YES'):
 504       dbg_format = self._Settings().get('DEBUG_INFORMATION_FORMAT', 'dwarf')
 505       if dbg_format == 'dwarf':
 506         cflags.append('-gdwarf-2')
 507       elif dbg_format == 'stabs':
 508         raise NotImplementedError('stabs debug format is not supported yet.')
 509       elif dbg_format == 'dwarf-with-dsym':
 510         cflags.append('-gdwarf-2')
 511       else:
 512         raise NotImplementedError('Unknown debug format %s' % dbg_format)
 513
 514     if self._Settings().get('GCC_STRICT_ALIASING') == 'YES':
 515       cflags.append('-fstrict-aliasing')
 516     elif self._Settings().get('GCC_STRICT_ALIASING') == 'NO':
 517       cflags.append('-fno-strict-aliasing')
 518
 519     if self._Test('GCC_SYMBOLS_PRIVATE_EXTERN', 'YES', default='NO'):
 520       cflags.append('-fvisibility=hidden')
 521
 522     if self._Test('GCC_TREAT_WARNINGS_AS_ERRORS', 'YES', default='NO'):
 523       cflags.append('-Werror')
 524
 525     if self._Test('GCC_WARN_ABOUT_MISSING_NEWLINE', 'YES', default='NO'):
 526       cflags.append('-Wnewline-eof')
 527
 528     # In Xcode, this is only activated when GCC_COMPILER_VERSION is clang or
 529     # llvm-gcc. It also requires a fairly recent libtool, and
 530     # if the system clang isn't used, DYLD_LIBRARY_PATH needs to contain the
 531     # path to the libLTO.dylib that matches the used clang.
 532     if self._Test('LLVM_LTO', 'YES', default='NO'):
 533       cflags.append('-flto')
 534
 535     self._AppendPlatformVersionMinFlags(cflags)
 536
 537     # TODO:
 538     if self._Test('COPY_PHASE_STRIP', 'YES', default='NO'):
 539       self._WarnUnimplemented('COPY_PHASE_STRIP')
 540     self._WarnUnimplemented('GCC_DEBUGGING_SYMBOLS')
 541     self._WarnUnimplemented('GCC_ENABLE_OBJC_EXCEPTIONS')
 542
 543     # TODO: This is exported correctly, but assigning to it is not supported.
 544     self._WarnUnimplemented('MACH_O_TYPE')
 545     self._WarnUnimplemented('PRODUCT_TYPE')
 546
 547     if arch is not None:
 548       archs = [arch]
 549     else:
 550       assert self.configname
 551       archs = self.GetActiveArchs(self.configname)
 552     if len(archs) != 1:
 553       # TODO: Supporting fat binaries will be annoying.
 554       self._WarnUnimplemented('ARCHS')
 555       archs = ['i386']
 556     cflags.append('-arch ' + archs[0])
 557
 558     if archs[0] in ('i386', 'x86_64'):
 559       if self._Test('GCC_ENABLE_SSE3_EXTENSIONS', 'YES', default='NO'):
 560         cflags.append('-msse3')
 561       if self._Test('GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS', 'YES',
 562                     default='NO'):
 563         cflags.append('-mssse3')  # Note 3rd 's'.
 564       if self._Test('GCC_ENABLE_SSE41_EXTENSIONS', 'YES', default='NO'):
 565         cflags.append('-msse4.1')
 566       if self._Test('GCC_ENABLE_SSE42_EXTENSIONS', 'YES', default='NO'):
 567         cflags.append('-msse4.2')
 568
 569     cflags += self._Settings().get('WARNING_CFLAGS', [])
 570
 571     if sdk_root:
 572       framework_root = sdk_root
 573     else:
 574       framework_root = ''
 575     config = self.spec['configurations'][self.configname]
 576     framework_dirs = config.get('mac_framework_dirs', [])
 577     for directory in framework_dirs:
 578       cflags.append('-F' + directory.replace('$(SDKROOT)', framework_root))
 579
 580     self.configname = None
 581     return cflags
 582
 583   def GetCflagsC(self, configname):
 584     """Returns flags that need to be added to .c, and .m compilations."""
 585     self.configname = configname
 586     cflags_c = []
 587     if self._Settings().get('GCC_C_LANGUAGE_STANDARD', '') == 'ansi':
 588       cflags_c.append('-ansi')
 589     else:
 590       self._Appendf(cflags_c, 'GCC_C_LANGUAGE_STANDARD', '-std=%s')
 591     cflags_c += self._Settings().get('OTHER_CFLAGS', [])
 592     self.configname = None
 593     return cflags_c
 594
 595   def GetCflagsCC(self, configname):
 596     """Returns flags that need to be added to .cc, and .mm compilations."""
 597     self.configname = configname
 598     cflags_cc = []
 599
 600     clang_cxx_language_standard = self._Settings().get(
 601         'CLANG_CXX_LANGUAGE_STANDARD')
 602     # Note: Don't make c++0x to c++11 so that c++0x can be used with older
 603     # clangs that don't understand c++11 yet (like Xcode 4.2's).
 604     if clang_cxx_language_standard:
 605       cflags_cc.append('-std=%s' % clang_cxx_language_standard)
 606
 607     self._Appendf(cflags_cc, 'CLANG_CXX_LIBRARY', '-stdlib=%s')
 608
 609     if self._Test('GCC_ENABLE_CPP_RTTI', 'NO', default='YES'):
 610       cflags_cc.append('-fno-rtti')
 611     if self._Test('GCC_ENABLE_CPP_EXCEPTIONS', 'NO', default='YES'):
 612       cflags_cc.append('-fno-exceptions')
 613     if self._Test('GCC_INLINES_ARE_PRIVATE_EXTERN', 'YES', default='NO'):
 614       cflags_cc.append('-fvisibility-inlines-hidden')
 615     if self._Test('GCC_THREADSAFE_STATICS', 'NO', default='YES'):
 616       cflags_cc.append('-fno-threadsafe-statics')
 617     # Note: This flag is a no-op for clang, it only has an effect for gcc.
 618     if self._Test('GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO', 'NO', default='YES'):
 619       cflags_cc.append('-Wno-invalid-offsetof')
 620
 621     other_ccflags = []
 622
 623     for flag in self._Settings().get('OTHER_CPLUSPLUSFLAGS', ['$(inherited)']):
 624       # TODO: More general variable expansion. Missing in many other places too.
 625       if flag in ('$inherited', '$(inherited)', '${inherited}'):
 626         flag = '$OTHER_CFLAGS'
 627       if flag in ('$OTHER_CFLAGS', '$(OTHER_CFLAGS)', '${OTHER_CFLAGS}'):
 628         other_ccflags += self._Settings().get('OTHER_CFLAGS', [])
 629       else:
 630         other_ccflags.append(flag)
 631     cflags_cc += other_ccflags
 632
 633     self.configname = None
 634     return cflags_cc
 635
 636   def _AddObjectiveCGarbageCollectionFlags(self, flags):
 637     gc_policy = self._Settings().get('GCC_ENABLE_OBJC_GC', 'unsupported')
 638     if gc_policy == 'supported':
 639       flags.append('-fobjc-gc')
 640     elif gc_policy == 'required':
 641       flags.append('-fobjc-gc-only')
 642
 643   def _AddObjectiveCARCFlags(self, flags):
 644     if self._Test('CLANG_ENABLE_OBJC_ARC', 'YES', default='NO'):
 645       flags.append('-fobjc-arc')
 646
 647   def _AddObjectiveCMissingPropertySynthesisFlags(self, flags):
 648     if self._Test('CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS',
 649                   'YES', default='NO'):
 650       flags.append('-Wobjc-missing-property-synthesis')
 651
 652   def GetCflagsObjC(self, configname):
 653     """Returns flags that need to be added to .m compilations."""
 654     self.configname = configname
 655     cflags_objc = []
 656     self._AddObjectiveCGarbageCollectionFlags(cflags_objc)
 657     self._AddObjectiveCARCFlags(cflags_objc)
 658     self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objc)
 659     self.configname = None
 660     return cflags_objc
 661
 662   def GetCflagsObjCC(self, configname):
 663     """Returns flags that need to be added to .mm compilations."""
 664     self.configname = configname
 665     cflags_objcc = []
 666     self._AddObjectiveCGarbageCollectionFlags(cflags_objcc)
 667     self._AddObjectiveCARCFlags(cflags_objcc)
 668     self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objcc)
 669     if self._Test('GCC_OBJC_CALL_CXX_CDTORS', 'YES', default='NO'):
 670       cflags_objcc.append('-fobjc-call-cxx-cdtors')
 671     self.configname = None
 672     return cflags_objcc
 673
 674   def GetInstallNameBase(self):
 675     """Return DYLIB_INSTALL_NAME_BASE for this target."""
 676     # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
 677     if (self.spec['type'] != 'shared_library' and
 678         (self.spec['type'] != 'loadable_module' or self._IsBundle())):
 679       return None
 680     install_base = self.GetPerTargetSetting(
 681         'DYLIB_INSTALL_NAME_BASE',
 682         default='/Library/Frameworks' if self._IsBundle() else '/usr/local/lib')
 683     return install_base
 684
 685   def _StandardizePath(self, path):
 686     """Do :standardizepath processing for path."""
 687     # I'm not quite sure what :standardizepath does. Just call normpath(),
 688     # but don't let @executable_path/../foo collapse to foo.
 689     if '/' in path:
 690       prefix, rest = '', path
 691       if path.startswith('@'):
 692         prefix, rest = path.split('/', 1)
 693       rest = os.path.normpath(rest)  # :standardizepath
 694       path = os.path.join(prefix, rest)
 695     return path
 696
 697   def GetInstallName(self):
 698     """Return LD_DYLIB_INSTALL_NAME for this target."""
 699     # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
 700     if (self.spec['type'] != 'shared_library' and
 701         (self.spec['type'] != 'loadable_module' or self._IsBundle())):
 702       return None
 703
 704     default_install_name = \
 705         '$(DYLIB_INSTALL_NAME_BASE:standardizepath)/$(EXECUTABLE_PATH)'
 706     install_name = self.GetPerTargetSetting(
 707         'LD_DYLIB_INSTALL_NAME', default=default_install_name)
 708
 709     # Hardcode support for the variables used in chromium for now, to
 710     # unblock people using the make build.
 711     if '$' in install_name:
 712       assert install_name in ('$(DYLIB_INSTALL_NAME_BASE:standardizepath)/'
 713           '$(WRAPPER_NAME)/$(PRODUCT_NAME)', default_install_name), (
 714           'Variables in LD_DYLIB_INSTALL_NAME are not generally supported '
 715           'yet in target \'%s\' (got \'%s\')' %
 716               (self.spec['target_name'], install_name))
 717
 718       install_name = install_name.replace(
 719           '$(DYLIB_INSTALL_NAME_BASE:standardizepath)',
 720           self._StandardizePath(self.GetInstallNameBase()))
 721       if self._IsBundle():
 722         # These are only valid for bundles, hence the |if|.
 723         install_name = install_name.replace(
 724             '$(WRAPPER_NAME)', self.GetWrapperName())
 725         install_name = install_name.replace(
 726             '$(PRODUCT_NAME)', self.GetProductName())
 727       else:
 728         assert '$(WRAPPER_NAME)' not in install_name
 729         assert '$(PRODUCT_NAME)' not in install_name
 730
 731       install_name = install_name.replace(
 732           '$(EXECUTABLE_PATH)', self.GetExecutablePath())
 733     return install_name
 734
 735   def _MapLinkerFlagFilename(self, ldflag, gyp_to_build_path):
 736     """Checks if ldflag contains a filename and if so remaps it from
 737     gyp-directory-relative to build-directory-relative."""
 738     # This list is expanded on demand.
 739     # They get matched as:
 740     #   -exported_symbols_list file
 741     #   -Wl,exported_symbols_list file
 742     #   -Wl,exported_symbols_list,file
 743     LINKER_FILE = r'(\S+)'
 744     WORD = r'\S+'
 745     linker_flags = [
 746       ['-exported_symbols_list', LINKER_FILE],    # Needed for NaCl.
 747       ['-unexported_symbols_list', LINKER_FILE],
 748       ['-reexported_symbols_list', LINKER_FILE],
 749       ['-sectcreate', WORD, WORD, LINKER_FILE],   # Needed for remoting.
 750     ]
 751     for flag_pattern in linker_flags:
 752       regex = re.compile('(?:-Wl,)?' + '[ ,]'.join(flag_pattern))
 753       m = regex.match(ldflag)
 754       if m:
 755         ldflag = ldflag[:m.start(1)] + gyp_to_build_path(m.group(1)) + \
 756                  ldflag[m.end(1):]
 757     # Required for ffmpeg (no idea why they don't use LIBRARY_SEARCH_PATHS,
 758     # TODO(thakis): Update ffmpeg.gyp):
 759     if ldflag.startswith('-L'):
 760       ldflag = '-L' + gyp_to_build_path(ldflag[len('-L'):])
 761     return ldflag
 762
 763   def GetLdflags(self, configname, product_dir, gyp_to_build_path, arch=None):
 764     """Returns flags that need to be passed to the linker.
 765
 766     Args:
 767         configname: The name of the configuration to get ld flags for.
 768         product_dir: The directory where products such static and dynamic
 769             libraries are placed. This is added to the library search path.
 770         gyp_to_build_path: A function that converts paths relative to the
 771             current gyp file to paths relative to the build direcotry.
 772     """
 773     self.configname = configname
 774     ldflags = []
 775
 776     # The xcode build is relative to a gyp file's directory, and OTHER_LDFLAGS
 777     # can contain entries that depend on this. Explicitly absolutify these.
 778     for ldflag in self._Settings().get('OTHER_LDFLAGS', []):
 779       ldflags.append(self._MapLinkerFlagFilename(ldflag, gyp_to_build_path))
 780
 781     if self._Test('DEAD_CODE_STRIPPING', 'YES', default='NO'):
 782       ldflags.append('-Wl,-dead_strip')
 783
 784     if self._Test('PREBINDING', 'YES', default='NO'):
 785       ldflags.append('-Wl,-prebind')
 786
 787     self._Appendf(
 788         ldflags, 'DYLIB_COMPATIBILITY_VERSION', '-compatibility_version %s')
 789     self._Appendf(
 790         ldflags, 'DYLIB_CURRENT_VERSION', '-current_version %s')
 791
 792     self._AppendPlatformVersionMinFlags(ldflags)
 793
 794     if 'SDKROOT' in self._Settings() and self._SdkPath():
 795       ldflags.append('-isysroot ' + self._SdkPath())
 796
 797     for library_path in self._Settings().get('LIBRARY_SEARCH_PATHS', []):
 798       ldflags.append('-L' + gyp_to_build_path(library_path))
 799
 800     if 'ORDER_FILE' in self._Settings():
 801       ldflags.append('-Wl,-order_file ' +
 802                      '-Wl,' + gyp_to_build_path(
 803                                   self._Settings()['ORDER_FILE']))
 804
 805     if arch is not None:
 806       archs = [arch]
 807     else:
 808       assert self.configname
 809       archs = self.GetActiveArchs(self.configname)
 810     if len(archs) != 1:
 811       # TODO: Supporting fat binaries will be annoying.
 812       self._WarnUnimplemented('ARCHS')
 813       archs = ['i386']
 814     ldflags.append('-arch ' + archs[0])
 815
 816     # Xcode adds the product directory by default.
 817     ldflags.append('-L' + product_dir)
 818
 819     install_name = self.GetInstallName()
 820     if install_name and self.spec['type'] != 'loadable_module':
 821       ldflags.append('-install_name ' + install_name.replace(' ', r'\ '))
 822
 823     for rpath in self._Settings().get('LD_RUNPATH_SEARCH_PATHS', []):
 824       ldflags.append('-Wl,-rpath,' + rpath)
 825
 826     sdk_root = self._SdkPath()
 827     if not sdk_root:
 828       sdk_root = ''
 829     config = self.spec['configurations'][self.configname]
 830     framework_dirs = config.get('mac_framework_dirs', [])
 831     for directory in framework_dirs:
 832       ldflags.append('-F' + directory.replace('$(SDKROOT)', sdk_root))
 833
 834     is_extension = self._IsIosAppExtension() or self._IsIosWatchKitExtension()
 835     if sdk_root and is_extension:
 836       # Adds the link flags for extensions. These flags are common for all
 837       # extensions and provide loader and main function.
 838       # These flags reflect the compilation options used by xcode to compile
 839       # extensions.
 840       ldflags.append('-lpkstart')
 841       if XcodeVersion() < '0900':
 842         ldflags.append(sdk_root +
 843             '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')
 844       ldflags.append('-fapplication-extension')
 845       ldflags.append('-Xlinker -rpath '
 846           '-Xlinker @executable_path/../../Frameworks')
 847
 848     self._Appendf(ldflags, 'CLANG_CXX_LIBRARY', '-stdlib=%s')
 849
 850     self.configname = None
 851     return ldflags
 852
 853   def GetLibtoolflags(self, configname):
 854     """Returns flags that need to be passed to the static linker.
 855
 856     Args:
 857         configname: The name of the configuration to get ld flags for.
 858     """
 859     self.configname = configname
 860     libtoolflags = []
 861
 862     for libtoolflag in self._Settings().get('OTHER_LDFLAGS', []):
 863       libtoolflags.append(libtoolflag)
 864     # TODO(thakis): ARCHS?
 865
 866     self.configname = None
 867     return libtoolflags
 868
 869   def GetPerTargetSettings(self):
 870     """Gets a list of all the per-target settings. This will only fetch keys
 871     whose values are the same across all configurations."""
 872     first_pass = True
 873     result = {}
 874     for configname in sorted(self.xcode_settings.keys()):
 875       if first_pass:
 876         result = dict(self.xcode_settings[configname])
 877         first_pass = False
 878       else:
 879         for key, value in self.xcode_settings[configname].iteritems():
 880           if key not in result:
 881             continue
 882           elif result[key] != value:
 883             del result[key]
 884     return result
 885
 886   def GetPerConfigSetting(self, setting, configname, default=None):
 887     if configname in self.xcode_settings:
 888       return self.xcode_settings[configname].get(setting, default)
 889     else:
 890       return self.GetPerTargetSetting(setting, default)
 891
 892   def GetPerTargetSetting(self, setting, default=None):
 893     """Tries to get xcode_settings.setting from spec. Assumes that the setting
 894        has the same value in all configurations and throws otherwise."""
 895     is_first_pass = True
 896     result = None
 897     for configname in sorted(self.xcode_settings.keys()):
 898       if is_first_pass:
 899         result = self.xcode_settings[configname].get(setting, None)
 900         is_first_pass = False
 901       else:
 902         assert result == self.xcode_settings[configname].get(setting, None), (
 903             "Expected per-target setting for '%s', got per-config setting "
 904             "(target %s)" % (setting, self.spec['target_name']))
 905     if result is None:
 906       return default
 907     return result
 908
 909   def _GetStripPostbuilds(self, configname, output_binary, quiet):
 910     """Returns a list of shell commands that contain the shell commands
 911     neccessary to strip this target's binary. These should be run as postbuilds
 912     before the actual postbuilds run."""
 913     self.configname = configname
 914
 915     result = []
 916     if (self._Test('DEPLOYMENT_POSTPROCESSING', 'YES', default='NO') and
 917         self._Test('STRIP_INSTALLED_PRODUCT', 'YES', default='NO')):
 918
 919       default_strip_style = 'debugging'
 920       if self.spec['type'] == 'loadable_module' and self._IsBundle():
 921         default_strip_style = 'non-global'
 922       elif self.spec['type'] == 'executable':
 923         default_strip_style = 'all'
 924
 925       strip_style = self._Settings().get('STRIP_STYLE', default_strip_style)
 926       strip_flags = {
 927         'all': '',
 928         'non-global': '-x',
 929         'debugging': '-S',
 930       }[strip_style]
 931
 932       explicit_strip_flags = self._Settings().get('STRIPFLAGS', '')
 933       if explicit_strip_flags:
 934         strip_flags += ' ' + _NormalizeEnvVarReferences(explicit_strip_flags)
 935
 936       if not quiet:
 937         result.append('echo STRIP\\(%s\\)' % self.spec['target_name'])
 938       result.append('strip %s %s' % (strip_flags, output_binary))
 939
 940     self.configname = None
 941     return result
 942
 943   def _GetDebugInfoPostbuilds(self, configname, output, output_binary, quiet):
 944     """Returns a list of shell commands that contain the shell commands
 945     neccessary to massage this target's debug information. These should be run
 946     as postbuilds before the actual postbuilds run."""
 947     self.configname = configname
 948
 949     # For static libraries, no dSYMs are created.
 950     result = []
 951     if (self._Test('GCC_GENERATE_DEBUGGING_SYMBOLS', 'YES', default='YES') and
 952         self._Test(
 953             'DEBUG_INFORMATION_FORMAT', 'dwarf-with-dsym', default='dwarf') and
 954         self.spec['type'] != 'static_library'):
 955       if not quiet:
 956         result.append('echo DSYMUTIL\\(%s\\)' % self.spec['target_name'])
 957       result.append('dsymutil %s -o %s' % (output_binary, output + '.dSYM'))
 958
 959     self.configname = None
 960     return result
 961
 962   def _GetTargetPostbuilds(self, configname, output, output_binary,
 963                            quiet=False):
 964     """Returns a list of shell commands that contain the shell commands
 965     to run as postbuilds for this target, before the actual postbuilds."""
 966     # dSYMs need to build before stripping happens.
 967     return (
 968         self._GetDebugInfoPostbuilds(configname, output, output_binary, quiet) +
 969         self._GetStripPostbuilds(configname, output_binary, quiet))
 970
 971   def _GetIOSPostbuilds(self, configname, output_binary):
 972     """Return a shell command to codesign the iOS output binary so it can
 973     be deployed to a device.  This should be run as the very last step of the
 974     build."""
 975     if not (self.isIOS and self.spec['type'] == 'executable'):
 976       return []
 977
 978     settings = self.xcode_settings[configname]
 979     key = self._GetIOSCodeSignIdentityKey(settings)
 980     if not key:
 981       return []
 982
 983     # Warn for any unimplemented signing xcode keys.
 984     unimpl = ['OTHER_CODE_SIGN_FLAGS']
 985     unimpl = set(unimpl) & set(self.xcode_settings[configname].keys())
 986     if unimpl:
 987       print 'Warning: Some codesign keys not implemented, ignoring: %s' % (
 988           ', '.join(sorted(unimpl)))
 989
 990     return ['%s code-sign-bundle "%s" "%s" "%s" "%s"' % (
 991         os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
 992         settings.get('CODE_SIGN_RESOURCE_RULES_PATH', ''),
 993         settings.get('CODE_SIGN_ENTITLEMENTS', ''),
 994         settings.get('PROVISIONING_PROFILE', ''))
 995     ]
 996
 997   def _GetIOSCodeSignIdentityKey(self, settings):
 998     identity = settings.get('CODE_SIGN_IDENTITY')
 999     if not identity:
1000       return None
1001     if identity not in XcodeSettings._codesigning_key_cache:
1002       output = subprocess.check_output(
1003           ['security', 'find-identity', '-p', 'codesigning', '-v'])
1004       for line in output.splitlines():
1005         if identity in line:
1006           fingerprint = line.split()[1]
1007           cache = XcodeSettings._codesigning_key_cache
1008           assert identity not in cache or fingerprint == cache[identity], (
1009               "Multiple codesigning fingerprints for identity: %s" % identity)
1010           XcodeSettings._codesigning_key_cache[identity] = fingerprint
1011     return XcodeSettings._codesigning_key_cache.get(identity, '')
1012
1013   def AddImplicitPostbuilds(self, configname, output, output_binary,
1014                             postbuilds=[], quiet=False):
1015     """Returns a list of shell commands that should run before and after
1016     |postbuilds|."""
1017     assert output_binary is not None
1018     pre = self._GetTargetPostbuilds(configname, output, output_binary, quiet)
1019     post = self._GetIOSPostbuilds(configname, output_binary)
1020     return pre + postbuilds + post
1021
1022   def _AdjustLibrary(self, library, config_name=None):
1023     if library.endswith('.framework'):
1024       l = '-framework ' + os.path.splitext(os.path.basename(library))[0]
1025     else:
1026       m = self.library_re.match(library)
1027       if m:
1028         l = '-l' + m.group(1)
1029       else:
1030         l = library
1031
1032     sdk_root = self._SdkPath(config_name)
1033     if not sdk_root:
1034       sdk_root = ''
1035     # Xcode 7 started shipping with ".tbd" (text based stubs) files instead of
1036     # ".dylib" without providing a real support for them. What it does, for
1037     # "/usr/lib" libraries, is do "-L/usr/lib -lname" which is dependent on the
1038     # library order and cause collision when building Chrome.
1039     #
1040     # Instead substitude ".tbd" to ".dylib" in the generated project when the
1041     # following conditions are both true:
1042     # - library is referenced in the gyp file as "$(SDKROOT)/**/*.dylib",
1043     # - the ".dylib" file does not exists but a ".tbd" file do.
1044     library = l.replace('$(SDKROOT)', sdk_root)
1045     if l.startswith('$(SDKROOT)'):
1046       basename, ext = os.path.splitext(library)
1047       if ext == '.dylib' and not os.path.exists(library):
1048         tbd_library = basename + '.tbd'
1049         if os.path.exists(tbd_library):
1050           library = tbd_library
1051     return library
1052
1053   def AdjustLibraries(self, libraries, config_name=None):
1054     """Transforms entries like 'Cocoa.framework' in libraries into entries like
1055     '-framework Cocoa', 'libcrypto.dylib' into '-lcrypto', etc.
1056     """
1057     libraries = [self._AdjustLibrary(library, config_name)
1058                  for library in libraries]
1059     return libraries
1060
1061   def _BuildMachineOSBuild(self):
1062     return GetStdout(['sw_vers', '-buildVersion'])
1063
1064   def _XcodeIOSDeviceFamily(self, configname):
1065     family = self.xcode_settings[configname].get('TARGETED_DEVICE_FAMILY', '1')
1066     return [int(x) for x in family.split(',')]
1067
1068   def GetExtraPlistItems(self, configname=None):
1069     """Returns a dictionary with extra items to insert into Info.plist."""
1070     if configname not in XcodeSettings._plist_cache:
1071       cache = {}
1072       cache['BuildMachineOSBuild'] = self._BuildMachineOSBuild()
1073
1074       xcode, xcode_build = XcodeVersion()
1075       cache['DTXcode'] = xcode
1076       cache['DTXcodeBuild'] = xcode_build
1077
1078       sdk_root = self._SdkRoot(configname)
1079       if not sdk_root:
1080         sdk_root = self._DefaultSdkRoot()
1081       cache['DTSDKName'] = sdk_root
1082       if xcode >= '0430':
1083         cache['DTSDKBuild'] = self._GetSdkVersionInfoItem(
1084             sdk_root, 'ProductBuildVersion')
1085       else:
1086         cache['DTSDKBuild'] = cache['BuildMachineOSBuild']
1087
1088       if self.isIOS:
1089         cache['DTPlatformName'] = cache['DTSDKName']
1090         if configname.endswith("iphoneos"):
1091           cache['DTPlatformVersion'] = self._GetSdkVersionInfoItem(
1092               sdk_root, 'ProductVersion')
1093           cache['CFBundleSupportedPlatforms'] = ['iPhoneOS']
1094         else:
1095           cache['CFBundleSupportedPlatforms'] = ['iPhoneSimulator']
1096       XcodeSettings._plist_cache[configname] = cache
1097
1098     # Include extra plist items that are per-target, not per global
1099     # XcodeSettings.
1100     items = dict(XcodeSettings._plist_cache[configname])
1101     if self.isIOS:
1102       items['UIDeviceFamily'] = self._XcodeIOSDeviceFamily(configname)
1103     return items
1104
1105   def _DefaultSdkRoot(self):
1106     """Returns the default SDKROOT to use.
1107
1108     Prior to version 5.0.0, if SDKROOT was not explicitly set in the Xcode
1109     project, then the environment variable was empty. Starting with this
1110     version, Xcode uses the name of the newest SDK installed.
1111     """
1112     xcode_version, xcode_build = XcodeVersion()
1113     if xcode_version < '0500':
1114       return ''
1115     default_sdk_path = self._XcodeSdkPath('')
1116     default_sdk_root = XcodeSettings._sdk_root_cache.get(default_sdk_path)
1117     if default_sdk_root:
1118       return default_sdk_root
1119     try:
1120       all_sdks = GetStdout(['xcodebuild', '-showsdks'])
1121     except:
1122       # If xcodebuild fails, there will be no valid SDKs
1123       return ''
1124     for line in all_sdks.splitlines():
1125       items = line.split()
1126       if len(items) >= 3 and items[-2] == '-sdk':
1127         sdk_root = items[-1]
1128         sdk_path = self._XcodeSdkPath(sdk_root)
1129         if sdk_path == default_sdk_path:
1130           return sdk_root
1131     return ''
1132
1133
1134 class MacPrefixHeader(object):
1135   """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.
1136
1137   This feature consists of several pieces:
1138   * If GCC_PREFIX_HEADER is present, all compilations in that project get an
1139     additional |-include path_to_prefix_header| cflag.
1140   * If GCC_PRECOMPILE_PREFIX_HEADER is present too, then the prefix header is
1141     instead compiled, and all other compilations in the project get an
1142     additional |-include path_to_compiled_header| instead.
1143     + Compiled prefix headers have the extension gch. There is one gch file for
1144       every language used in the project (c, cc, m, mm), since gch files for
1145       different languages aren't compatible.
1146     + gch files themselves are built with the target's normal cflags, but they
1147       obviously don't get the |-include| flag. Instead, they need a -x flag that
1148       describes their language.
1149     + All o files in the target need to depend on the gch file, to make sure
1150       it's built before any o file is built.
1151
1152   This class helps with some of these tasks, but it needs help from the build
1153   system for writing dependencies to the gch files, for writing build commands
1154   for the gch files, and for figuring out the location of the gch files.
1155   """
1156   def __init__(self, xcode_settings,
1157                gyp_path_to_build_path, gyp_path_to_build_output):
1158     """If xcode_settings is None, all methods on this class are no-ops.
1159
1160     Args:
1161         gyp_path_to_build_path: A function that takes a gyp-relative path,
1162             and returns a path relative to the build directory.
1163         gyp_path_to_build_output: A function that takes a gyp-relative path and
1164             a language code ('c', 'cc', 'm', or 'mm'), and that returns a path
1165             to where the output of precompiling that path for that language
1166             should be placed (without the trailing '.gch').
1167     """
1168     # This doesn't support per-configuration prefix headers. Good enough
1169     # for now.
1170     self.header = None
1171     self.compile_headers = False
1172     if xcode_settings:
1173       self.header = xcode_settings.GetPerTargetSetting('GCC_PREFIX_HEADER')
1174       self.compile_headers = xcode_settings.GetPerTargetSetting(
1175           'GCC_PRECOMPILE_PREFIX_HEADER', default='NO') != 'NO'
1176     self.compiled_headers = {}
1177     if self.header:
1178       if self.compile_headers:
1179         for lang in ['c', 'cc', 'm', 'mm']:
1180           self.compiled_headers[lang] = gyp_path_to_build_output(
1181               self.header, lang)
1182       self.header = gyp_path_to_build_path(self.header)
1183
1184   def _CompiledHeader(self, lang, arch):
1185     assert self.compile_headers
1186     h = self.compiled_headers[lang]
1187     if arch:
1188       h += '.' + arch
1189     return h
1190
1191   def GetInclude(self, lang, arch=None):
1192     """Gets the cflags to include the prefix header for language |lang|."""
1193     if self.compile_headers and lang in self.compiled_headers:
1194       return '-include %s' % self._CompiledHeader(lang, arch)
1195     elif self.header:
1196       return '-include %s' % self.header
1197     else:
1198       return ''
1199
1200   def _Gch(self, lang, arch):
1201     """Returns the actual file name of the prefix header for language |lang|."""
1202     assert self.compile_headers
1203     return self._CompiledHeader(lang, arch) + '.gch'
1204
1205   def GetObjDependencies(self, sources, objs, arch=None):
1206     """Given a list of source files and the corresponding object files, returns
1207     a list of (source, object, gch) tuples, where |gch| is the build-directory
1208     relative path to the gch file each object file depends on.  |compilable[i]|
1209     has to be the source file belonging to |objs[i]|."""
1210     if not self.header or not self.compile_headers:
1211       return []
1212
1213     result = []
1214     for source, obj in zip(sources, objs):
1215       ext = os.path.splitext(source)[1]
1216       lang = {
1217         '.c': 'c',
1218         '.cpp': 'cc', '.cc': 'cc', '.cxx': 'cc',
1219         '.m': 'm',
1220         '.mm': 'mm',
1221       }.get(ext, None)
1222       if lang:
1223         result.append((source, obj, self._Gch(lang, arch)))
1224     return result
1225
1226   def GetPchBuildCommands(self, arch=None):
1227     """Returns [(path_to_gch, language_flag, language, header)].
1228     |path_to_gch| and |header| are relative to the build directory.
1229     """
1230     if not self.header or not self.compile_headers:
1231       return []
1232     return [
1233       (self._Gch('c', arch), '-x c-header', 'c', self.header),
1234       (self._Gch('cc', arch), '-x c++-header', 'cc', self.header),
1235       (self._Gch('m', arch), '-x objective-c-header', 'm', self.header),
1236       (self._Gch('mm', arch), '-x objective-c++-header', 'mm', self.header),
1237     ]
1238
1239
1240 def XcodeVersion():
1241   """Returns a tuple of version and build version of installed Xcode."""
1242   # `xcodebuild -version` output looks like
1243   #    Xcode 4.6.3
1244   #    Build version 4H1503
1245   # or like
1246   #    Xcode 3.2.6
1247   #    Component versions: DevToolsCore-1809.0; DevToolsSupport-1806.0
1248   #    BuildVersion: 10M2518
1249   # Convert that to '0463', '4H1503'.
1250   global XCODE_VERSION_CACHE
1251   if XCODE_VERSION_CACHE:
1252     return XCODE_VERSION_CACHE
1253   try:
1254     version_list = GetStdout(['xcodebuild', '-version']).splitlines()
1255     # In some circumstances xcodebuild exits 0 but doesn't return
1256     # the right results; for example, a user on 10.7 or 10.8 with
1257     # a bogus path set via xcode-select
1258     # In that case this may be a CLT-only install so fall back to
1259     # checking that version.
1260     if len(version_list) < 2:
1261       raise GypError("xcodebuild returned unexpected results")
1262   except:
1263     version = CLTVersion()
1264     if version:
1265       version = re.match(r'(\d\.\d\.?\d*)', version).groups()[0]
1266     else:
1267       raise GypError("No Xcode or CLT version detected!")
1268     # The CLT has no build information, so we return an empty string.
1269     version_list = [version, '']
1270   version = version_list[0]
1271   build = version_list[-1]
1272   # Be careful to convert "4.2" to "0420":
1273   version = version.split()[-1].replace('.', '')
1274   version = (version + '0' * (3 - len(version))).zfill(4)
1275   if build:
1276     build = build.split()[-1]
1277   XCODE_VERSION_CACHE = (version, build)
1278   return XCODE_VERSION_CACHE
1279
1280
1281 # This function ported from the logic in Homebrew's CLT version check
1282 def CLTVersion():
1283   """Returns the version of command-line tools from pkgutil."""
1284   # pkgutil output looks like
1285   #   package-id: com.apple.pkg.CLTools_Executables
1286   #   version: 5.0.1.0.1.1382131676
1287   #   volume: /
1288   #   location: /
1289   #   install-time: 1382544035
1290   #   groups: com.apple.FindSystemFiles.pkg-group com.apple.DevToolsBoth.pkg-group com.apple.DevToolsNonRelocatableShared.pkg-group
1291   STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo"
1292   FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI"
1293   MAVERICKS_PKG_ID = "com.apple.pkg.CLTools_Executables"
1294
1295   regex = re.compile('version: (?P<version>.+)')
1296   for key in [MAVERICKS_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID]:
1297     try:
1298       output = GetStdout(['/usr/sbin/pkgutil', '--pkg-info', key])
1299       return re.search(regex, output).groupdict()['version']
1300     except:
1301       continue
1302
1303
1304 def GetStdout(cmdlist):
1305   """Returns the content of standard output returned by invoking |cmdlist|.
1306   Raises |GypError| if the command return with a non-zero return code."""
1307   job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE)
1308   out = job.communicate()[0]
1309   if job.returncode != 0:
1310     sys.stderr.write(out + '\n')
1311     raise GypError('Error %d running %s' % (job.returncode, cmdlist[0]))
1312   return out.rstrip('\n')
1313
1314
1315 def MergeGlobalXcodeSettingsToSpec(global_dict, spec):
1316   """Merges the global xcode_settings dictionary into each configuration of the
1317   target represented by spec. For keys that are both in the global and the local
1318   xcode_settings dict, the local key gets precendence.
1319   """
1320   # The xcode generator special-cases global xcode_settings and does something
1321   # that amounts to merging in the global xcode_settings into each local
1322   # xcode_settings dict.
1323   global_xcode_settings = global_dict.get('xcode_settings', {})
1324   for config in spec['configurations'].values():
1325     if 'xcode_settings' in config:
1326       new_settings = global_xcode_settings.copy()
1327       new_settings.update(config['xcode_settings'])
1328       config['xcode_settings'] = new_settings
1329
1330
1331 def IsMacBundle(flavor, spec):
1332   """Returns if |spec| should be treated as a bundle.
1333
1334   Bundles are directories with a certain subdirectory structure, instead of
1335   just a single file. Bundle rules do not produce a binary but also package
1336   resources into that directory."""
1337   is_mac_bundle = (int(spec.get('mac_bundle', 0)) != 0 and flavor == 'mac')
1338   if is_mac_bundle:
1339     assert spec['type'] != 'none', (
1340         'mac_bundle targets cannot have type none (target "%s")' %
1341         spec['target_name'])
1342   return is_mac_bundle
1343
1344
1345 def GetMacBundleResources(product_dir, xcode_settings, resources):
1346   """Yields (output, resource) pairs for every resource in |resources|.
1347   Only call this for mac bundle targets.
1348
1349   Args:
1350       product_dir: Path to the directory containing the output bundle,
1351           relative to the build directory.
1352       xcode_settings: The XcodeSettings of the current target.
1353       resources: A list of bundle resources, relative to the build directory.
1354   """
1355   dest = os.path.join(product_dir,
1356                       xcode_settings.GetBundleResourceFolder())
1357   for res in resources:
1358     output = dest
1359
1360     # The make generator doesn't support it, so forbid it everywhere
1361     # to keep the generators more interchangable.
1362     assert ' ' not in res, (
1363       "Spaces in resource filenames not supported (%s)"  % res)
1364
1365     # Split into (path,file).
1366     res_parts = os.path.split(res)
1367
1368     # Now split the path into (prefix,maybe.lproj).
1369     lproj_parts = os.path.split(res_parts[0])
1370     # If the resource lives in a .lproj bundle, add that to the destination.
1371     if lproj_parts[1].endswith('.lproj'):
1372       output = os.path.join(output, lproj_parts[1])
1373
1374     output = os.path.join(output, res_parts[1])
1375     # Compiled XIB files are referred to by .nib.
1376     if output.endswith('.xib'):
1377       output = os.path.splitext(output)[0] + '.nib'
1378     # Compiled storyboard files are referred to by .storyboardc.
1379     if output.endswith('.storyboard'):
1380       output = os.path.splitext(output)[0] + '.storyboardc'
1381
1382     yield output, res
1383
1384
1385 def GetMacInfoPlist(product_dir, xcode_settings, gyp_path_to_build_path):
1386   """Returns (info_plist, dest_plist, defines, extra_env), where:
1387   * |info_plist| is the source plist path, relative to the
1388     build directory,
1389   * |dest_plist| is the destination plist path, relative to the
1390     build directory,
1391   * |defines| is a list of preprocessor defines (empty if the plist
1392     shouldn't be preprocessed,
1393   * |extra_env| is a dict of env variables that should be exported when
1394     invoking |mac_tool copy-info-plist|.
1395
1396   Only call this for mac bundle targets.
1397
1398   Args:
1399       product_dir: Path to the directory containing the output bundle,
1400           relative to the build directory.
1401       xcode_settings: The XcodeSettings of the current target.
1402       gyp_to_build_path: A function that converts paths relative to the
1403           current gyp file to paths relative to the build direcotry.
1404   """
1405   info_plist = xcode_settings.GetPerTargetSetting('INFOPLIST_FILE')
1406   if not info_plist:
1407     return None, None, [], {}
1408
1409   # The make generator doesn't support it, so forbid it everywhere
1410   # to keep the generators more interchangable.
1411   assert ' ' not in info_plist, (
1412     "Spaces in Info.plist filenames not supported (%s)"  % info_plist)
1413
1414   info_plist = gyp_path_to_build_path(info_plist)
1415
1416   # If explicitly set to preprocess the plist, invoke the C preprocessor and
1417   # specify any defines as -D flags.
1418   if xcode_settings.GetPerTargetSetting(
1419       'INFOPLIST_PREPROCESS', default='NO') == 'YES':
1420     # Create an intermediate file based on the path.
1421     defines = shlex.split(xcode_settings.GetPerTargetSetting(
1422         'INFOPLIST_PREPROCESSOR_DEFINITIONS', default=''))
1423   else:
1424     defines = []
1425
1426   dest_plist = os.path.join(product_dir, xcode_settings.GetBundlePlistPath())
1427   extra_env = xcode_settings.GetPerTargetSettings()
1428
1429   return info_plist, dest_plist, defines, extra_env
1430
1431
1432 def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
1433                 additional_settings=None):
1434   """Return the environment variables that Xcode would set. See
1435   http://developer.apple.com/library/mac/#documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW153
1436   for a full list.
1437
1438   Args:
1439       xcode_settings: An XcodeSettings object. If this is None, this function
1440           returns an empty dict.
1441       built_products_dir: Absolute path to the built products dir.
1442       srcroot: Absolute path to the source root.
1443       configuration: The build configuration name.
1444       additional_settings: An optional dict with more values to add to the
1445           result.
1446   """
1447   if not xcode_settings: return {}
1448
1449   # This function is considered a friend of XcodeSettings, so let it reach into
1450   # its implementation details.
1451   spec = xcode_settings.spec
1452
1453   # These are filled in on a as-needed basis.
1454   env = {
1455     'BUILT_FRAMEWORKS_DIR' : built_products_dir,
1456     'BUILT_PRODUCTS_DIR' : built_products_dir,
1457     'CONFIGURATION' : configuration,
1458     'PRODUCT_NAME' : xcode_settings.GetProductName(),
1459     # See /Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Specifications/MacOSX\ Product\ Types.xcspec for FULL_PRODUCT_NAME
1460     'SRCROOT' : srcroot,
1461     'SOURCE_ROOT': '${SRCROOT}',
1462     # This is not true for static libraries, but currently the env is only
1463     # written for bundles:
1464     'TARGET_BUILD_DIR' : built_products_dir,
1465     'TEMP_DIR' : '${TMPDIR}',
1466   }
1467   if xcode_settings.GetPerConfigSetting('SDKROOT', configuration):
1468     env['SDKROOT'] = xcode_settings._SdkPath(configuration)
1469   else:
1470     env['SDKROOT'] = ''
1471
1472   if spec['type'] in (
1473       'executable', 'static_library', 'shared_library', 'loadable_module'):
1474     env['EXECUTABLE_NAME'] = xcode_settings.GetExecutableName()
1475     env['EXECUTABLE_PATH'] = xcode_settings.GetExecutablePath()
1476     env['FULL_PRODUCT_NAME'] = xcode_settings.GetFullProductName()
1477     mach_o_type = xcode_settings.GetMachOType()
1478     if mach_o_type:
1479       env['MACH_O_TYPE'] = mach_o_type
1480     env['PRODUCT_TYPE'] = xcode_settings.GetProductType()
1481   if xcode_settings._IsBundle():
1482     env['CONTENTS_FOLDER_PATH'] = \
1483       xcode_settings.GetBundleContentsFolderPath()
1484     env['UNLOCALIZED_RESOURCES_FOLDER_PATH'] = \
1485         xcode_settings.GetBundleResourceFolder()
1486     env['INFOPLIST_PATH'] = xcode_settings.GetBundlePlistPath()
1487     env['WRAPPER_NAME'] = xcode_settings.GetWrapperName()
1488
1489   install_name = xcode_settings.GetInstallName()
1490   if install_name:
1491     env['LD_DYLIB_INSTALL_NAME'] = install_name
1492   install_name_base = xcode_settings.GetInstallNameBase()
1493   if install_name_base:
1494     env['DYLIB_INSTALL_NAME_BASE'] = install_name_base
1495   if XcodeVersion() >= '0500' and not env.get('SDKROOT'):
1496     sdk_root = xcode_settings._SdkRoot(configuration)
1497     if not sdk_root:
1498       sdk_root = xcode_settings._XcodeSdkPath('')
1499     if sdk_root is None:
1500       sdk_root = ''
1501     env['SDKROOT'] = sdk_root
1502
1503   if not additional_settings:
1504     additional_settings = {}
1505   else:
1506     # Flatten lists to strings.
1507     for k in additional_settings:
1508       if not isinstance(additional_settings[k], str):
1509         additional_settings[k] = ' '.join(additional_settings[k])
1510   additional_settings.update(env)
1511
1512   for k in additional_settings:
1513     additional_settings[k] = _NormalizeEnvVarReferences(additional_settings[k])
1514
1515   return additional_settings
1516
1517
1518 def _NormalizeEnvVarReferences(str):
1519   """Takes a string containing variable references in the form ${FOO}, $(FOO),
1520   or $FOO, and returns a string with all variable references in the form ${FOO}.
1521   """
1522   # $FOO -> ${FOO}
1523   str = re.sub(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', r'${\1}', str)
1524
1525   # $(FOO) -> ${FOO}
1526   matches = re.findall(r'(\$\(([a-zA-Z0-9\-_]+)\))', str)
1527   for match in matches:
1528     to_replace, variable = match
1529     assert '$(' not in match, '$($(FOO)) variables not supported: ' + match
1530     str = str.replace(to_replace, '${' + variable + '}')
1531
1532   return str
1533
1534
1535 def ExpandEnvVars(string, expansions):
1536   """Expands ${VARIABLES}, $(VARIABLES), and $VARIABLES in string per the
1537   expansions list. If the variable expands to something that references
1538   another variable, this variable is expanded as well if it's in env --
1539   until no variables present in env are left."""
1540   for k, v in reversed(expansions):
1541     string = string.replace('${' + k + '}', v)
1542     string = string.replace('$(' + k + ')', v)
1543     string = string.replace('$' + k, v)
1544   return string
1545
1546
1547 def _TopologicallySortedEnvVarKeys(env):
1548   """Takes a dict |env| whose values are strings that can refer to other keys,
1549   for example env['foo'] = '$(bar) and $(baz)'. Returns a list L of all keys of
1550   env such that key2 is after key1 in L if env[key2] refers to env[key1].
1551
1552   Throws an Exception in case of dependency cycles.
1553   """
1554   # Since environment variables can refer to other variables, the evaluation
1555   # order is important. Below is the logic to compute the dependency graph
1556   # and sort it.
1557   regex = re.compile(r'\$\{([a-zA-Z0-9\-_]+)\}')
1558   def GetEdges(node):
1559     # Use a definition of edges such that user_of_variable -> used_varible.
1560     # This happens to be easier in this case, since a variable's
1561     # definition contains all variables it references in a single string.
1562     # We can then reverse the result of the topological sort at the end.
1563     # Since: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
1564     matches = set([v for v in regex.findall(env[node]) if v in env])
1565     for dependee in matches:
1566       assert '${' not in dependee, 'Nested variables not supported: ' + dependee
1567     return matches
1568
1569   try:
1570     # Topologically sort, and then reverse, because we used an edge definition
1571     # that's inverted from the expected result of this function (see comment
1572     # above).
1573     order = gyp.common.TopologicallySorted(env.keys(), GetEdges)
1574     order.reverse()
1575     return order
1576   except gyp.common.CycleError, e:
1577     raise GypError(
1578         'Xcode environment variables are cyclically dependent: ' + str(e.nodes))
1579
1580
1581 def GetSortedXcodeEnv(xcode_settings, built_products_dir, srcroot,
1582                       configuration, additional_settings=None):
1583   env = _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
1584                     additional_settings)
1585   return [(key, env[key]) for key in _TopologicallySortedEnvVarKeys(env)]
1586
1587
1588 def GetSpecPostbuildCommands(spec, quiet=False):
1589   """Returns the list of postbuilds explicitly defined on |spec|, in a form
1590   executable by a shell."""
1591   postbuilds = []
1592   for postbuild in spec.get('postbuilds', []):
1593     if not quiet:
1594       postbuilds.append('echo POSTBUILD\\(%s\\) %s' % (
1595             spec['target_name'], postbuild['postbuild_name']))
1596     postbuilds.append(gyp.common.EncodePOSIXShellList(postbuild['action']))
1597   return postbuilds
1598
1599
1600 def _HasIOSTarget(targets):
1601   """Returns true if any target contains the iOS specific key
1602   IPHONEOS_DEPLOYMENT_TARGET."""
1603   for target_dict in targets.values():
1604     for config in target_dict['configurations'].values():
1605       if config.get('xcode_settings', {}).get('IPHONEOS_DEPLOYMENT_TARGET'):
1606         return True
1607   return False
1608
1609
1610 def _AddIOSDeviceConfigurations(targets):
1611   """Clone all targets and append -iphoneos to the name. Configure these targets
1612   to build for iOS devices and use correct architectures for those builds."""
1613   for target_dict in targets.itervalues():
1614     toolset = target_dict['toolset']
1615     configs = target_dict['configurations']
1616     for config_name, config_dict in dict(configs).iteritems():
1617       iphoneos_config_dict = copy.deepcopy(config_dict)
1618       configs[config_name + '-iphoneos'] = iphoneos_config_dict
1619       configs[config_name + '-iphonesimulator'] = config_dict
1620       if toolset == 'target':
1621         iphoneos_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
1622   return targets
1623
1624 def CloneConfigurationForDeviceAndEmulator(target_dicts):
1625   """If |target_dicts| contains any iOS targets, automatically create -iphoneos
1626   targets for iOS device builds."""
1627   if _HasIOSTarget(target_dicts):
1628     return _AddIOSDeviceConfigurations(target_dicts)
1629   return target_dicts