Lib/distutils/sysconfig.py

   1 """Provide access to Python's configuration information.  The specific
   2 configuration variables available depend heavily on the platform and
   3 configuration.  The values may be retrieved using
   4 get_config_var(name), and the list of variables is available via
   5 get_config_vars().keys().  Additional convenience functions are also
   6 available.
   7
   8 Written by:   Fred L. Drake, Jr.
   9 Email:        <fdrake@acm.org>
  10 """
  11
  12 __revision__ = "$Id$"
  13
  14 import os
  15 import re
  16 import string
  17 import sys
  18
  19 from distutils.errors import DistutilsPlatformError
  20
  21 # These are needed in a couple of spots, so just compute them once.
  22 PREFIX = os.path.normpath(sys.prefix)
  23 EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
  24
  25 # python_build: (Boolean) if true, we're either building Python or
  26 # building an extension with an un-installed Python, so we use
  27 # different (hard-wired) directories.
  28
  29 argv0_path = os.path.dirname(os.path.abspath(sys.executable))
  30 landmark = os.path.join(argv0_path, "Modules", "Setup")
  31
  32 python_build = os.path.isfile(landmark)
  33
  34 del landmark
  35
  36
  37 def get_python_version():
  38     """Return a string containing the major and minor Python version,
  39     leaving off the patchlevel.  Sample return values could be '1.5'
  40     or '2.2'.
  41     """
  42     return sys.version[:3]
  43
  44
  45 def get_python_inc(plat_specific=0, prefix=None):
  46     """Return the directory containing installed Python header files.
  47
  48     If 'plat_specific' is false (the default), this is the path to the
  49     non-platform-specific header files, i.e. Python.h and so on;
  50     otherwise, this is the path to platform-specific header files
  51     (namely pyconfig.h).
  52
  53     If 'prefix' is supplied, use it instead of sys.prefix or
  54     sys.exec_prefix -- i.e., ignore 'plat_specific'.
  55     """
  56     if prefix is None:
  57         prefix = plat_specific and EXEC_PREFIX or PREFIX
  58     if os.name == "posix":
  59         if python_build:
  60             base = os.path.dirname(os.path.abspath(sys.executable))
  61             if plat_specific:
  62                 inc_dir = base
  63             else:
  64                 inc_dir = os.path.join(base, "Include")
  65                 if not os.path.exists(inc_dir):
  66                     inc_dir = os.path.join(os.path.dirname(base), "Include")
  67             return inc_dir
  68         return os.path.join(prefix, "include", "python" + get_python_version())
  69     elif os.name == "nt":
  70         return os.path.join(prefix, "include")
  71     elif os.name == "mac":
  72         if plat_specific:
  73             return os.path.join(prefix, "Mac", "Include")
  74         else:
  75             return os.path.join(prefix, "Include")
  76     elif os.name == "os2":
  77         return os.path.join(prefix, "Include")
  78     else:
  79         raise DistutilsPlatformError(
  80             "I don't know where Python installs its C header files "
  81             "on platform '%s'" % os.name)
  82
  83
  84 def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
  85     """Return the directory containing the Python library (standard or
  86     site additions).
  87
  88     If 'plat_specific' is true, return the directory containing
  89     platform-specific modules, i.e. any module from a non-pure-Python
  90     module distribution; otherwise, return the platform-shared library
  91     directory.  If 'standard_lib' is true, return the directory
  92     containing standard Python library modules; otherwise, return the
  93     directory for site-specific modules.
  94
  95     If 'prefix' is supplied, use it instead of sys.prefix or
  96     sys.exec_prefix -- i.e., ignore 'plat_specific'.
  97     """
  98     if prefix is None:
  99         prefix = plat_specific and EXEC_PREFIX or PREFIX
 100
 101     if os.name == "posix":
 102         libpython = os.path.join(prefix,
 103                                  "lib", "python" + get_python_version())
 104         if standard_lib:
 105             return libpython
 106         else:
 107             return os.path.join(libpython, "site-packages")
 108
 109     elif os.name == "nt":
 110         if standard_lib:
 111             return os.path.join(prefix, "Lib")
 112         else:
 113             if get_python_version() < "2.2":
 114                 return prefix
 115             else:
 116                 return os.path.join(PREFIX, "Lib", "site-packages")
 117
 118     elif os.name == "mac":
 119         if plat_specific:
 120             if standard_lib:
 121                 return os.path.join(prefix, "Lib", "lib-dynload")
 122             else:
 123                 return os.path.join(prefix, "Lib", "site-packages")
 124         else:
 125             if standard_lib:
 126                 return os.path.join(prefix, "Lib")
 127             else:
 128                 return os.path.join(prefix, "Lib", "site-packages")
 129
 130     elif os.name == "os2":
 131         if standard_lib:
 132             return os.path.join(PREFIX, "Lib")
 133         else:
 134             return os.path.join(PREFIX, "Lib", "site-packages")
 135
 136     else:
 137         raise DistutilsPlatformError(
 138             "I don't know where Python installs its library "
 139             "on platform '%s'" % os.name)
 140
 141
 142 def customize_compiler(compiler):
 143     """Do any platform-specific customization of a CCompiler instance.
 144
 145     Mainly needed on Unix, so we can plug in the information that
 146     varies across Unices and is stored in Python's Makefile.
 147     """
 148     if compiler.compiler_type == "unix":
 149         (cc, cxx, opt, cflags, ccshared, ldshared, so_ext) = \
 150             get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',
 151                             'CCSHARED', 'LDSHARED', 'SO')
 152
 153         if os.environ.has_key('CC'):
 154             cc = os.environ['CC']
 155         if os.environ.has_key('CXX'):
 156             cxx = os.environ['CXX']
 157         if os.environ.has_key('LDSHARED'):
 158             ldshared = os.environ['LDSHARED']
 159         if os.environ.has_key('CPP'):
 160             cpp = os.environ['CPP']
 161         else:
 162             cpp = cc + " -E"           # not always
 163         if os.environ.has_key('LDFLAGS'):
 164             ldshared = ldshared + ' ' + os.environ['LDFLAGS']
 165         if os.environ.has_key('CFLAGS'):
 166             cflags = opt + ' ' + os.environ['CFLAGS']
 167             ldshared = ldshared + ' ' + os.environ['CFLAGS']
 168         if os.environ.has_key('CPPFLAGS'):
 169             cpp = cpp + ' ' + os.environ['CPPFLAGS']
 170             cflags = cflags + ' ' + os.environ['CPPFLAGS']
 171             ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
 172
 173         cc_cmd = cc + ' ' + cflags
 174         compiler.set_executables(
 175             preprocessor=cpp,
 176             compiler=cc_cmd,
 177             compiler_so=cc_cmd + ' ' + ccshared,
 178             compiler_cxx=cxx,
 179             linker_so=ldshared,
 180             linker_exe=cc)
 181
 182         compiler.shared_lib_extension = so_ext
 183
 184
 185 def get_config_h_filename():
 186     """Return full pathname of installed pyconfig.h file."""
 187     if python_build:
 188         inc_dir = argv0_path
 189     else:
 190         inc_dir = get_python_inc(plat_specific=1)
 191     if get_python_version() < '2.2':
 192         config_h = 'config.h'
 193     else:
 194         # The name of the config.h file changed in 2.2
 195         config_h = 'pyconfig.h'
 196     return os.path.join(inc_dir, config_h)
 197
 198
 199 def get_makefile_filename():
 200     """Return full pathname of installed Makefile from the Python build."""
 201     if python_build:
 202         return os.path.join(os.path.dirname(sys.executable), "Makefile")
 203     lib_dir = get_python_lib(plat_specific=1, standard_lib=1)
 204     return os.path.join(lib_dir, "config", "Makefile")
 205
 206
 207 def parse_config_h(fp, g=None):
 208     """Parse a config.h-style file.
 209
 210     A dictionary containing name/value pairs is returned.  If an
 211     optional dictionary is passed in as the second argument, it is
 212     used instead of a new dictionary.
 213     """
 214     if g is None:
 215         g = {}
 216     define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
 217     undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
 218     #
 219     while 1:
 220         line = fp.readline()
 221         if not line:
 222             break
 223         m = define_rx.match(line)
 224         if m:
 225             n, v = m.group(1, 2)
 226             try: v = int(v)
 227             except ValueError: pass
 228             g[n] = v
 229         else:
 230             m = undef_rx.match(line)
 231             if m:
 232                 g[m.group(1)] = 0
 233     return g
 234
 235
 236 # Regexes needed for parsing Makefile (and similar syntaxes,
 237 # like old-style Setup files).
 238 _variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
 239 _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
 240 _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
 241
 242 def parse_makefile(fn, g=None):
 243     """Parse a Makefile-style file.
 244
 245     A dictionary containing name/value pairs is returned.  If an
 246     optional dictionary is passed in as the second argument, it is
 247     used instead of a new dictionary.
 248     """
 249     from distutils.text_file import TextFile
 250     fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1)
 251
 252     if g is None:
 253         g = {}
 254     done = {}
 255     notdone = {}
 256
 257     while 1:
 258         line = fp.readline()
 259         if line is None:                # eof
 260             break
 261         m = _variable_rx.match(line)
 262         if m:
 263             n, v = m.group(1, 2)
 264             v = string.strip(v)
 265             if "$" in v:
 266                 notdone[n] = v
 267             else:
 268                 try: v = int(v)
 269                 except ValueError: pass
 270                 done[n] = v
 271
 272     # do variable interpolation here
 273     while notdone:
 274         for name in notdone.keys():
 275             value = notdone[name]
 276             m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
 277             if m:
 278                 n = m.group(1)
 279                 found = True
 280                 if done.has_key(n):
 281                     item = str(done[n])
 282                 elif notdone.has_key(n):
 283                     # get it on a subsequent round
 284                     found = False
 285                 elif os.environ.has_key(n):
 286                     # do it like make: fall back to environment
 287                     item = os.environ[n]
 288                 else:
 289                     done[n] = item = ""
 290                 if found:
 291                     after = value[m.end():]
 292                     value = value[:m.start()] + item + after
 293                     if "$" in after:
 294                         notdone[name] = value
 295                     else:
 296                         try: value = int(value)
 297                         except ValueError:
 298                             done[name] = string.strip(value)
 299                         else:
 300                             done[name] = value
 301                         del notdone[name]
 302             else:
 303                 # bogus variable reference; just drop it since we can't deal
 304                 del notdone[name]
 305
 306     fp.close()
 307
 308     # save the results in the global dictionary
 309     g.update(done)
 310     return g
 311
 312
 313 def expand_makefile_vars(s, vars):
 314     """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
 315     'string' according to 'vars' (a dictionary mapping variable names to
 316     values).  Variables not present in 'vars' are silently expanded to the
 317     empty string.  The variable values in 'vars' should not contain further
 318     variable expansions; if 'vars' is the output of 'parse_makefile()',
 319     you're fine.  Returns a variable-expanded version of 's'.
 320     """
 321
 322     # This algorithm does multiple expansion, so if vars['foo'] contains
 323     # "${bar}", it will expand ${foo} to ${bar}, and then expand
 324     # ${bar}... and so forth.  This is fine as long as 'vars' comes from
 325     # 'parse_makefile()', which takes care of such expansions eagerly,
 326     # according to make's variable expansion semantics.
 327
 328     while 1:
 329         m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
 330         if m:
 331             (beg, end) = m.span()
 332             s = s[0:beg] + vars.get(m.group(1)) + s[end:]
 333         else:
 334             break
 335     return s
 336
 337
 338 _config_vars = None
 339
 340 def _init_posix():
 341     """Initialize the module as appropriate for POSIX systems."""
 342     g = {}
 343     # load the installed Makefile:
 344     try:
 345         filename = get_makefile_filename()
 346         parse_makefile(filename, g)
 347     except IOError, msg:
 348         my_msg = "invalid Python installation: unable to open %s" % filename
 349         if hasattr(msg, "strerror"):
 350             my_msg = my_msg + " (%s)" % msg.strerror
 351
 352         raise DistutilsPlatformError(my_msg)
 353
 354     # load the installed pyconfig.h:
 355     try:
 356         filename = get_config_h_filename()
 357         parse_config_h(file(filename), g)
 358     except IOError, msg:
 359         my_msg = "invalid Python installation: unable to open %s" % filename
 360         if hasattr(msg, "strerror"):
 361             my_msg = my_msg + " (%s)" % msg.strerror
 362
 363         raise DistutilsPlatformError(my_msg)
 364
 365     # On MacOSX we need to check the setting of the environment variable
 366     # MACOSX_DEPLOYMENT_TARGET: configure bases some choices on it so
 367     # it needs to be compatible.
 368     # If it isn't set we set it to the configure-time value
 369     if sys.platform == 'darwin' and g.has_key('MACOSX_DEPLOYMENT_TARGET'):
 370         cfg_target = g['MACOSX_DEPLOYMENT_TARGET']
 371         cur_target = os.getenv('MACOSX_DEPLOYMENT_TARGET', '')
 372         if cur_target == '':
 373             cur_target = cfg_target
 374             os.putenv('MACOSX_DEPLOYMENT_TARGET', cfg_target)
 375         elif map(int, cfg_target.split('.')) > map(int, cur_target.split('.')):
 376             my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure'
 377                 % (cur_target, cfg_target))
 378             raise DistutilsPlatformError(my_msg)
 379
 380     # On AIX, there are wrong paths to the linker scripts in the Makefile
 381     # -- these paths are relative to the Python source, but when installed
 382     # the scripts are in another directory.
 383     if python_build:
 384         g['LDSHARED'] = g['BLDSHARED']
 385
 386     elif get_python_version() < '2.1':
 387         # The following two branches are for 1.5.2 compatibility.
 388         if sys.platform == 'aix4':          # what about AIX 3.x ?
 389             # Linker script is in the config directory, not in Modules as the
 390             # Makefile says.
 391             python_lib = get_python_lib(standard_lib=1)
 392             ld_so_aix = os.path.join(python_lib, 'config', 'ld_so_aix')
 393             python_exp = os.path.join(python_lib, 'config', 'python.exp')
 394
 395             g['LDSHARED'] = "%s %s -bI:%s" % (ld_so_aix, g['CC'], python_exp)
 396
 397         elif sys.platform == 'beos':
 398             # Linker script is in the config directory.  In the Makefile it is
 399             # relative to the srcdir, which after installation no longer makes
 400             # sense.
 401             python_lib = get_python_lib(standard_lib=1)
 402             linkerscript_path = string.split(g['LDSHARED'])[0]
 403             linkerscript_name = os.path.basename(linkerscript_path)
 404             linkerscript = os.path.join(python_lib, 'config',
 405                                         linkerscript_name)
 406
 407             # XXX this isn't the right place to do this: adding the Python
 408             # library to the link, if needed, should be in the "build_ext"
 409             # command.  (It's also needed for non-MS compilers on Windows, and
 410             # it's taken care of for them by the 'build_ext.get_libraries()'
 411             # method.)
 412             g['LDSHARED'] = ("%s -L%s/lib -lpython%s" %
 413                              (linkerscript, PREFIX, get_python_version()))
 414
 415     global _config_vars
 416     _config_vars = g
 417
 418
 419 def _init_nt():
 420     """Initialize the module as appropriate for NT"""
 421     g = {}
 422     # set basic install directories
 423     g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
 424     g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
 425
 426     # XXX hmmm.. a normal install puts include files here
 427     g['INCLUDEPY'] = get_python_inc(plat_specific=0)
 428
 429     g['SO'] = '.pyd'
 430     g['EXE'] = ".exe"
 431
 432     global _config_vars
 433     _config_vars = g
 434
 435
 436 def _init_mac():
 437     """Initialize the module as appropriate for Macintosh systems"""
 438     g = {}
 439     # set basic install directories
 440     g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
 441     g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
 442
 443     # XXX hmmm.. a normal install puts include files here
 444     g['INCLUDEPY'] = get_python_inc(plat_specific=0)
 445
 446     import MacOS
 447     if not hasattr(MacOS, 'runtimemodel'):
 448         g['SO'] = '.ppc.slb'
 449     else:
 450         g['SO'] = '.%s.slb' % MacOS.runtimemodel
 451
 452     # XXX are these used anywhere?
 453     g['install_lib'] = os.path.join(EXEC_PREFIX, "Lib")
 454     g['install_platlib'] = os.path.join(EXEC_PREFIX, "Mac", "Lib")
 455
 456     # These are used by the extension module build
 457     g['srcdir'] = ':'
 458     global _config_vars
 459     _config_vars = g
 460
 461
 462 def _init_os2():
 463     """Initialize the module as appropriate for OS/2"""
 464     g = {}
 465     # set basic install directories
 466     g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
 467     g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
 468
 469     # XXX hmmm.. a normal install puts include files here
 470     g['INCLUDEPY'] = get_python_inc(plat_specific=0)
 471
 472     g['SO'] = '.pyd'
 473     g['EXE'] = ".exe"
 474
 475     global _config_vars
 476     _config_vars = g
 477
 478
 479 def get_config_vars(*args):
 480     """With no arguments, return a dictionary of all configuration
 481     variables relevant for the current platform.  Generally this includes
 482     everything needed to build extensions and install both pure modules and
 483     extensions.  On Unix, this means every variable defined in Python's
 484     installed Makefile; on Windows and Mac OS it's a much smaller set.
 485
 486     With arguments, return a list of values that result from looking up
 487     each argument in the configuration variable dictionary.
 488     """
 489     global _config_vars
 490     if _config_vars is None:
 491         func = globals().get("_init_" + os.name)
 492         if func:
 493             func()
 494         else:
 495             _config_vars = {}
 496
 497         # Normalized versions of prefix and exec_prefix are handy to have;
 498         # in fact, these are the standard versions used most places in the
 499         # Distutils.
 500         _config_vars['prefix'] = PREFIX
 501         _config_vars['exec_prefix'] = EXEC_PREFIX
 502
 503         if sys.platform == 'darwin':
 504             kernel_version = os.uname()[2] # Kernel version (8.4.3)
 505             major_version = int(kernel_version.split('.')[0])
 506
 507             if major_version < 8:
 508                 # On Mac OS X before 10.4, check if -arch and -isysroot
 509                 # are in CFLAGS or LDFLAGS and remove them if they are.
 510                 # This is needed when building extensions on a 10.3 system
 511                 # using a universal build of python.
 512                 for key in ('LDFLAGS', 'BASECFLAGS'):
 513                     flags = _config_vars[key]
 514                     flags = re.sub('-arch\s+\w+\s', ' ', flags)
 515                     flags = re.sub('-isysroot [^ \t]* ', ' ', flags)
 516                     _config_vars[key] = flags
 517
 518     if args:
 519         vals = []
 520         for name in args:
 521             vals.append(_config_vars.get(name))
 522         return vals
 523     else:
 524         return _config_vars
 525
 526 def get_config_var(name):
 527     """Return the value of a single variable using the dictionary
 528     returned by 'get_config_vars()'.  Equivalent to
 529     get_config_vars().get(name)
 530     """
 531     return get_config_vars().get(name)