]> git.saurik.com Git - wxWidgets.git/blob - wxPython/distutils/sysconfig.py
Added multi-line TextCtrl
[wxWidgets.git] / wxPython / 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 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 argv0_path, 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" + sys.version[:3])
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 sys.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, basecflags, ccshared, ldshared, so_ext) = \
150 get_config_vars('CC', 'CXX', 'OPT', 'BASECFLAGS', 'CCSHARED', 'LDSHARED', 'SO')
151
152 if os.environ.has_key('CC'):
153 cc = os.environ['CC']
154 if os.environ.has_key('CXX'):
155 cxx = os.environ['CXX']
156 if os.environ.has_key('CPP'):
157 cpp = os.environ['CPP']
158 else:
159 cpp = cc + " -E" # not always
160 if os.environ.has_key('LDFLAGS'):
161 ldshared = ldshared + ' ' + os.environ['LDFLAGS']
162 if basecflags:
163 opt = basecflags + ' ' + opt
164 if os.environ.has_key('CFLAGS'):
165 opt = opt + ' ' + os.environ['CFLAGS']
166 ldshared = ldshared + ' ' + os.environ['CFLAGS']
167 if os.environ.has_key('CPPFLAGS'):
168 cpp = cpp + ' ' + os.environ['CPPFLAGS']
169 opt = opt + ' ' + os.environ['CPPFLAGS']
170 ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
171
172 cc_cmd = cc + ' ' + opt
173 compiler.set_executables(
174 preprocessor=cpp,
175 compiler=cc_cmd,
176 compiler_so=cc_cmd + ' ' + ccshared,
177 compiler_cxx=cxx,
178 linker_so=ldshared,
179 linker_exe=cc)
180
181 compiler.shared_lib_extension = so_ext
182
183
184 def get_config_h_filename():
185 """Return full pathname of installed pyconfig.h file."""
186 if python_build:
187 inc_dir = os.curdir
188 else:
189 inc_dir = get_python_inc(plat_specific=1)
190 if sys.version < '2.2':
191 config_h = 'config.h'
192 else:
193 # The name of the config.h file changed in 2.2
194 config_h = 'pyconfig.h'
195 return os.path.join(inc_dir, config_h)
196
197
198 def get_makefile_filename():
199 """Return full pathname of installed Makefile from the Python build."""
200 if python_build:
201 return os.path.join(os.path.dirname(sys.executable), "Makefile")
202 lib_dir = get_python_lib(plat_specific=1, standard_lib=1)
203 return os.path.join(lib_dir, "config", "Makefile")
204
205
206 def parse_config_h(fp, g=None):
207 """Parse a config.h-style file.
208
209 A dictionary containing name/value pairs is returned. If an
210 optional dictionary is passed in as the second argument, it is
211 used instead of a new dictionary.
212 """
213 if g is None:
214 g = {}
215 define_rx = re.compile("#define ([A-Z][A-Z0-9_]+) (.*)\n")
216 undef_rx = re.compile("/[*] #undef ([A-Z][A-Z0-9_]+) [*]/\n")
217 #
218 while 1:
219 line = fp.readline()
220 if not line:
221 break
222 m = define_rx.match(line)
223 if m:
224 n, v = m.group(1, 2)
225 try: v = int(v)
226 except ValueError: pass
227 g[n] = v
228 else:
229 m = undef_rx.match(line)
230 if m:
231 g[m.group(1)] = 0
232 return g
233
234
235 # Regexes needed for parsing Makefile (and similar syntaxes,
236 # like old-style Setup files).
237 _variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
238 _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
239 _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
240
241 def parse_makefile(fn, g=None):
242 """Parse a Makefile-style file.
243
244 A dictionary containing name/value pairs is returned. If an
245 optional dictionary is passed in as the second argument, it is
246 used instead of a new dictionary.
247 """
248 from distutils.text_file import TextFile
249 fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1)
250
251 if g is None:
252 g = {}
253 done = {}
254 notdone = {}
255
256 while 1:
257 line = fp.readline()
258 if line is None: # eof
259 break
260 m = _variable_rx.match(line)
261 if m:
262 n, v = m.group(1, 2)
263 v = string.strip(v)
264 if "$" in v:
265 notdone[n] = v
266 else:
267 try: v = int(v)
268 except ValueError: pass
269 done[n] = v
270
271 # do variable interpolation here
272 while notdone:
273 for name in notdone.keys():
274 value = notdone[name]
275 m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
276 if m:
277 n = m.group(1)
278 if done.has_key(n):
279 after = value[m.end():]
280 value = value[:m.start()] + str(done[n]) + after
281 if "$" in after:
282 notdone[name] = value
283 else:
284 try: value = int(value)
285 except ValueError:
286 done[name] = string.strip(value)
287 else:
288 done[name] = value
289 del notdone[name]
290 elif notdone.has_key(n):
291 # get it on a subsequent round
292 pass
293 else:
294 done[n] = ""
295 after = value[m.end():]
296 value = value[:m.start()] + after
297 if "$" in after:
298 notdone[name] = value
299 else:
300 try: value = int(value)
301 except ValueError:
302 done[name] = string.strip(value)
303 else:
304 done[name] = value
305 del notdone[name]
306 else:
307 # bogus variable reference; just drop it since we can't deal
308 del notdone[name]
309
310 fp.close()
311
312 # save the results in the global dictionary
313 g.update(done)
314 return g
315
316
317 def expand_makefile_vars(s, vars):
318 """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
319 'string' according to 'vars' (a dictionary mapping variable names to
320 values). Variables not present in 'vars' are silently expanded to the
321 empty string. The variable values in 'vars' should not contain further
322 variable expansions; if 'vars' is the output of 'parse_makefile()',
323 you're fine. Returns a variable-expanded version of 's'.
324 """
325
326 # This algorithm does multiple expansion, so if vars['foo'] contains
327 # "${bar}", it will expand ${foo} to ${bar}, and then expand
328 # ${bar}... and so forth. This is fine as long as 'vars' comes from
329 # 'parse_makefile()', which takes care of such expansions eagerly,
330 # according to make's variable expansion semantics.
331
332 while 1:
333 m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
334 if m:
335 (beg, end) = m.span()
336 s = s[0:beg] + vars.get(m.group(1)) + s[end:]
337 else:
338 break
339 return s
340
341
342 _config_vars = None
343
344 def _init_posix():
345 """Initialize the module as appropriate for POSIX systems."""
346 g = {}
347 # load the installed Makefile:
348 try:
349 filename = get_makefile_filename()
350 parse_makefile(filename, g)
351 except IOError, msg:
352 my_msg = "invalid Python installation: unable to open %s" % filename
353 if hasattr(msg, "strerror"):
354 my_msg = my_msg + " (%s)" % msg.strerror
355
356 raise DistutilsPlatformError(my_msg)
357
358
359 # On AIX, there are wrong paths to the linker scripts in the Makefile
360 # -- these paths are relative to the Python source, but when installed
361 # the scripts are in another directory.
362 if python_build:
363 g['LDSHARED'] = g['BLDSHARED']
364
365 elif sys.version < '2.1':
366 # The following two branches are for 1.5.2 compatibility.
367 if sys.platform == 'aix4': # what about AIX 3.x ?
368 # Linker script is in the config directory, not in Modules as the
369 # Makefile says.
370 python_lib = get_python_lib(standard_lib=1)
371 ld_so_aix = os.path.join(python_lib, 'config', 'ld_so_aix')
372 python_exp = os.path.join(python_lib, 'config', 'python.exp')
373
374 g['LDSHARED'] = "%s %s -bI:%s" % (ld_so_aix, g['CC'], python_exp)
375
376 elif sys.platform == 'beos':
377 # Linker script is in the config directory. In the Makefile it is
378 # relative to the srcdir, which after installation no longer makes
379 # sense.
380 python_lib = get_python_lib(standard_lib=1)
381 linkerscript_path = string.split(g['LDSHARED'])[0]
382 linkerscript_name = os.path.basename(linkerscript_path)
383 linkerscript = os.path.join(python_lib, 'config',
384 linkerscript_name)
385
386 # XXX this isn't the right place to do this: adding the Python
387 # library to the link, if needed, should be in the "build_ext"
388 # command. (It's also needed for non-MS compilers on Windows, and
389 # it's taken care of for them by the 'build_ext.get_libraries()'
390 # method.)
391 g['LDSHARED'] = ("%s -L%s/lib -lpython%s" %
392 (linkerscript, PREFIX, sys.version[0:3]))
393
394 global _config_vars
395 _config_vars = g
396
397
398 def _init_nt():
399 """Initialize the module as appropriate for NT"""
400 g = {}
401 # set basic install directories
402 g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
403 g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
404
405 # XXX hmmm.. a normal install puts include files here
406 g['INCLUDEPY'] = get_python_inc(plat_specific=0)
407
408 g['SO'] = '.pyd'
409 g['EXE'] = ".exe"
410
411 global _config_vars
412 _config_vars = g
413
414
415 def _init_mac():
416 """Initialize the module as appropriate for Macintosh systems"""
417 g = {}
418 # set basic install directories
419 g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
420 g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
421
422 # XXX hmmm.. a normal install puts include files here
423 g['INCLUDEPY'] = get_python_inc(plat_specific=0)
424
425 import MacOS
426 if not hasattr(MacOS, 'runtimemodel'):
427 g['SO'] = '.ppc.slb'
428 else:
429 g['SO'] = '.%s.slb' % MacOS.runtimemodel
430
431 # XXX are these used anywhere?
432 g['install_lib'] = os.path.join(EXEC_PREFIX, "Lib")
433 g['install_platlib'] = os.path.join(EXEC_PREFIX, "Mac", "Lib")
434
435 # These are used by the extension module build
436 g['srcdir'] = ':'
437 global _config_vars
438 _config_vars = g
439
440
441 def _init_os2():
442 """Initialize the module as appropriate for OS/2"""
443 g = {}
444 # set basic install directories
445 g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
446 g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
447
448 # XXX hmmm.. a normal install puts include files here
449 g['INCLUDEPY'] = get_python_inc(plat_specific=0)
450
451 g['SO'] = '.pyd'
452 g['EXE'] = ".exe"
453
454 global _config_vars
455 _config_vars = g
456
457
458 def get_config_vars(*args):
459 """With no arguments, return a dictionary of all configuration
460 variables relevant for the current platform. Generally this includes
461 everything needed to build extensions and install both pure modules and
462 extensions. On Unix, this means every variable defined in Python's
463 installed Makefile; on Windows and Mac OS it's a much smaller set.
464
465 With arguments, return a list of values that result from looking up
466 each argument in the configuration variable dictionary.
467 """
468 global _config_vars
469 if _config_vars is None:
470 func = globals().get("_init_" + os.name)
471 if func:
472 func()
473 else:
474 _config_vars = {}
475
476 # Normalized versions of prefix and exec_prefix are handy to have;
477 # in fact, these are the standard versions used most places in the
478 # Distutils.
479 _config_vars['prefix'] = PREFIX
480 _config_vars['exec_prefix'] = EXEC_PREFIX
481
482 if args:
483 vals = []
484 for name in args:
485 vals.append(_config_vars.get(name))
486 return vals
487 else:
488 return _config_vars
489
490 def get_config_var(name):
491 """Return the value of a single variable using the dictionary
492 returned by 'get_config_vars()'. Equivalent to
493 get_config_vars().get(name)
494 """
495 return get_config_vars().get(name)