| """Provide access to Python's configuration information. | |
| """ | |
| import sys | |
| import os | |
| from os.path import pardir, realpath | |
| _INSTALL_SCHEMES = { | |
| 'posix_prefix': { | |
| 'stdlib': '{base}/lib/python{py_version_short}', | |
| 'platstdlib': '{platbase}/lib/python{py_version_short}', | |
| 'purelib': '{base}/lib/python{py_version_short}/site-packages', | |
| 'platlib': '{platbase}/lib/python{py_version_short}/site-packages', | |
| 'include': '{base}/include/python{py_version_short}', | |
| 'platinclude': '{platbase}/include/python{py_version_short}', | |
| 'scripts': '{base}/bin', | |
| 'data': '{base}', | |
| }, | |
| 'posix_home': { | |
| 'stdlib': '{base}/lib/python', | |
| 'platstdlib': '{base}/lib/python', | |
| 'purelib': '{base}/lib/python', | |
| 'platlib': '{base}/lib/python', | |
| 'include': '{base}/include/python', | |
| 'platinclude': '{base}/include/python', | |
| 'scripts': '{base}/bin', | |
| 'data' : '{base}', | |
| }, | |
| 'nt': { | |
| 'stdlib': '{base}/Lib', | |
| 'platstdlib': '{base}/Lib', | |
| 'purelib': '{base}/Lib/site-packages', | |
| 'platlib': '{base}/Lib/site-packages', | |
| 'include': '{base}/Include', | |
| 'platinclude': '{base}/Include', | |
| 'scripts': '{base}/Scripts', | |
| 'data' : '{base}', | |
| }, | |
| 'os2': { | |
| 'stdlib': '{base}/Lib', | |
| 'platstdlib': '{base}/Lib', | |
| 'purelib': '{base}/Lib/site-packages', | |
| 'platlib': '{base}/Lib/site-packages', | |
| 'include': '{base}/Include', | |
| 'platinclude': '{base}/Include', | |
| 'scripts': '{base}/Scripts', | |
| 'data' : '{base}', | |
| }, | |
| 'os2_home': { | |
| 'stdlib': '{userbase}/lib/python{py_version_short}', | |
| 'platstdlib': '{userbase}/lib/python{py_version_short}', | |
| 'purelib': '{userbase}/lib/python{py_version_short}/site-packages', | |
| 'platlib': '{userbase}/lib/python{py_version_short}/site-packages', | |
| 'include': '{userbase}/include/python{py_version_short}', | |
| 'scripts': '{userbase}/bin', | |
| 'data' : '{userbase}', | |
| }, | |
| 'nt_user': { | |
| 'stdlib': '{userbase}/Python{py_version_nodot}', | |
| 'platstdlib': '{userbase}/Python{py_version_nodot}', | |
| 'purelib': '{userbase}/Python{py_version_nodot}/site-packages', | |
| 'platlib': '{userbase}/Python{py_version_nodot}/site-packages', | |
| 'include': '{userbase}/Python{py_version_nodot}/Include', | |
| 'scripts': '{userbase}/Scripts', | |
| 'data' : '{userbase}', | |
| }, | |
| 'posix_user': { | |
| 'stdlib': '{userbase}/lib/python{py_version_short}', | |
| 'platstdlib': '{userbase}/lib/python{py_version_short}', | |
| 'purelib': '{userbase}/lib/python{py_version_short}/site-packages', | |
| 'platlib': '{userbase}/lib/python{py_version_short}/site-packages', | |
| 'include': '{userbase}/include/python{py_version_short}', | |
| 'scripts': '{userbase}/bin', | |
| 'data' : '{userbase}', | |
| }, | |
| 'osx_framework_user': { | |
| 'stdlib': '{userbase}/lib/python', | |
| 'platstdlib': '{userbase}/lib/python', | |
| 'purelib': '{userbase}/lib/python/site-packages', | |
| 'platlib': '{userbase}/lib/python/site-packages', | |
| 'include': '{userbase}/include', | |
| 'scripts': '{userbase}/bin', | |
| 'data' : '{userbase}', | |
| }, | |
| } | |
| _SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include', | |
| 'scripts', 'data') | |
| _PY_VERSION = sys.version.split()[0] | |
| _PY_VERSION_SHORT = sys.version[:3] | |
| _PY_VERSION_SHORT_NO_DOT = _PY_VERSION[0] + _PY_VERSION[2] | |
| _PREFIX = os.path.normpath(sys.prefix) | |
| _EXEC_PREFIX = os.path.normpath(sys.exec_prefix) | |
| _CONFIG_VARS = None | |
| _USER_BASE = None | |
| def _safe_realpath(path): | |
| try: | |
| return realpath(path) | |
| except OSError: | |
| return path | |
| if sys.executable: | |
| _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable)) | |
| else: | |
| # sys.executable can be empty if argv[0] has been changed and Python is | |
| # unable to retrieve the real program name | |
| _PROJECT_BASE = _safe_realpath(os.getcwd()) | |
| if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower(): | |
| _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir)) | |
| # PC/VS7.1 | |
| if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower(): | |
| _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir)) | |
| # PC/AMD64 | |
| if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower(): | |
| _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir)) | |
| def is_python_build(): | |
| for fn in ("Setup.dist", "Setup.local"): | |
| if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)): | |
| return True | |
| return False | |
| _PYTHON_BUILD = is_python_build() | |
| if _PYTHON_BUILD: | |
| for scheme in ('posix_prefix', 'posix_home'): | |
| _INSTALL_SCHEMES[scheme]['include'] = '{projectbase}/Include' | |
| _INSTALL_SCHEMES[scheme]['platinclude'] = '{srcdir}' | |
| def _subst_vars(s, local_vars): | |
| try: | |
| return s.format(**local_vars) | |
| except KeyError: | |
| try: | |
| return s.format(**os.environ) | |
| except KeyError, var: | |
| raise AttributeError('{%s}' % var) | |
| def _extend_dict(target_dict, other_dict): | |
| target_keys = target_dict.keys() | |
| for key, value in other_dict.items(): | |
| if key in target_keys: | |
| continue | |
| target_dict[key] = value | |
| def _expand_vars(scheme, vars): | |
| res = {} | |
| if vars is None: | |
| vars = {} | |
| _extend_dict(vars, get_config_vars()) | |
| for key, value in _INSTALL_SCHEMES[scheme].items(): | |
| if os.name in ('posix', 'nt'): | |
| value = os.path.expanduser(value) | |
| res[key] = os.path.normpath(_subst_vars(value, vars)) | |
| return res | |
| def _get_default_scheme(): | |
| if os.name == 'posix': | |
| # the default scheme for posix is posix_prefix | |
| return 'posix_prefix' | |
| return os.name | |
| def _getuserbase(): | |
| env_base = os.environ.get("PYTHONUSERBASE", None) | |
| def joinuser(*args): | |
| return os.path.expanduser(os.path.join(*args)) | |
| # what about 'os2emx', 'riscos' ? | |
| if os.name == "nt": | |
| base = os.environ.get("APPDATA") or "~" | |
| return env_base if env_base else joinuser(base, "Python") | |
| if sys.platform == "darwin": | |
| framework = get_config_var("PYTHONFRAMEWORK") | |
| if framework: | |
| return joinuser("~", "Library", framework, "%d.%d"%( | |
| sys.version_info[:2])) | |
| return env_base if env_base else joinuser("~", ".local") | |
| def _parse_makefile(filename, vars=None): | |
| """Parse a Makefile-style file. | |
| A dictionary containing name/value pairs is returned. If an | |
| optional dictionary is passed in as the second argument, it is | |
| used instead of a new dictionary. | |
| """ | |
| import re | |
| # Regexes needed for parsing Makefile (and similar syntaxes, | |
| # like old-style Setup files). | |
| _variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)") | |
| _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)") | |
| _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}") | |
| if vars is None: | |
| vars = {} | |
| done = {} | |
| notdone = {} | |
| with open(filename) as f: | |
| lines = f.readlines() | |
| for line in lines: | |
| if line.startswith('#') or line.strip() == '': | |
| continue | |
| m = _variable_rx.match(line) | |
| if m: | |
| n, v = m.group(1, 2) | |
| v = v.strip() | |
| # `$$' is a literal `$' in make | |
| tmpv = v.replace('$$', '') | |
| if "$" in tmpv: | |
| notdone[n] = v | |
| else: | |
| try: | |
| v = int(v) | |
| except ValueError: | |
| # insert literal `$' | |
| done[n] = v.replace('$$', '$') | |
| else: | |
| done[n] = v | |
| # do variable interpolation here | |
| while notdone: | |
| for name in notdone.keys(): | |
| value = notdone[name] | |
| m = _findvar1_rx.search(value) or _findvar2_rx.search(value) | |
| if m: | |
| n = m.group(1) | |
| found = True | |
| if n in done: | |
| item = str(done[n]) | |
| elif n in notdone: | |
| # get it on a subsequent round | |
| found = False | |
| elif n in os.environ: | |
| # do it like make: fall back to environment | |
| item = os.environ[n] | |
| else: | |
| done[n] = item = "" | |
| if found: | |
| after = value[m.end():] | |
| value = value[:m.start()] + item + after | |
| if "$" in after: | |
| notdone[name] = value | |
| else: | |
| try: value = int(value) | |
| except ValueError: | |
| done[name] = value.strip() | |
| else: | |
| done[name] = value | |
| del notdone[name] | |
| else: | |
| # bogus variable reference; just drop it since we can't deal | |
| del notdone[name] | |
| # strip spurious spaces | |
| for k, v in done.items(): | |
| if isinstance(v, str): | |
| done[k] = v.strip() | |
| # save the results in the global dictionary | |
| vars.update(done) | |
| return vars | |
| def _get_makefile_filename(): | |
| if _PYTHON_BUILD: | |
| return os.path.join(_PROJECT_BASE, "Makefile") | |
| return os.path.join(get_path('platstdlib'), "config", "Makefile") | |
| def _init_posix(vars): | |
| """Initialize the module as appropriate for POSIX systems.""" | |
| # load the installed Makefile: | |
| makefile = _get_makefile_filename() | |
| try: | |
| _parse_makefile(makefile, vars) | |
| except IOError, e: | |
| msg = "invalid Python installation: unable to open %s" % makefile | |
| if hasattr(e, "strerror"): | |
| msg = msg + " (%s)" % e.strerror | |
| raise IOError(msg) | |
| # load the installed pyconfig.h: | |
| config_h = get_config_h_filename() | |
| try: | |
| with open(config_h) as f: | |
| parse_config_h(f, vars) | |
| except IOError, e: | |
| msg = "invalid Python installation: unable to open %s" % config_h | |
| if hasattr(e, "strerror"): | |
| msg = msg + " (%s)" % e.strerror | |
| raise IOError(msg) | |
| # On AIX, there are wrong paths to the linker scripts in the Makefile | |
| # -- these paths are relative to the Python source, but when installed | |
| # the scripts are in another directory. | |
| if _PYTHON_BUILD: | |
| vars['LDSHARED'] = vars['BLDSHARED'] | |
| def _init_non_posix(vars): | |
| """Initialize the module as appropriate for NT""" | |
| # set basic install directories | |
| vars['LIBDEST'] = get_path('stdlib') | |
| vars['BINLIBDEST'] = get_path('platstdlib') | |
| vars['INCLUDEPY'] = get_path('include') | |
| vars['SO'] = '.pyd' | |
| vars['EXE'] = '.exe' | |
| vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT | |
| vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable)) | |
| # | |
| # public APIs | |
| # | |
| def parse_config_h(fp, vars=None): | |
| """Parse a config.h-style file. | |
| A dictionary containing name/value pairs is returned. If an | |
| optional dictionary is passed in as the second argument, it is | |
| used instead of a new dictionary. | |
| """ | |
| import re | |
| if vars is None: | |
| vars = {} | |
| define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n") | |
| undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n") | |
| while True: | |
| line = fp.readline() | |
| if not line: | |
| break | |
| m = define_rx.match(line) | |
| if m: | |
| n, v = m.group(1, 2) | |
| try: v = int(v) | |
| except ValueError: pass | |
| vars[n] = v | |
| else: | |
| m = undef_rx.match(line) | |
| if m: | |
| vars[m.group(1)] = 0 | |
| return vars | |
| def get_config_h_filename(): | |
| """Returns the path of pyconfig.h.""" | |
| if _PYTHON_BUILD: | |
| if os.name == "nt": | |
| inc_dir = os.path.join(_PROJECT_BASE, "PC") | |
| else: | |
| inc_dir = _PROJECT_BASE | |
| else: | |
| inc_dir = get_path('platinclude') | |
| return os.path.join(inc_dir, 'pyconfig.h') | |
| def get_scheme_names(): | |
| """Returns a tuple containing the schemes names.""" | |
| schemes = _INSTALL_SCHEMES.keys() | |
| schemes.sort() | |
| return tuple(schemes) | |
| def get_path_names(): | |
| """Returns a tuple containing the paths names.""" | |
| return _SCHEME_KEYS | |
| def get_paths(scheme=_get_default_scheme(), vars=None, expand=True): | |
| """Returns a mapping containing an install scheme. | |
| ``scheme`` is the install scheme name. If not provided, it will | |
| return the default scheme for the current platform. | |
| """ | |
| if expand: | |
| return _expand_vars(scheme, vars) | |
| else: | |
| return _INSTALL_SCHEMES[scheme] | |
| def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True): | |
| """Returns a path corresponding to the scheme. | |
| ``scheme`` is the install scheme name. | |
| """ | |
| return get_paths(scheme, vars, expand)[name] | |
| def get_config_vars(*args): | |
| """With no arguments, return a dictionary of all configuration | |
| variables relevant for the current platform. | |
| On Unix, this means every variable defined in Python's installed Makefile; | |
| On Windows and Mac OS it's a much smaller set. | |
| With arguments, return a list of values that result from looking up | |
| each argument in the configuration variable dictionary. | |
| """ | |
| import re | |
| global _CONFIG_VARS | |
| if _CONFIG_VARS is None: | |
| _CONFIG_VARS = {} | |
| # Normalized versions of prefix and exec_prefix are handy to have; | |
| # in fact, these are the standard versions used most places in the | |
| # Distutils. | |
| _CONFIG_VARS['prefix'] = _PREFIX | |
| _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX | |
| _CONFIG_VARS['py_version'] = _PY_VERSION | |
| _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT | |
| _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2] | |
| _CONFIG_VARS['base'] = _PREFIX | |
| _CONFIG_VARS['platbase'] = _EXEC_PREFIX | |
| _CONFIG_VARS['projectbase'] = _PROJECT_BASE | |
| if os.name in ('nt', 'os2'): | |
| _init_non_posix(_CONFIG_VARS) | |
| if os.name == 'posix': | |
| _init_posix(_CONFIG_VARS) | |
| # Setting 'userbase' is done below the call to the | |
| # init function to enable using 'get_config_var' in | |
| # the init-function. | |
| _CONFIG_VARS['userbase'] = _getuserbase() | |
| if 'srcdir' not in _CONFIG_VARS: | |
| _CONFIG_VARS['srcdir'] = _PROJECT_BASE | |
| # Convert srcdir into an absolute path if it appears necessary. | |
| # Normally it is relative to the build directory. However, during | |
| # testing, for example, we might be running a non-installed python | |
| # from a different directory. | |
| if _PYTHON_BUILD and os.name == "posix": | |
| base = _PROJECT_BASE | |
| try: | |
| cwd = os.getcwd() | |
| except OSError: | |
| cwd = None | |
| if (not os.path.isabs(_CONFIG_VARS['srcdir']) and | |
| base != cwd): | |
| # srcdir is relative and we are not in the same directory | |
| # as the executable. Assume executable is in the build | |
| # directory and make srcdir absolute. | |
| srcdir = os.path.join(base, _CONFIG_VARS['srcdir']) | |
| _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir) | |
| if sys.platform == 'darwin': | |
| kernel_version = os.uname()[2] # Kernel version (8.4.3) | |
| major_version = int(kernel_version.split('.')[0]) | |
| if major_version < 8: | |
| # On Mac OS X before 10.4, check if -arch and -isysroot | |
| # are in CFLAGS or LDFLAGS and remove them if they are. | |
| # This is needed when building extensions on a 10.3 system | |
| # using a universal build of python. | |
| for key in ('LDFLAGS', 'BASECFLAGS', | |
| # a number of derived variables. These need to be | |
| # patched up as well. | |
| 'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'): | |
| flags = _CONFIG_VARS[key] | |
| flags = re.sub('-arch\s+\w+\s', ' ', flags) | |
| flags = re.sub('-isysroot [^ \t]*', ' ', flags) | |
| _CONFIG_VARS[key] = flags | |
| else: | |
| # Allow the user to override the architecture flags using | |
| # an environment variable. | |
| # NOTE: This name was introduced by Apple in OSX 10.5 and | |
| # is used by several scripting languages distributed with | |
| # that OS release. | |
| if 'ARCHFLAGS' in os.environ: | |
| arch = os.environ['ARCHFLAGS'] | |
| for key in ('LDFLAGS', 'BASECFLAGS', | |
| # a number of derived variables. These need to be | |
| # patched up as well. | |
| 'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'): | |
| flags = _CONFIG_VARS[key] | |
| flags = re.sub('-arch\s+\w+\s', ' ', flags) | |
| flags = flags + ' ' + arch | |
| _CONFIG_VARS[key] = flags | |
| # If we're on OSX 10.5 or later and the user tries to | |
| # compiles an extension using an SDK that is not present | |
| # on the current machine it is better to not use an SDK | |
| # than to fail. | |
| # | |
| # The major usecase for this is users using a Python.org | |
| # binary installer on OSX 10.6: that installer uses | |
| # the 10.4u SDK, but that SDK is not installed by default | |
| # when you install Xcode. | |
| # | |
| CFLAGS = _CONFIG_VARS.get('CFLAGS', '') | |
| m = re.search('-isysroot\s+(\S+)', CFLAGS) | |
| if m is not None: | |
| sdk = m.group(1) | |
| if not os.path.exists(sdk): | |
| for key in ('LDFLAGS', 'BASECFLAGS', | |
| # a number of derived variables. These need to be | |
| # patched up as well. | |
| 'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'): | |
| flags = _CONFIG_VARS[key] | |
| flags = re.sub('-isysroot\s+\S+(\s|$)', ' ', flags) | |
| _CONFIG_VARS[key] = flags | |
| if args: | |
| vals = [] | |
| for name in args: | |
| vals.append(_CONFIG_VARS.get(name)) | |
| return vals | |
| else: | |
| return _CONFIG_VARS | |
| def get_config_var(name): | |
| """Return the value of a single variable using the dictionary returned by | |
| 'get_config_vars()'. | |
| Equivalent to get_config_vars().get(name) | |
| """ | |
| return get_config_vars().get(name) | |
| def get_platform(): | |
| """Return a string that identifies the current platform. | |
| This is used mainly to distinguish platform-specific build directories and | |
| platform-specific built distributions. Typically includes the OS name | |
| and version and the architecture (as supplied by 'os.uname()'), | |
| although the exact information included depends on the OS; eg. for IRIX | |
| the architecture isn't particularly important (IRIX only runs on SGI | |
| hardware), but for Linux the kernel version isn't particularly | |
| important. | |
| Examples of returned values: | |
| linux-i586 | |
| linux-alpha (?) | |
| solaris-2.6-sun4u | |
| irix-5.3 | |
| irix64-6.2 | |
| Windows will return one of: | |
| win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc) | |
| win-ia64 (64bit Windows on Itanium) | |
| win32 (all others - specifically, sys.platform is returned) | |
| For other non-POSIX platforms, currently just returns 'sys.platform'. | |
| """ | |
| import re | |
| if os.name == 'nt': | |
| # sniff sys.version for architecture. | |
| prefix = " bit (" | |
| i = sys.version.find(prefix) | |
| if i == -1: | |
| return sys.platform | |
| j = sys.version.find(")", i) | |
| look = sys.version[i+len(prefix):j].lower() | |
| if look == 'amd64': | |
| return 'win-amd64' | |
| if look == 'itanium': | |
| return 'win-ia64' | |
| return sys.platform | |
| if os.name != "posix" or not hasattr(os, 'uname'): | |
| # XXX what about the architecture? NT is Intel or Alpha, | |
| # Mac OS is M68k or PPC, etc. | |
| return sys.platform | |
| # Try to distinguish various flavours of Unix | |
| osname, host, release, version, machine = os.uname() | |
| # Convert the OS name to lowercase, remove '/' characters | |
| # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh") | |
| osname = osname.lower().replace('/', '') | |
| machine = machine.replace(' ', '_') | |
| machine = machine.replace('/', '-') | |
| if osname[:5] == "linux": | |
| # At least on Linux/Intel, 'machine' is the processor -- | |
| # i386, etc. | |
| # XXX what about Alpha, SPARC, etc? | |
| return "%s-%s" % (osname, machine) | |
| elif osname[:5] == "sunos": | |
| if release[0] >= "5": # SunOS 5 == Solaris 2 | |
| osname = "solaris" | |
| release = "%d.%s" % (int(release[0]) - 3, release[2:]) | |
| # fall through to standard osname-release-machine representation | |
| elif osname[:4] == "irix": # could be "irix64"! | |
| return "%s-%s" % (osname, release) | |
| elif osname[:3] == "aix": | |
| return "%s-%s.%s" % (osname, version, release) | |
| elif osname[:6] == "cygwin": | |
| osname = "cygwin" | |
| rel_re = re.compile (r'[\d.]+') | |
| m = rel_re.match(release) | |
| if m: | |
| release = m.group() | |
| elif osname[:6] == "darwin": | |
| # | |
| # For our purposes, we'll assume that the system version from | |
| # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set | |
| # to. This makes the compatibility story a bit more sane because the | |
| # machine is going to compile and link as if it were | |
| # MACOSX_DEPLOYMENT_TARGET. | |
| cfgvars = get_config_vars() | |
| macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET') | |
| if 1: | |
| # Always calculate the release of the running machine, | |
| # needed to determine if we can build fat binaries or not. | |
| macrelease = macver | |
| # Get the system version. Reading this plist is a documented | |
| # way to get the system version (see the documentation for | |
| # the Gestalt Manager) | |
| try: | |
| f = open('/System/Library/CoreServices/SystemVersion.plist') | |
| except IOError: | |
| # We're on a plain darwin box, fall back to the default | |
| # behaviour. | |
| pass | |
| else: | |
| try: | |
| m = re.search( | |
| r'<key>ProductUserVisibleVersion</key>\s*' + | |
| r'<string>(.*?)</string>', f.read()) | |
| if m is not None: | |
| macrelease = '.'.join(m.group(1).split('.')[:2]) | |
| # else: fall back to the default behaviour | |
| finally: | |
| f.close() | |
| if not macver: | |
| macver = macrelease | |
| if macver: | |
| release = macver | |
| osname = "macosx" | |
| if (macrelease + '.') >= '10.4.' and \ | |
| '-arch' in get_config_vars().get('CFLAGS', '').strip(): | |
| # The universal build will build fat binaries, but not on | |
| # systems before 10.4 | |
| # | |
| # Try to detect 4-way universal builds, those have machine-type | |
| # 'universal' instead of 'fat'. | |
| machine = 'fat' | |
| cflags = get_config_vars().get('CFLAGS') | |
| archs = re.findall('-arch\s+(\S+)', cflags) | |
| archs = tuple(sorted(set(archs))) | |
| if len(archs) == 1: | |
| machine = archs[0] | |
| elif archs == ('i386', 'ppc'): | |
| machine = 'fat' | |
| elif archs == ('i386', 'x86_64'): | |
| machine = 'intel' | |
| elif archs == ('i386', 'ppc', 'x86_64'): | |
| machine = 'fat3' | |
| elif archs == ('ppc64', 'x86_64'): | |
| machine = 'fat64' | |
| elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'): | |
| machine = 'universal' | |
| else: | |
| raise ValueError( | |
| "Don't know machine value for archs=%r"%(archs,)) | |
| elif machine == 'i386': | |
| # On OSX the machine type returned by uname is always the | |
| # 32-bit variant, even if the executable architecture is | |
| # the 64-bit variant | |
| if sys.maxint >= 2**32: | |
| machine = 'x86_64' | |
| elif machine in ('PowerPC', 'Power_Macintosh'): | |
| # Pick a sane name for the PPC architecture. | |
| # See 'i386' case | |
| if sys.maxint >= 2**32: | |
| machine = 'ppc64' | |
| else: | |
| machine = 'ppc' | |
| return "%s-%s-%s" % (osname, release, machine) | |
| def get_python_version(): | |
| return _PY_VERSION_SHORT |