AppPkg/Applications/Python/Python-2.7.2/Lib/sysconfig.py

   1 """Provide access to Python's configuration information.
   2
   3 """
   4 import sys
   5 import os
   6 from os.path import pardir, realpath
   7
   8 _INSTALL_SCHEMES = {
   9     'posix_prefix': {
  10         'stdlib': '{base}/lib/python{py_version_short}',
  11         'platstdlib': '{platbase}/lib/python{py_version_short}',
  12         'purelib': '{base}/lib/python{py_version_short}/site-packages',
  13         'platlib': '{platbase}/lib/python{py_version_short}/site-packages',
  14         'include': '{base}/include/python{py_version_short}',
  15         'platinclude': '{platbase}/include/python{py_version_short}',
  16         'scripts': '{base}/bin',
  17         'data': '{base}',
  18         },
  19     'posix_home': {
  20         'stdlib': '{base}/lib/python',
  21         'platstdlib': '{base}/lib/python',
  22         'purelib': '{base}/lib/python',
  23         'platlib': '{base}/lib/python',
  24         'include': '{base}/include/python',
  25         'platinclude': '{base}/include/python',
  26         'scripts': '{base}/bin',
  27         'data'   : '{base}',
  28         },
  29     'nt': {
  30         'stdlib': '{base}/Lib',
  31         'platstdlib': '{base}/Lib',
  32         'purelib': '{base}/Lib/site-packages',
  33         'platlib': '{base}/Lib/site-packages',
  34         'include': '{base}/Include',
  35         'platinclude': '{base}/Include',
  36         'scripts': '{base}/Scripts',
  37         'data'   : '{base}',
  38         },
  39     'os2': {
  40         'stdlib': '{base}/Lib',
  41         'platstdlib': '{base}/Lib',
  42         'purelib': '{base}/Lib/site-packages',
  43         'platlib': '{base}/Lib/site-packages',
  44         'include': '{base}/Include',
  45         'platinclude': '{base}/Include',
  46         'scripts': '{base}/Scripts',
  47         'data'   : '{base}',
  48         },
  49     'os2_home': {
  50         'stdlib': '{userbase}/lib/python{py_version_short}',
  51         'platstdlib': '{userbase}/lib/python{py_version_short}',
  52         'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
  53         'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
  54         'include': '{userbase}/include/python{py_version_short}',
  55         'scripts': '{userbase}/bin',
  56         'data'   : '{userbase}',
  57         },
  58     'nt_user': {
  59         'stdlib': '{userbase}/Python{py_version_nodot}',
  60         'platstdlib': '{userbase}/Python{py_version_nodot}',
  61         'purelib': '{userbase}/Python{py_version_nodot}/site-packages',
  62         'platlib': '{userbase}/Python{py_version_nodot}/site-packages',
  63         'include': '{userbase}/Python{py_version_nodot}/Include',
  64         'scripts': '{userbase}/Scripts',
  65         'data'   : '{userbase}',
  66         },
  67     'posix_user': {
  68         'stdlib': '{userbase}/lib/python{py_version_short}',
  69         'platstdlib': '{userbase}/lib/python{py_version_short}',
  70         'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
  71         'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
  72         'include': '{userbase}/include/python{py_version_short}',
  73         'scripts': '{userbase}/bin',
  74         'data'   : '{userbase}',
  75         },
  76     'osx_framework_user': {
  77         'stdlib': '{userbase}/lib/python',
  78         'platstdlib': '{userbase}/lib/python',
  79         'purelib': '{userbase}/lib/python/site-packages',
  80         'platlib': '{userbase}/lib/python/site-packages',
  81         'include': '{userbase}/include',
  82         'scripts': '{userbase}/bin',
  83         'data'   : '{userbase}',
  84         },
  85     }
  86
  87 _SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include',
  88                 'scripts', 'data')
  89 _PY_VERSION = sys.version.split()[0]
  90 _PY_VERSION_SHORT = sys.version[:3]
  91 _PY_VERSION_SHORT_NO_DOT = _PY_VERSION[0] + _PY_VERSION[2]
  92 _PREFIX = os.path.normpath(sys.prefix)
  93 _EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
  94 _CONFIG_VARS = None
  95 _USER_BASE = None
  96
  97 def _safe_realpath(path):
  98     try:
  99         return realpath(path)
 100     except OSError:
 101         return path
 102
 103 if sys.executable:
 104     _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
 105 else:
 106     # sys.executable can be empty if argv[0] has been changed and Python is
 107     # unable to retrieve the real program name
 108     _PROJECT_BASE = _safe_realpath(os.getcwd())
 109
 110 if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower():
 111     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
 112 # PC/VS7.1
 113 if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
 114     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
 115 # PC/AMD64
 116 if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
 117     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
 118
 119 def is_python_build():
 120     for fn in ("Setup.dist", "Setup.local"):
 121         if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
 122             return True
 123     return False
 124
 125 _PYTHON_BUILD = is_python_build()
 126
 127 if _PYTHON_BUILD:
 128     for scheme in ('posix_prefix', 'posix_home'):
 129         _INSTALL_SCHEMES[scheme]['include'] = '{projectbase}/Include'
 130         _INSTALL_SCHEMES[scheme]['platinclude'] = '{srcdir}'
 131
 132 def _subst_vars(s, local_vars):
 133     try:
 134         return s.format(**local_vars)
 135     except KeyError:
 136         try:
 137             return s.format(**os.environ)
 138         except KeyError, var:
 139             raise AttributeError('{%s}' % var)
 140
 141 def _extend_dict(target_dict, other_dict):
 142     target_keys = target_dict.keys()
 143     for key, value in other_dict.items():
 144         if key in target_keys:
 145             continue
 146         target_dict[key] = value
 147
 148 def _expand_vars(scheme, vars):
 149     res = {}
 150     if vars is None:
 151         vars = {}
 152     _extend_dict(vars, get_config_vars())
 153
 154     for key, value in _INSTALL_SCHEMES[scheme].items():
 155         if os.name in ('posix', 'nt'):
 156             value = os.path.expanduser(value)
 157         res[key] = os.path.normpath(_subst_vars(value, vars))
 158     return res
 159
 160 def _get_default_scheme():
 161     if os.name == 'posix':
 162         # the default scheme for posix is posix_prefix
 163         return 'posix_prefix'
 164     return os.name
 165
 166 def _getuserbase():
 167     env_base = os.environ.get("PYTHONUSERBASE", None)
 168     def joinuser(*args):
 169         return os.path.expanduser(os.path.join(*args))
 170
 171     # what about 'os2emx', 'riscos' ?
 172     if os.name == "nt":
 173         base = os.environ.get("APPDATA") or "~"
 174         return env_base if env_base else joinuser(base, "Python")
 175
 176     if sys.platform == "darwin":
 177         framework = get_config_var("PYTHONFRAMEWORK")
 178         if framework:
 179             return joinuser("~", "Library", framework, "%d.%d"%(
 180                 sys.version_info[:2]))
 181
 182     return env_base if env_base else joinuser("~", ".local")
 183
 184
 185 def _parse_makefile(filename, vars=None):
 186     """Parse a Makefile-style file.
 187
 188     A dictionary containing name/value pairs is returned.  If an
 189     optional dictionary is passed in as the second argument, it is
 190     used instead of a new dictionary.
 191     """
 192     import re
 193     # Regexes needed for parsing Makefile (and similar syntaxes,
 194     # like old-style Setup files).
 195     _variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
 196     _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
 197     _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
 198
 199     if vars is None:
 200         vars = {}
 201     done = {}
 202     notdone = {}
 203
 204     with open(filename) as f:
 205         lines = f.readlines()
 206
 207     for line in lines:
 208         if line.startswith('#') or line.strip() == '':
 209             continue
 210         m = _variable_rx.match(line)
 211         if m:
 212             n, v = m.group(1, 2)
 213             v = v.strip()
 214             # `$$' is a literal `$' in make
 215             tmpv = v.replace('$$', '')
 216
 217             if "$" in tmpv:
 218                 notdone[n] = v
 219             else:
 220                 try:
 221                     v = int(v)
 222                 except ValueError:
 223                     # insert literal `$'
 224                     done[n] = v.replace('$$', '$')
 225                 else:
 226                     done[n] = v
 227
 228     # do variable interpolation here
 229     while notdone:
 230         for name in notdone.keys():
 231             value = notdone[name]
 232             m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
 233             if m:
 234                 n = m.group(1)
 235                 found = True
 236                 if n in done:
 237                     item = str(done[n])
 238                 elif n in notdone:
 239                     # get it on a subsequent round
 240                     found = False
 241                 elif n in os.environ:
 242                     # do it like make: fall back to environment
 243                     item = os.environ[n]
 244                 else:
 245                     done[n] = item = ""
 246                 if found:
 247                     after = value[m.end():]
 248                     value = value[:m.start()] + item + after
 249                     if "$" in after:
 250                         notdone[name] = value
 251                     else:
 252                         try: value = int(value)
 253                         except ValueError:
 254                             done[name] = value.strip()
 255                         else:
 256                             done[name] = value
 257                         del notdone[name]
 258             else:
 259                 # bogus variable reference; just drop it since we can't deal
 260                 del notdone[name]
 261     # strip spurious spaces
 262     for k, v in done.items():
 263         if isinstance(v, str):
 264             done[k] = v.strip()
 265
 266     # save the results in the global dictionary
 267     vars.update(done)
 268     return vars
 269
 270
 271 def _get_makefile_filename():
 272     if _PYTHON_BUILD:
 273         return os.path.join(_PROJECT_BASE, "Makefile")
 274     return os.path.join(get_path('platstdlib'), "config", "Makefile")
 275
 276
 277 def _init_posix(vars):
 278     """Initialize the module as appropriate for POSIX systems."""
 279     # load the installed Makefile:
 280     makefile = _get_makefile_filename()
 281     try:
 282         _parse_makefile(makefile, vars)
 283     except IOError, e:
 284         msg = "invalid Python installation: unable to open %s" % makefile
 285         if hasattr(e, "strerror"):
 286             msg = msg + " (%s)" % e.strerror
 287         raise IOError(msg)
 288
 289     # load the installed pyconfig.h:
 290     config_h = get_config_h_filename()
 291     try:
 292         with open(config_h) as f:
 293             parse_config_h(f, vars)
 294     except IOError, e:
 295         msg = "invalid Python installation: unable to open %s" % config_h
 296         if hasattr(e, "strerror"):
 297             msg = msg + " (%s)" % e.strerror
 298         raise IOError(msg)
 299
 300     # On AIX, there are wrong paths to the linker scripts in the Makefile
 301     # -- these paths are relative to the Python source, but when installed
 302     # the scripts are in another directory.
 303     if _PYTHON_BUILD:
 304         vars['LDSHARED'] = vars['BLDSHARED']
 305
 306 def _init_non_posix(vars):
 307     """Initialize the module as appropriate for NT"""
 308     # set basic install directories
 309     vars['LIBDEST'] = get_path('stdlib')
 310     vars['BINLIBDEST'] = get_path('platstdlib')
 311     vars['INCLUDEPY'] = get_path('include')
 312     vars['SO'] = '.pyd'
 313     vars['EXE'] = '.exe'
 314     vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
 315     vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
 316
 317 #
 318 # public APIs
 319 #
 320
 321
 322 def parse_config_h(fp, vars=None):
 323     """Parse a config.h-style file.
 324
 325     A dictionary containing name/value pairs is returned.  If an
 326     optional dictionary is passed in as the second argument, it is
 327     used instead of a new dictionary.
 328     """
 329     import re
 330     if vars is None:
 331         vars = {}
 332     define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
 333     undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
 334
 335     while True:
 336         line = fp.readline()
 337         if not line:
 338             break
 339         m = define_rx.match(line)
 340         if m:
 341             n, v = m.group(1, 2)
 342             try: v = int(v)
 343             except ValueError: pass
 344             vars[n] = v
 345         else:
 346             m = undef_rx.match(line)
 347             if m:
 348                 vars[m.group(1)] = 0
 349     return vars
 350
 351 def get_config_h_filename():
 352     """Returns the path of pyconfig.h."""
 353     if _PYTHON_BUILD:
 354         if os.name == "nt":
 355             inc_dir = os.path.join(_PROJECT_BASE, "PC")
 356         else:
 357             inc_dir = _PROJECT_BASE
 358     else:
 359         inc_dir = get_path('platinclude')
 360     return os.path.join(inc_dir, 'pyconfig.h')
 361
 362 def get_scheme_names():
 363     """Returns a tuple containing the schemes names."""
 364     schemes = _INSTALL_SCHEMES.keys()
 365     schemes.sort()
 366     return tuple(schemes)
 367
 368 def get_path_names():
 369     """Returns a tuple containing the paths names."""
 370     return _SCHEME_KEYS
 371
 372 def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
 373     """Returns a mapping containing an install scheme.
 374
 375     ``scheme`` is the install scheme name. If not provided, it will
 376     return the default scheme for the current platform.
 377     """
 378     if expand:
 379         return _expand_vars(scheme, vars)
 380     else:
 381         return _INSTALL_SCHEMES[scheme]
 382
 383 def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
 384     """Returns a path corresponding to the scheme.
 385
 386     ``scheme`` is the install scheme name.
 387     """
 388     return get_paths(scheme, vars, expand)[name]
 389
 390 def get_config_vars(*args):
 391     """With no arguments, return a dictionary of all configuration
 392     variables relevant for the current platform.
 393
 394     On Unix, this means every variable defined in Python's installed Makefile;
 395     On Windows and Mac OS it's a much smaller set.
 396
 397     With arguments, return a list of values that result from looking up
 398     each argument in the configuration variable dictionary.
 399     """
 400     import re
 401     global _CONFIG_VARS
 402     if _CONFIG_VARS is None:
 403         _CONFIG_VARS = {}
 404         # Normalized versions of prefix and exec_prefix are handy to have;
 405         # in fact, these are the standard versions used most places in the
 406         # Distutils.
 407         _CONFIG_VARS['prefix'] = _PREFIX
 408         _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
 409         _CONFIG_VARS['py_version'] = _PY_VERSION
 410         _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
 411         _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
 412         _CONFIG_VARS['base'] = _PREFIX
 413         _CONFIG_VARS['platbase'] = _EXEC_PREFIX
 414         _CONFIG_VARS['projectbase'] = _PROJECT_BASE
 415
 416         if os.name in ('nt', 'os2'):
 417             _init_non_posix(_CONFIG_VARS)
 418         if os.name == 'posix':
 419             _init_posix(_CONFIG_VARS)
 420
 421         # Setting 'userbase' is done below the call to the
 422         # init function to enable using 'get_config_var' in
 423         # the init-function.
 424         _CONFIG_VARS['userbase'] = _getuserbase()
 425
 426         if 'srcdir' not in _CONFIG_VARS:
 427             _CONFIG_VARS['srcdir'] = _PROJECT_BASE
 428
 429         # Convert srcdir into an absolute path if it appears necessary.
 430         # Normally it is relative to the build directory.  However, during
 431         # testing, for example, we might be running a non-installed python
 432         # from a different directory.
 433         if _PYTHON_BUILD and os.name == "posix":
 434             base = _PROJECT_BASE
 435             try:
 436                 cwd = os.getcwd()
 437             except OSError:
 438                 cwd = None
 439             if (not os.path.isabs(_CONFIG_VARS['srcdir']) and
 440                 base != cwd):
 441                 # srcdir is relative and we are not in the same directory
 442                 # as the executable. Assume executable is in the build
 443                 # directory and make srcdir absolute.
 444                 srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
 445                 _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)
 446
 447         if sys.platform == 'darwin':
 448             kernel_version = os.uname()[2] # Kernel version (8.4.3)
 449             major_version = int(kernel_version.split('.')[0])
 450
 451             if major_version < 8:
 452                 # On Mac OS X before 10.4, check if -arch and -isysroot
 453                 # are in CFLAGS or LDFLAGS and remove them if they are.
 454                 # This is needed when building extensions on a 10.3 system
 455                 # using a universal build of python.
 456                 for key in ('LDFLAGS', 'BASECFLAGS',
 457                         # a number of derived variables. These need to be
 458                         # patched up as well.
 459                         'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
 460                     flags = _CONFIG_VARS[key]
 461                     flags = re.sub('-arch\s+\w+\s', ' ', flags)
 462                     flags = re.sub('-isysroot [^ \t]*', ' ', flags)
 463                     _CONFIG_VARS[key] = flags
 464             else:
 465                 # Allow the user to override the architecture flags using
 466                 # an environment variable.
 467                 # NOTE: This name was introduced by Apple in OSX 10.5 and
 468                 # is used by several scripting languages distributed with
 469                 # that OS release.
 470                 if 'ARCHFLAGS' in os.environ:
 471                     arch = os.environ['ARCHFLAGS']
 472                     for key in ('LDFLAGS', 'BASECFLAGS',
 473                         # a number of derived variables. These need to be
 474                         # patched up as well.
 475                         'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
 476
 477                         flags = _CONFIG_VARS[key]
 478                         flags = re.sub('-arch\s+\w+\s', ' ', flags)
 479                         flags = flags + ' ' + arch
 480                         _CONFIG_VARS[key] = flags
 481
 482                 # If we're on OSX 10.5 or later and the user tries to
 483                 # compiles an extension using an SDK that is not present
 484                 # on the current machine it is better to not use an SDK
 485                 # than to fail.
 486                 #
 487                 # The major usecase for this is users using a Python.org
 488                 # binary installer  on OSX 10.6: that installer uses
 489                 # the 10.4u SDK, but that SDK is not installed by default
 490                 # when you install Xcode.
 491                 #
 492                 CFLAGS = _CONFIG_VARS.get('CFLAGS', '')
 493                 m = re.search('-isysroot\s+(\S+)', CFLAGS)
 494                 if m is not None:
 495                     sdk = m.group(1)
 496                     if not os.path.exists(sdk):
 497                         for key in ('LDFLAGS', 'BASECFLAGS',
 498                              # a number of derived variables. These need to be
 499                              # patched up as well.
 500                             'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
 501
 502                             flags = _CONFIG_VARS[key]
 503                             flags = re.sub('-isysroot\s+\S+(\s|$)', ' ', flags)
 504                             _CONFIG_VARS[key] = flags
 505
 506     if args:
 507         vals = []
 508         for name in args:
 509             vals.append(_CONFIG_VARS.get(name))
 510         return vals
 511     else:
 512         return _CONFIG_VARS
 513
 514 def get_config_var(name):
 515     """Return the value of a single variable using the dictionary returned by
 516     'get_config_vars()'.
 517
 518     Equivalent to get_config_vars().get(name)
 519     """
 520     return get_config_vars().get(name)
 521
 522 def get_platform():
 523     """Return a string that identifies the current platform.
 524
 525     This is used mainly to distinguish platform-specific build directories and
 526     platform-specific built distributions.  Typically includes the OS name
 527     and version and the architecture (as supplied by 'os.uname()'),
 528     although the exact information included depends on the OS; eg. for IRIX
 529     the architecture isn't particularly important (IRIX only runs on SGI
 530     hardware), but for Linux the kernel version isn't particularly
 531     important.
 532
 533     Examples of returned values:
 534        linux-i586
 535        linux-alpha (?)
 536        solaris-2.6-sun4u
 537        irix-5.3
 538        irix64-6.2
 539
 540     Windows will return one of:
 541        win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
 542        win-ia64 (64bit Windows on Itanium)
 543        win32 (all others - specifically, sys.platform is returned)
 544
 545     For other non-POSIX platforms, currently just returns 'sys.platform'.
 546     """
 547     import re
 548     if os.name == 'nt':
 549         # sniff sys.version for architecture.
 550         prefix = " bit ("
 551         i = sys.version.find(prefix)
 552         if i == -1:
 553             return sys.platform
 554         j = sys.version.find(")", i)
 555         look = sys.version[i+len(prefix):j].lower()
 556         if look == 'amd64':
 557             return 'win-amd64'
 558         if look == 'itanium':
 559             return 'win-ia64'
 560         return sys.platform
 561
 562     if os.name != "posix" or not hasattr(os, 'uname'):
 563         # XXX what about the architecture? NT is Intel or Alpha,
 564         # Mac OS is M68k or PPC, etc.
 565         return sys.platform
 566
 567     # Try to distinguish various flavours of Unix
 568     osname, host, release, version, machine = os.uname()
 569
 570     # Convert the OS name to lowercase, remove '/' characters
 571     # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
 572     osname = osname.lower().replace('/', '')
 573     machine = machine.replace(' ', '_')
 574     machine = machine.replace('/', '-')
 575
 576     if osname[:5] == "linux":
 577         # At least on Linux/Intel, 'machine' is the processor --
 578         # i386, etc.
 579         # XXX what about Alpha, SPARC, etc?
 580         return  "%s-%s" % (osname, machine)
 581     elif osname[:5] == "sunos":
 582         if release[0] >= "5":           # SunOS 5 == Solaris 2
 583             osname = "solaris"
 584             release = "%d.%s" % (int(release[0]) - 3, release[2:])
 585         # fall through to standard osname-release-machine representation
 586     elif osname[:4] == "irix":              # could be "irix64"!
 587         return "%s-%s" % (osname, release)
 588     elif osname[:3] == "aix":
 589         return "%s-%s.%s" % (osname, version, release)
 590     elif osname[:6] == "cygwin":
 591         osname = "cygwin"
 592         rel_re = re.compile (r'[\d.]+')
 593         m = rel_re.match(release)
 594         if m:
 595             release = m.group()
 596     elif osname[:6] == "darwin":
 597         #
 598         # For our purposes, we'll assume that the system version from
 599         # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
 600         # to. This makes the compatibility story a bit more sane because the
 601         # machine is going to compile and link as if it were
 602         # MACOSX_DEPLOYMENT_TARGET.
 603         cfgvars = get_config_vars()
 604         macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
 605
 606         if 1:
 607             # Always calculate the release of the running machine,
 608             # needed to determine if we can build fat binaries or not.
 609
 610             macrelease = macver
 611             # Get the system version. Reading this plist is a documented
 612             # way to get the system version (see the documentation for
 613             # the Gestalt Manager)
 614             try:
 615                 f = open('/System/Library/CoreServices/SystemVersion.plist')
 616             except IOError:
 617                 # We're on a plain darwin box, fall back to the default
 618                 # behaviour.
 619                 pass
 620             else:
 621                 try:
 622                     m = re.search(
 623                             r'<key>ProductUserVisibleVersion</key>\s*' +
 624                             r'<string>(.*?)</string>', f.read())
 625                     if m is not None:
 626                         macrelease = '.'.join(m.group(1).split('.')[:2])
 627                     # else: fall back to the default behaviour
 628                 finally:
 629                     f.close()
 630
 631         if not macver:
 632             macver = macrelease
 633
 634         if macver:
 635             release = macver
 636             osname = "macosx"
 637
 638             if (macrelease + '.') >= '10.4.' and \
 639                     '-arch' in get_config_vars().get('CFLAGS', '').strip():
 640                 # The universal build will build fat binaries, but not on
 641                 # systems before 10.4
 642                 #
 643                 # Try to detect 4-way universal builds, those have machine-type
 644                 # 'universal' instead of 'fat'.
 645
 646                 machine = 'fat'
 647                 cflags = get_config_vars().get('CFLAGS')
 648
 649                 archs = re.findall('-arch\s+(\S+)', cflags)
 650                 archs = tuple(sorted(set(archs)))
 651
 652                 if len(archs) == 1:
 653                     machine = archs[0]
 654                 elif archs == ('i386', 'ppc'):
 655                     machine = 'fat'
 656                 elif archs == ('i386', 'x86_64'):
 657                     machine = 'intel'
 658                 elif archs == ('i386', 'ppc', 'x86_64'):
 659                     machine = 'fat3'
 660                 elif archs == ('ppc64', 'x86_64'):
 661                     machine = 'fat64'
 662                 elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
 663                     machine = 'universal'
 664                 else:
 665                     raise ValueError(
 666                        "Don't know machine value for archs=%r"%(archs,))
 667
 668             elif machine == 'i386':
 669                 # On OSX the machine type returned by uname is always the
 670                 # 32-bit variant, even if the executable architecture is
 671                 # the 64-bit variant
 672                 if sys.maxint >= 2**32:
 673                     machine = 'x86_64'
 674
 675             elif machine in ('PowerPC', 'Power_Macintosh'):
 676                 # Pick a sane name for the PPC architecture.
 677                 # See 'i386' case
 678                 if sys.maxint >= 2**32:
 679                     machine = 'ppc64'
 680                 else:
 681                     machine = 'ppc'
 682
 683     return "%s-%s-%s" % (osname, release, machine)
 684
 685
 686 def get_python_version():
 687     return _PY_VERSION_SHORT