blob: b51629eb94f825d8d0f857b8aa5b431814199d72 [file] [log] [blame]
xf.li86118912025-03-19 20:07:27 -07001"""Provide access to Python's configuration information. The specific
2configuration variables available depend heavily on the platform and
3configuration. The values may be retrieved using
4get_config_var(name), and the list of variables is available via
5get_config_vars().keys(). Additional convenience functions are also
6available.
7
8Written by: Fred L. Drake, Jr.
9Email: <fdrake@acm.org>
10"""
11
12import _imp
13import os
14import re
15import sys
16
17from .errors import DistutilsPlatformError
18from .util import get_platform, get_host_platform
19
20# These are needed in a couple of spots, so just compute them once.
21PREFIX = os.path.normpath(sys.prefix)
22EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
23BASE_PREFIX = os.path.normpath(sys.base_prefix)
24BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
25
26# Path to the base directory of the project. On Windows the binary may
27# live in project/PCbuild/win32 or project/PCbuild/amd64.
28# set for cross builds
29if "_PYTHON_PROJECT_BASE" in os.environ:
30 project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
31else:
32 if sys.executable:
33 project_base = os.path.dirname(os.path.abspath(sys.executable))
34 else:
35 # sys.executable can be empty if argv[0] has been changed and Python is
36 # unable to retrieve the real program name
37 project_base = os.getcwd()
38
39
40# python_build: (Boolean) if true, we're either building Python or
41# building an extension with an un-installed Python, so we use
42# different (hard-wired) directories.
43def _is_python_source_dir(d):
44 for fn in ("Setup", "Setup.local"):
45 if os.path.isfile(os.path.join(d, "Modules", fn)):
46 return True
47 return False
48
49_sys_home = getattr(sys, '_home', None)
50
51if os.name == 'nt':
52 def _fix_pcbuild(d):
53 if d and os.path.normcase(d).startswith(
54 os.path.normcase(os.path.join(PREFIX, "PCbuild"))):
55 return PREFIX
56 return d
57 project_base = _fix_pcbuild(project_base)
58 _sys_home = _fix_pcbuild(_sys_home)
59
60def _python_build():
61 if _sys_home:
62 return _is_python_source_dir(_sys_home)
63 return _is_python_source_dir(project_base)
64
65python_build = _python_build()
66
67
68# Calculate the build qualifier flags if they are defined. Adding the flags
69# to the include and lib directories only makes sense for an installation, not
70# an in-source build.
71build_flags = ''
72try:
73 if not python_build:
74 build_flags = sys.abiflags
75except AttributeError:
76 # It's not a configure-based build, so the sys module doesn't have
77 # this attribute, which is fine.
78 pass
79
80def get_python_version():
81 """Return a string containing the major and minor Python version,
82 leaving off the patchlevel. Sample return values could be '1.5'
83 or '2.2'.
84 """
85 return '%d.%d' % sys.version_info[:2]
86
87
88def get_python_inc(plat_specific=0, prefix=None):
89 """Return the directory containing installed Python header files.
90
91 If 'plat_specific' is false (the default), this is the path to the
92 non-platform-specific header files, i.e. Python.h and so on;
93 otherwise, this is the path to platform-specific header files
94 (namely pyconfig.h).
95
96 If 'prefix' is supplied, use it instead of sys.base_prefix or
97 sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
98 """
99 if prefix is None:
100 prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
101 if os.name == "posix":
102 if python_build:
103 # Assume the executable is in the build directory. The
104 # pyconfig.h file should be in the same directory. Since
105 # the build directory may not be the source directory, we
106 # must use "srcdir" from the makefile to find the "Include"
107 # directory.
108 if plat_specific:
109 return _sys_home or project_base
110 else:
111 incdir = os.path.join(get_config_var('srcdir'), 'Include')
112 return os.path.normpath(incdir)
113 python_dir = 'python' + get_python_version() + build_flags
114 return os.path.join(prefix, "include", python_dir)
115 elif os.name == "nt":
116 if python_build:
117 # Include both the include and PC dir to ensure we can find
118 # pyconfig.h
119 return (os.path.join(prefix, "include") + os.path.pathsep +
120 os.path.join(prefix, "PC"))
121 return os.path.join(prefix, "include")
122 else:
123 raise DistutilsPlatformError(
124 "I don't know where Python installs its C header files "
125 "on platform '%s'" % os.name)
126
127
128def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
129 """Return the directory containing the Python library (standard or
130 site additions).
131
132 If 'plat_specific' is true, return the directory containing
133 platform-specific modules, i.e. any module from a non-pure-Python
134 module distribution; otherwise, return the platform-shared library
135 directory. If 'standard_lib' is true, return the directory
136 containing standard Python library modules; otherwise, return the
137 directory for site-specific modules.
138
139 If 'prefix' is supplied, use it instead of sys.base_prefix or
140 sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
141 """
142 if prefix is None:
143 if standard_lib:
144 prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
145 else:
146 prefix = plat_specific and EXEC_PREFIX or PREFIX
147
148 if os.name == "posix":
149 libpython = os.path.join(prefix,
150 "lib", "python" + get_python_version())
151 if standard_lib:
152 return libpython
153 else:
154 return os.path.join(libpython, "site-packages")
155 elif os.name == "nt":
156 if standard_lib:
157 return os.path.join(prefix, "Lib")
158 else:
159 return os.path.join(prefix, "Lib", "site-packages")
160 else:
161 raise DistutilsPlatformError(
162 "I don't know where Python installs its library "
163 "on platform '%s'" % os.name)
164
165
166
167def customize_compiler(compiler):
168 """Do any platform-specific customization of a CCompiler instance.
169
170 Mainly needed on Unix, so we can plug in the information that
171 varies across Unices and is stored in Python's Makefile.
172 """
173 if compiler.compiler_type == "unix":
174 if sys.platform == "darwin":
175 # Perform first-time customization of compiler-related
176 # config vars on OS X now that we know we need a compiler.
177 # This is primarily to support Pythons from binary
178 # installers. The kind and paths to build tools on
179 # the user system may vary significantly from the system
180 # that Python itself was built on. Also the user OS
181 # version and build tools may not support the same set
182 # of CPU architectures for universal builds.
183 global _config_vars
184 # Use get_config_var() to ensure _config_vars is initialized.
185 if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
186 import _osx_support
187 _osx_support.customize_compiler(_config_vars)
188 _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
189
190 (cc, cxx, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \
191 get_config_vars('CC', 'CXX', 'CFLAGS',
192 'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')
193
194 if 'CC' in os.environ:
195 newcc = os.environ['CC']
196 if (sys.platform == 'darwin'
197 and 'LDSHARED' not in os.environ
198 and ldshared.startswith(cc)):
199 # On OS X, if CC is overridden, use that as the default
200 # command for LDSHARED as well
201 ldshared = newcc + ldshared[len(cc):]
202 cc = newcc
203 if 'CXX' in os.environ:
204 cxx = os.environ['CXX']
205 if 'LDSHARED' in os.environ:
206 ldshared = os.environ['LDSHARED']
207 if 'CPP' in os.environ:
208 cpp = os.environ['CPP']
209 else:
210 cpp = cc + " -E" # not always
211 if 'LDFLAGS' in os.environ:
212 ldshared = ldshared + ' ' + os.environ['LDFLAGS']
213 if 'CFLAGS' in os.environ:
214 cflags = cflags + ' ' + os.environ['CFLAGS']
215 ldshared = ldshared + ' ' + os.environ['CFLAGS']
216 if 'CPPFLAGS' in os.environ:
217 cpp = cpp + ' ' + os.environ['CPPFLAGS']
218 cflags = cflags + ' ' + os.environ['CPPFLAGS']
219 ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
220 if 'AR' in os.environ:
221 ar = os.environ['AR']
222 if 'ARFLAGS' in os.environ:
223 archiver = ar + ' ' + os.environ['ARFLAGS']
224 else:
225 archiver = ar + ' ' + ar_flags
226
227 cc_cmd = cc + ' ' + cflags
228 compiler.set_executables(
229 preprocessor=cpp,
230 compiler=cc_cmd,
231 compiler_so=cc_cmd + ' ' + ccshared,
232 compiler_cxx=cxx,
233 linker_so=ldshared,
234 linker_exe=cc,
235 archiver=archiver)
236
237 compiler.shared_lib_extension = shlib_suffix
238
239
240def get_config_h_filename():
241 """Return full pathname of installed pyconfig.h file."""
242 if python_build:
243 if os.name == "nt":
244 inc_dir = os.path.join(_sys_home or project_base, "PC")
245 else:
246 inc_dir = _sys_home or project_base
247 else:
248 inc_dir = get_python_inc(plat_specific=1)
249
250 return os.path.join(inc_dir, 'pyconfig.h')
251
252
253def get_makefile_filename():
254 """Return full pathname of installed Makefile from the Python build."""
255 if python_build:
256 return os.path.join(_sys_home or project_base, "Makefile")
257 lib_dir = get_python_lib(plat_specific=0, standard_lib=1)
258 config_file = 'config-{}{}'.format(get_python_version(), build_flags)
259 if hasattr(sys.implementation, '_multiarch'):
260 config_file += '-%s' % sys.implementation._multiarch
261 return os.path.join(lib_dir, config_file, 'Makefile')
262
263
264def parse_config_h(fp, g=None):
265 """Parse a config.h-style file.
266
267 A dictionary containing name/value pairs is returned. If an
268 optional dictionary is passed in as the second argument, it is
269 used instead of a new dictionary.
270 """
271 if g is None:
272 g = {}
273 define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
274 undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
275 #
276 while True:
277 line = fp.readline()
278 if not line:
279 break
280 m = define_rx.match(line)
281 if m:
282 n, v = m.group(1, 2)
283 try: v = int(v)
284 except ValueError: pass
285 g[n] = v
286 else:
287 m = undef_rx.match(line)
288 if m:
289 g[m.group(1)] = 0
290 return g
291
292
293# Regexes needed for parsing Makefile (and similar syntaxes,
294# like old-style Setup files).
295_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
296_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
297_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
298
299def parse_makefile(fn, g=None):
300 """Parse a Makefile-style file.
301
302 A dictionary containing name/value pairs is returned. If an
303 optional dictionary is passed in as the second argument, it is
304 used instead of a new dictionary.
305 """
306 from distutils.text_file import TextFile
307 fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape")
308
309 if g is None:
310 g = {}
311 done = {}
312 notdone = {}
313
314 while True:
315 line = fp.readline()
316 if line is None: # eof
317 break
318 m = _variable_rx.match(line)
319 if m:
320 n, v = m.group(1, 2)
321 v = v.strip()
322 # `$$' is a literal `$' in make
323 tmpv = v.replace('$$', '')
324
325 if "$" in tmpv:
326 notdone[n] = v
327 else:
328 try:
329 v = int(v)
330 except ValueError:
331 # insert literal `$'
332 done[n] = v.replace('$$', '$')
333 else:
334 done[n] = v
335
336 # Variables with a 'PY_' prefix in the makefile. These need to
337 # be made available without that prefix through sysconfig.
338 # Special care is needed to ensure that variable expansion works, even
339 # if the expansion uses the name without a prefix.
340 renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
341
342 # do variable interpolation here
343 while notdone:
344 for name in list(notdone):
345 value = notdone[name]
346 m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
347 if m:
348 n = m.group(1)
349 found = True
350 if n in done:
351 item = str(done[n])
352 elif n in notdone:
353 # get it on a subsequent round
354 found = False
355 elif n in os.environ:
356 # do it like make: fall back to environment
357 item = os.environ[n]
358
359 elif n in renamed_variables:
360 if name.startswith('PY_') and name[3:] in renamed_variables:
361 item = ""
362
363 elif 'PY_' + n in notdone:
364 found = False
365
366 else:
367 item = str(done['PY_' + n])
368 else:
369 done[n] = item = ""
370 if found:
371 after = value[m.end():]
372 value = value[:m.start()] + item + after
373 if "$" in after:
374 notdone[name] = value
375 else:
376 try: value = int(value)
377 except ValueError:
378 done[name] = value.strip()
379 else:
380 done[name] = value
381 del notdone[name]
382
383 if name.startswith('PY_') \
384 and name[3:] in renamed_variables:
385
386 name = name[3:]
387 if name not in done:
388 done[name] = value
389 else:
390 # bogus variable reference; just drop it since we can't deal
391 del notdone[name]
392
393 fp.close()
394
395 # strip spurious spaces
396 for k, v in done.items():
397 if isinstance(v, str):
398 done[k] = v.strip()
399
400 # save the results in the global dictionary
401 g.update(done)
402 return g
403
404
405def expand_makefile_vars(s, vars):
406 """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
407 'string' according to 'vars' (a dictionary mapping variable names to
408 values). Variables not present in 'vars' are silently expanded to the
409 empty string. The variable values in 'vars' should not contain further
410 variable expansions; if 'vars' is the output of 'parse_makefile()',
411 you're fine. Returns a variable-expanded version of 's'.
412 """
413
414 # This algorithm does multiple expansion, so if vars['foo'] contains
415 # "${bar}", it will expand ${foo} to ${bar}, and then expand
416 # ${bar}... and so forth. This is fine as long as 'vars' comes from
417 # 'parse_makefile()', which takes care of such expansions eagerly,
418 # according to make's variable expansion semantics.
419
420 while True:
421 m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
422 if m:
423 (beg, end) = m.span()
424 s = s[0:beg] + vars.get(m.group(1)) + s[end:]
425 else:
426 break
427 return s
428
429
430_config_vars = None
431
432def _init_posix():
433 """Initialize the module as appropriate for POSIX systems."""
434 # _sysconfigdata is generated at build time, see the sysconfig module
435 name = os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',
436 '_sysconfigdata_{abi}_{platform}_{multiarch}'.format(
437 abi=sys.abiflags,
438 platform=sys.platform,
439 multiarch=getattr(sys.implementation, '_multiarch', ''),
440 ))
441 _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
442 build_time_vars = _temp.build_time_vars
443 global _config_vars
444 _config_vars = {}
445 _config_vars.update(build_time_vars)
446
447
448def _init_nt():
449 """Initialize the module as appropriate for NT"""
450 g = {}
451 # set basic install directories
452 g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
453 g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
454
455 # XXX hmmm.. a normal install puts include files here
456 g['INCLUDEPY'] = get_python_inc(plat_specific=0)
457
458 g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
459 g['EXE'] = ".exe"
460 g['VERSION'] = get_python_version().replace(".", "")
461 g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))
462
463 global _config_vars
464 _config_vars = g
465
466
467def get_config_vars(*args):
468 """With no arguments, return a dictionary of all configuration
469 variables relevant for the current platform. Generally this includes
470 everything needed to build extensions and install both pure modules and
471 extensions. On Unix, this means every variable defined in Python's
472 installed Makefile; on Windows it's a much smaller set.
473
474 With arguments, return a list of values that result from looking up
475 each argument in the configuration variable dictionary.
476 """
477 global _config_vars
478 if _config_vars is None:
479 func = globals().get("_init_" + os.name)
480 if func:
481 func()
482 else:
483 _config_vars = {}
484
485 # Normalized versions of prefix and exec_prefix are handy to have;
486 # in fact, these are the standard versions used most places in the
487 # Distutils.
488 _config_vars['prefix'] = PREFIX
489 _config_vars['exec_prefix'] = EXEC_PREFIX
490
491 # For backward compatibility, see issue19555
492 SO = _config_vars.get('EXT_SUFFIX')
493 if SO is not None:
494 _config_vars['SO'] = SO
495
496 # Always convert srcdir to an absolute path
497 srcdir = _config_vars.get('srcdir', project_base)
498 if os.name == 'posix':
499 if python_build:
500 # If srcdir is a relative path (typically '.' or '..')
501 # then it should be interpreted relative to the directory
502 # containing Makefile.
503 base = os.path.dirname(get_makefile_filename())
504 srcdir = os.path.join(base, srcdir)
505 else:
506 # srcdir is not meaningful since the installation is
507 # spread about the filesystem. We choose the
508 # directory containing the Makefile since we know it
509 # exists.
510 srcdir = os.path.dirname(get_makefile_filename())
511 _config_vars['srcdir'] = os.path.abspath(os.path.normpath(srcdir))
512
513 # Convert srcdir into an absolute path if it appears necessary.
514 # Normally it is relative to the build directory. However, during
515 # testing, for example, we might be running a non-installed python
516 # from a different directory.
517 if python_build and os.name == "posix":
518 base = project_base
519 if (not os.path.isabs(_config_vars['srcdir']) and
520 base != os.getcwd()):
521 # srcdir is relative and we are not in the same directory
522 # as the executable. Assume executable is in the build
523 # directory and make srcdir absolute.
524 srcdir = os.path.join(base, _config_vars['srcdir'])
525 _config_vars['srcdir'] = os.path.normpath(srcdir)
526
527 # OS X platforms require special customization to handle
528 # multi-architecture, multi-os-version installers
529 if sys.platform == 'darwin':
530 import _osx_support
531 _osx_support.customize_config_vars(_config_vars)
532
533 if args:
534 vals = []
535 for name in args:
536 vals.append(_config_vars.get(name))
537 return vals
538 else:
539 return _config_vars
540
541def get_config_var(name):
542 """Return the value of a single variable using the dictionary
543 returned by 'get_config_vars()'. Equivalent to
544 get_config_vars().get(name)
545 """
546 if name == 'SO':
547 import warnings
548 warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
549 return get_config_vars().get(name)