Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | """distutils.command.build_ext |
2 | ||
3 | Implements the Distutils 'build_ext' command, for building extension | |
4 | modules (currently limited to C extensions, should accommodate C++ | |
5 | extensions ASAP).""" | |
6 | ||
7 | # This module should be kept compatible with Python 2.1. | |
8 | ||
9 | __revision__ = "$Id: build_ext.py,v 1.98 2004/11/10 22:23:15 loewis Exp $" | |
10 | ||
11 | import sys, os, string, re | |
12 | from types import * | |
13 | from distutils.core import Command | |
14 | from distutils.errors import * | |
15 | from distutils.sysconfig import customize_compiler, get_python_version | |
16 | from distutils.dep_util import newer_group | |
17 | from distutils.extension import Extension | |
18 | from distutils import log | |
19 | ||
20 | # An extension name is just a dot-separated list of Python NAMEs (ie. | |
21 | # the same as a fully-qualified module name). | |
22 | extension_name_re = re.compile \ | |
23 | (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$') | |
24 | ||
25 | ||
26 | def show_compilers (): | |
27 | from distutils.ccompiler import show_compilers | |
28 | show_compilers() | |
29 | ||
30 | ||
31 | class build_ext (Command): | |
32 | ||
33 | description = "build C/C++ extensions (compile/link to build directory)" | |
34 | ||
35 | # XXX thoughts on how to deal with complex command-line options like | |
36 | # these, i.e. how to make it so fancy_getopt can suck them off the | |
37 | # command line and make it look like setup.py defined the appropriate | |
38 | # lists of tuples of what-have-you. | |
39 | # - each command needs a callback to process its command-line options | |
40 | # - Command.__init__() needs access to its share of the whole | |
41 | # command line (must ultimately come from | |
42 | # Distribution.parse_command_line()) | |
43 | # - it then calls the current command class' option-parsing | |
44 | # callback to deal with weird options like -D, which have to | |
45 | # parse the option text and churn out some custom data | |
46 | # structure | |
47 | # - that data structure (in this case, a list of 2-tuples) | |
48 | # will then be present in the command object by the time | |
49 | # we get to finalize_options() (i.e. the constructor | |
50 | # takes care of both command-line and client options | |
51 | # in between initialize_options() and finalize_options()) | |
52 | ||
53 | sep_by = " (separated by '%s')" % os.pathsep | |
54 | user_options = [ | |
55 | ('build-lib=', 'b', | |
56 | "directory for compiled extension modules"), | |
57 | ('build-temp=', 't', | |
58 | "directory for temporary files (build by-products)"), | |
59 | ('inplace', 'i', | |
60 | "ignore build-lib and put compiled extensions into the source " + | |
61 | "directory alongside your pure Python modules"), | |
62 | ('include-dirs=', 'I', | |
63 | "list of directories to search for header files" + sep_by), | |
64 | ('define=', 'D', | |
65 | "C preprocessor macros to define"), | |
66 | ('undef=', 'U', | |
67 | "C preprocessor macros to undefine"), | |
68 | ('libraries=', 'l', | |
69 | "external C libraries to link with"), | |
70 | ('library-dirs=', 'L', | |
71 | "directories to search for external C libraries" + sep_by), | |
72 | ('rpath=', 'R', | |
73 | "directories to search for shared C libraries at runtime"), | |
74 | ('link-objects=', 'O', | |
75 | "extra explicit link objects to include in the link"), | |
76 | ('debug', 'g', | |
77 | "compile/link with debugging information"), | |
78 | ('force', 'f', | |
79 | "forcibly build everything (ignore file timestamps)"), | |
80 | ('compiler=', 'c', | |
81 | "specify the compiler type"), | |
82 | ('swig-cpp', None, | |
83 | "make SWIG create C++ files (default is C)"), | |
84 | ('swig-opts=', None, | |
85 | "list of SWIG command line options"), | |
86 | ('swig=', None, | |
87 | "path to the SWIG executable"), | |
88 | ] | |
89 | ||
90 | boolean_options = ['inplace', 'debug', 'force', 'swig-cpp'] | |
91 | ||
92 | help_options = [ | |
93 | ('help-compiler', None, | |
94 | "list available compilers", show_compilers), | |
95 | ] | |
96 | ||
97 | def initialize_options (self): | |
98 | self.extensions = None | |
99 | self.build_lib = None | |
100 | self.build_temp = None | |
101 | self.inplace = 0 | |
102 | self.package = None | |
103 | ||
104 | self.include_dirs = None | |
105 | self.define = None | |
106 | self.undef = None | |
107 | self.libraries = None | |
108 | self.library_dirs = None | |
109 | self.rpath = None | |
110 | self.link_objects = None | |
111 | self.debug = None | |
112 | self.force = None | |
113 | self.compiler = None | |
114 | self.swig = None | |
115 | self.swig_cpp = None | |
116 | self.swig_opts = None | |
117 | ||
118 | def finalize_options (self): | |
119 | from distutils import sysconfig | |
120 | ||
121 | self.set_undefined_options('build', | |
122 | ('build_lib', 'build_lib'), | |
123 | ('build_temp', 'build_temp'), | |
124 | ('compiler', 'compiler'), | |
125 | ('debug', 'debug'), | |
126 | ('force', 'force')) | |
127 | ||
128 | if self.package is None: | |
129 | self.package = self.distribution.ext_package | |
130 | ||
131 | self.extensions = self.distribution.ext_modules | |
132 | ||
133 | ||
134 | # Make sure Python's include directories (for Python.h, pyconfig.h, | |
135 | # etc.) are in the include search path. | |
136 | py_include = sysconfig.get_python_inc() | |
137 | plat_py_include = sysconfig.get_python_inc(plat_specific=1) | |
138 | if self.include_dirs is None: | |
139 | self.include_dirs = self.distribution.include_dirs or [] | |
140 | if type(self.include_dirs) is StringType: | |
141 | self.include_dirs = string.split(self.include_dirs, os.pathsep) | |
142 | ||
143 | # Put the Python "system" include dir at the end, so that | |
144 | # any local include dirs take precedence. | |
145 | self.include_dirs.append(py_include) | |
146 | if plat_py_include != py_include: | |
147 | self.include_dirs.append(plat_py_include) | |
148 | ||
149 | if type(self.libraries) is StringType: | |
150 | self.libraries = [self.libraries] | |
151 | ||
152 | # Life is easier if we're not forever checking for None, so | |
153 | # simplify these options to empty lists if unset | |
154 | if self.libraries is None: | |
155 | self.libraries = [] | |
156 | if self.library_dirs is None: | |
157 | self.library_dirs = [] | |
158 | elif type(self.library_dirs) is StringType: | |
159 | self.library_dirs = string.split(self.library_dirs, os.pathsep) | |
160 | ||
161 | if self.rpath is None: | |
162 | self.rpath = [] | |
163 | elif type(self.rpath) is StringType: | |
164 | self.rpath = string.split(self.rpath, os.pathsep) | |
165 | ||
166 | # for extensions under windows use different directories | |
167 | # for Release and Debug builds. | |
168 | # also Python's library directory must be appended to library_dirs | |
169 | if os.name == 'nt': | |
170 | self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs')) | |
171 | if self.debug: | |
172 | self.build_temp = os.path.join(self.build_temp, "Debug") | |
173 | else: | |
174 | self.build_temp = os.path.join(self.build_temp, "Release") | |
175 | ||
176 | # Append the source distribution include and library directories, | |
177 | # this allows distutils on windows to work in the source tree | |
178 | self.include_dirs.append(os.path.join(sys.exec_prefix, 'PC')) | |
179 | self.library_dirs.append(os.path.join(sys.exec_prefix, 'PCBuild')) | |
180 | ||
181 | # OS/2 (EMX) doesn't support Debug vs Release builds, but has the | |
182 | # import libraries in its "Config" subdirectory | |
183 | if os.name == 'os2': | |
184 | self.library_dirs.append(os.path.join(sys.exec_prefix, 'Config')) | |
185 | ||
186 | # for extensions under Cygwin and AtheOS Python's library directory must be | |
187 | # appended to library_dirs | |
188 | if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos': | |
189 | if string.find(sys.executable, sys.exec_prefix) != -1: | |
190 | # building third party extensions | |
191 | self.library_dirs.append(os.path.join(sys.prefix, "lib", | |
192 | "python" + get_python_version(), | |
193 | "config")) | |
194 | else: | |
195 | # building python standard extensions | |
196 | self.library_dirs.append('.') | |
197 | ||
198 | # The argument parsing will result in self.define being a string, but | |
199 | # it has to be a list of 2-tuples. All the preprocessor symbols | |
200 | # specified by the 'define' option will be set to '1'. Multiple | |
201 | # symbols can be separated with commas. | |
202 | ||
203 | if self.define: | |
204 | defines = string.split(self.define, ',') | |
205 | self.define = map(lambda symbol: (symbol, '1'), defines) | |
206 | ||
207 | # The option for macros to undefine is also a string from the | |
208 | # option parsing, but has to be a list. Multiple symbols can also | |
209 | # be separated with commas here. | |
210 | if self.undef: | |
211 | self.undef = string.split(self.undef, ',') | |
212 | ||
213 | if self.swig_opts is None: | |
214 | self.swig_opts = [] | |
215 | else: | |
216 | self.swig_opts = self.swig_opts.split(' ') | |
217 | ||
218 | # finalize_options () | |
219 | ||
220 | ||
221 | def run (self): | |
222 | ||
223 | from distutils.ccompiler import new_compiler | |
224 | ||
225 | # 'self.extensions', as supplied by setup.py, is a list of | |
226 | # Extension instances. See the documentation for Extension (in | |
227 | # distutils.extension) for details. | |
228 | # | |
229 | # For backwards compatibility with Distutils 0.8.2 and earlier, we | |
230 | # also allow the 'extensions' list to be a list of tuples: | |
231 | # (ext_name, build_info) | |
232 | # where build_info is a dictionary containing everything that | |
233 | # Extension instances do except the name, with a few things being | |
234 | # differently named. We convert these 2-tuples to Extension | |
235 | # instances as needed. | |
236 | ||
237 | if not self.extensions: | |
238 | return | |
239 | ||
240 | # If we were asked to build any C/C++ libraries, make sure that the | |
241 | # directory where we put them is in the library search path for | |
242 | # linking extensions. | |
243 | if self.distribution.has_c_libraries(): | |
244 | build_clib = self.get_finalized_command('build_clib') | |
245 | self.libraries.extend(build_clib.get_library_names() or []) | |
246 | self.library_dirs.append(build_clib.build_clib) | |
247 | ||
248 | # Setup the CCompiler object that we'll use to do all the | |
249 | # compiling and linking | |
250 | self.compiler = new_compiler(compiler=self.compiler, | |
251 | verbose=self.verbose, | |
252 | dry_run=self.dry_run, | |
253 | force=self.force) | |
254 | customize_compiler(self.compiler) | |
255 | ||
256 | # And make sure that any compile/link-related options (which might | |
257 | # come from the command-line or from the setup script) are set in | |
258 | # that CCompiler object -- that way, they automatically apply to | |
259 | # all compiling and linking done here. | |
260 | if self.include_dirs is not None: | |
261 | self.compiler.set_include_dirs(self.include_dirs) | |
262 | if self.define is not None: | |
263 | # 'define' option is a list of (name,value) tuples | |
264 | for (name,value) in self.define: | |
265 | self.compiler.define_macro(name, value) | |
266 | if self.undef is not None: | |
267 | for macro in self.undef: | |
268 | self.compiler.undefine_macro(macro) | |
269 | if self.libraries is not None: | |
270 | self.compiler.set_libraries(self.libraries) | |
271 | if self.library_dirs is not None: | |
272 | self.compiler.set_library_dirs(self.library_dirs) | |
273 | if self.rpath is not None: | |
274 | self.compiler.set_runtime_library_dirs(self.rpath) | |
275 | if self.link_objects is not None: | |
276 | self.compiler.set_link_objects(self.link_objects) | |
277 | ||
278 | # Now actually compile and link everything. | |
279 | self.build_extensions() | |
280 | ||
281 | # run () | |
282 | ||
283 | ||
284 | def check_extensions_list (self, extensions): | |
285 | """Ensure that the list of extensions (presumably provided as a | |
286 | command option 'extensions') is valid, i.e. it is a list of | |
287 | Extension objects. We also support the old-style list of 2-tuples, | |
288 | where the tuples are (ext_name, build_info), which are converted to | |
289 | Extension instances here. | |
290 | ||
291 | Raise DistutilsSetupError if the structure is invalid anywhere; | |
292 | just returns otherwise. | |
293 | """ | |
294 | if type(extensions) is not ListType: | |
295 | raise DistutilsSetupError, \ | |
296 | "'ext_modules' option must be a list of Extension instances" | |
297 | ||
298 | for i in range(len(extensions)): | |
299 | ext = extensions[i] | |
300 | if isinstance(ext, Extension): | |
301 | continue # OK! (assume type-checking done | |
302 | # by Extension constructor) | |
303 | ||
304 | (ext_name, build_info) = ext | |
305 | log.warn(("old-style (ext_name, build_info) tuple found in " | |
306 | "ext_modules for extension '%s'" | |
307 | "-- please convert to Extension instance" % ext_name)) | |
308 | if type(ext) is not TupleType and len(ext) != 2: | |
309 | raise DistutilsSetupError, \ | |
310 | ("each element of 'ext_modules' option must be an " | |
311 | "Extension instance or 2-tuple") | |
312 | ||
313 | if not (type(ext_name) is StringType and | |
314 | extension_name_re.match(ext_name)): | |
315 | raise DistutilsSetupError, \ | |
316 | ("first element of each tuple in 'ext_modules' " | |
317 | "must be the extension name (a string)") | |
318 | ||
319 | if type(build_info) is not DictionaryType: | |
320 | raise DistutilsSetupError, \ | |
321 | ("second element of each tuple in 'ext_modules' " | |
322 | "must be a dictionary (build info)") | |
323 | ||
324 | # OK, the (ext_name, build_info) dict is type-safe: convert it | |
325 | # to an Extension instance. | |
326 | ext = Extension(ext_name, build_info['sources']) | |
327 | ||
328 | # Easy stuff: one-to-one mapping from dict elements to | |
329 | # instance attributes. | |
330 | for key in ('include_dirs', | |
331 | 'library_dirs', | |
332 | 'libraries', | |
333 | 'extra_objects', | |
334 | 'extra_compile_args', | |
335 | 'extra_link_args'): | |
336 | val = build_info.get(key) | |
337 | if val is not None: | |
338 | setattr(ext, key, val) | |
339 | ||
340 | # Medium-easy stuff: same syntax/semantics, different names. | |
341 | ext.runtime_library_dirs = build_info.get('rpath') | |
342 | if build_info.has_key('def_file'): | |
343 | log.warn("'def_file' element of build info dict " | |
344 | "no longer supported") | |
345 | ||
346 | # Non-trivial stuff: 'macros' split into 'define_macros' | |
347 | # and 'undef_macros'. | |
348 | macros = build_info.get('macros') | |
349 | if macros: | |
350 | ext.define_macros = [] | |
351 | ext.undef_macros = [] | |
352 | for macro in macros: | |
353 | if not (type(macro) is TupleType and | |
354 | 1 <= len(macro) <= 2): | |
355 | raise DistutilsSetupError, \ | |
356 | ("'macros' element of build info dict " | |
357 | "must be 1- or 2-tuple") | |
358 | if len(macro) == 1: | |
359 | ext.undef_macros.append(macro[0]) | |
360 | elif len(macro) == 2: | |
361 | ext.define_macros.append(macro) | |
362 | ||
363 | extensions[i] = ext | |
364 | ||
365 | # for extensions | |
366 | ||
367 | # check_extensions_list () | |
368 | ||
369 | ||
370 | def get_source_files (self): | |
371 | self.check_extensions_list(self.extensions) | |
372 | filenames = [] | |
373 | ||
374 | # Wouldn't it be neat if we knew the names of header files too... | |
375 | for ext in self.extensions: | |
376 | filenames.extend(ext.sources) | |
377 | ||
378 | return filenames | |
379 | ||
380 | ||
381 | def get_outputs (self): | |
382 | ||
383 | # Sanity check the 'extensions' list -- can't assume this is being | |
384 | # done in the same run as a 'build_extensions()' call (in fact, we | |
385 | # can probably assume that it *isn't*!). | |
386 | self.check_extensions_list(self.extensions) | |
387 | ||
388 | # And build the list of output (built) filenames. Note that this | |
389 | # ignores the 'inplace' flag, and assumes everything goes in the | |
390 | # "build" tree. | |
391 | outputs = [] | |
392 | for ext in self.extensions: | |
393 | fullname = self.get_ext_fullname(ext.name) | |
394 | outputs.append(os.path.join(self.build_lib, | |
395 | self.get_ext_filename(fullname))) | |
396 | return outputs | |
397 | ||
398 | # get_outputs () | |
399 | ||
400 | def build_extensions(self): | |
401 | # First, sanity-check the 'extensions' list | |
402 | self.check_extensions_list(self.extensions) | |
403 | ||
404 | for ext in self.extensions: | |
405 | self.build_extension(ext) | |
406 | ||
407 | def build_extension(self, ext): | |
408 | sources = ext.sources | |
409 | if sources is None or type(sources) not in (ListType, TupleType): | |
410 | raise DistutilsSetupError, \ | |
411 | ("in 'ext_modules' option (extension '%s'), " + | |
412 | "'sources' must be present and must be " + | |
413 | "a list of source filenames") % ext.name | |
414 | sources = list(sources) | |
415 | ||
416 | fullname = self.get_ext_fullname(ext.name) | |
417 | if self.inplace: | |
418 | # ignore build-lib -- put the compiled extension into | |
419 | # the source tree along with pure Python modules | |
420 | ||
421 | modpath = string.split(fullname, '.') | |
422 | package = string.join(modpath[0:-1], '.') | |
423 | base = modpath[-1] | |
424 | ||
425 | build_py = self.get_finalized_command('build_py') | |
426 | package_dir = build_py.get_package_dir(package) | |
427 | ext_filename = os.path.join(package_dir, | |
428 | self.get_ext_filename(base)) | |
429 | else: | |
430 | ext_filename = os.path.join(self.build_lib, | |
431 | self.get_ext_filename(fullname)) | |
432 | depends = sources + ext.depends | |
433 | if not (self.force or newer_group(depends, ext_filename, 'newer')): | |
434 | log.debug("skipping '%s' extension (up-to-date)", ext.name) | |
435 | return | |
436 | else: | |
437 | log.info("building '%s' extension", ext.name) | |
438 | ||
439 | # First, scan the sources for SWIG definition files (.i), run | |
440 | # SWIG on 'em to create .c files, and modify the sources list | |
441 | # accordingly. | |
442 | sources = self.swig_sources(sources, ext) | |
443 | ||
444 | # Next, compile the source code to object files. | |
445 | ||
446 | # XXX not honouring 'define_macros' or 'undef_macros' -- the | |
447 | # CCompiler API needs to change to accommodate this, and I | |
448 | # want to do one thing at a time! | |
449 | ||
450 | # Two possible sources for extra compiler arguments: | |
451 | # - 'extra_compile_args' in Extension object | |
452 | # - CFLAGS environment variable (not particularly | |
453 | # elegant, but people seem to expect it and I | |
454 | # guess it's useful) | |
455 | # The environment variable should take precedence, and | |
456 | # any sensible compiler will give precedence to later | |
457 | # command line args. Hence we combine them in order: | |
458 | extra_args = ext.extra_compile_args or [] | |
459 | ||
460 | macros = ext.define_macros[:] | |
461 | for undef in ext.undef_macros: | |
462 | macros.append((undef,)) | |
463 | ||
464 | objects = self.compiler.compile(sources, | |
465 | output_dir=self.build_temp, | |
466 | macros=macros, | |
467 | include_dirs=ext.include_dirs, | |
468 | debug=self.debug, | |
469 | extra_postargs=extra_args, | |
470 | depends=ext.depends) | |
471 | ||
472 | # XXX -- this is a Vile HACK! | |
473 | # | |
474 | # The setup.py script for Python on Unix needs to be able to | |
475 | # get this list so it can perform all the clean up needed to | |
476 | # avoid keeping object files around when cleaning out a failed | |
477 | # build of an extension module. Since Distutils does not | |
478 | # track dependencies, we have to get rid of intermediates to | |
479 | # ensure all the intermediates will be properly re-built. | |
480 | # | |
481 | self._built_objects = objects[:] | |
482 | ||
483 | # Now link the object files together into a "shared object" -- | |
484 | # of course, first we have to figure out all the other things | |
485 | # that go into the mix. | |
486 | if ext.extra_objects: | |
487 | objects.extend(ext.extra_objects) | |
488 | extra_args = ext.extra_link_args or [] | |
489 | ||
490 | # Detect target language, if not provided | |
491 | language = ext.language or self.compiler.detect_language(sources) | |
492 | ||
493 | self.compiler.link_shared_object( | |
494 | objects, ext_filename, | |
495 | libraries=self.get_libraries(ext), | |
496 | library_dirs=ext.library_dirs, | |
497 | runtime_library_dirs=ext.runtime_library_dirs, | |
498 | extra_postargs=extra_args, | |
499 | export_symbols=self.get_export_symbols(ext), | |
500 | debug=self.debug, | |
501 | build_temp=self.build_temp, | |
502 | target_lang=language) | |
503 | ||
504 | ||
505 | def swig_sources (self, sources, extension): | |
506 | ||
507 | """Walk the list of source files in 'sources', looking for SWIG | |
508 | interface (.i) files. Run SWIG on all that are found, and | |
509 | return a modified 'sources' list with SWIG source files replaced | |
510 | by the generated C (or C++) files. | |
511 | """ | |
512 | ||
513 | new_sources = [] | |
514 | swig_sources = [] | |
515 | swig_targets = {} | |
516 | ||
517 | # XXX this drops generated C/C++ files into the source tree, which | |
518 | # is fine for developers who want to distribute the generated | |
519 | # source -- but there should be an option to put SWIG output in | |
520 | # the temp dir. | |
521 | ||
522 | if self.swig_cpp: | |
523 | log.warn("--swig-cpp is deprecated - use --swig-opts=-c++") | |
524 | ||
525 | if self.swig_cpp or ('-c++' in self.swig_opts): | |
526 | target_ext = '.cpp' | |
527 | else: | |
528 | target_ext = '.c' | |
529 | ||
530 | for source in sources: | |
531 | (base, ext) = os.path.splitext(source) | |
532 | if ext == ".i": # SWIG interface file | |
533 | new_sources.append(base + '_wrap' + target_ext) | |
534 | swig_sources.append(source) | |
535 | swig_targets[source] = new_sources[-1] | |
536 | else: | |
537 | new_sources.append(source) | |
538 | ||
539 | if not swig_sources: | |
540 | return new_sources | |
541 | ||
542 | swig = self.swig or self.find_swig() | |
543 | swig_cmd = [swig, "-python"] | |
544 | swig_cmd.extend(self.swig_opts) | |
545 | if self.swig_cpp: | |
546 | swig_cmd.append("-c++") | |
547 | ||
548 | # Do not override commandline arguments | |
549 | if not self.swig_opts: | |
550 | for o in extension.swig_opts: | |
551 | swig_cmd.append(o) | |
552 | ||
553 | for source in swig_sources: | |
554 | target = swig_targets[source] | |
555 | log.info("swigging %s to %s", source, target) | |
556 | self.spawn(swig_cmd + ["-o", target, source]) | |
557 | ||
558 | return new_sources | |
559 | ||
560 | # swig_sources () | |
561 | ||
562 | def find_swig (self): | |
563 | """Return the name of the SWIG executable. On Unix, this is | |
564 | just "swig" -- it should be in the PATH. Tries a bit harder on | |
565 | Windows. | |
566 | """ | |
567 | ||
568 | if os.name == "posix": | |
569 | return "swig" | |
570 | elif os.name == "nt": | |
571 | ||
572 | # Look for SWIG in its standard installation directory on | |
573 | # Windows (or so I presume!). If we find it there, great; | |
574 | # if not, act like Unix and assume it's in the PATH. | |
575 | for vers in ("1.3", "1.2", "1.1"): | |
576 | fn = os.path.join("c:\\swig%s" % vers, "swig.exe") | |
577 | if os.path.isfile(fn): | |
578 | return fn | |
579 | else: | |
580 | return "swig.exe" | |
581 | ||
582 | elif os.name == "os2": | |
583 | # assume swig available in the PATH. | |
584 | return "swig.exe" | |
585 | ||
586 | else: | |
587 | raise DistutilsPlatformError, \ | |
588 | ("I don't know how to find (much less run) SWIG " | |
589 | "on platform '%s'") % os.name | |
590 | ||
591 | # find_swig () | |
592 | ||
593 | # -- Name generators ----------------------------------------------- | |
594 | # (extension names, filenames, whatever) | |
595 | ||
596 | def get_ext_fullname (self, ext_name): | |
597 | if self.package is None: | |
598 | return ext_name | |
599 | else: | |
600 | return self.package + '.' + ext_name | |
601 | ||
602 | def get_ext_filename (self, ext_name): | |
603 | r"""Convert the name of an extension (eg. "foo.bar") into the name | |
604 | of the file from which it will be loaded (eg. "foo/bar.so", or | |
605 | "foo\bar.pyd"). | |
606 | """ | |
607 | ||
608 | from distutils.sysconfig import get_config_var | |
609 | ext_path = string.split(ext_name, '.') | |
610 | # OS/2 has an 8 character module (extension) limit :-( | |
611 | if os.name == "os2": | |
612 | ext_path[len(ext_path) - 1] = ext_path[len(ext_path) - 1][:8] | |
613 | # extensions in debug_mode are named 'module_d.pyd' under windows | |
614 | so_ext = get_config_var('SO') | |
615 | if os.name == 'nt' and self.debug: | |
616 | return apply(os.path.join, ext_path) + '_d' + so_ext | |
617 | return apply(os.path.join, ext_path) + so_ext | |
618 | ||
619 | def get_export_symbols (self, ext): | |
620 | """Return the list of symbols that a shared extension has to | |
621 | export. This either uses 'ext.export_symbols' or, if it's not | |
622 | provided, "init" + module_name. Only relevant on Windows, where | |
623 | the .pyd file (DLL) must export the module "init" function. | |
624 | """ | |
625 | ||
626 | initfunc_name = "init" + string.split(ext.name,'.')[-1] | |
627 | if initfunc_name not in ext.export_symbols: | |
628 | ext.export_symbols.append(initfunc_name) | |
629 | return ext.export_symbols | |
630 | ||
631 | def get_libraries (self, ext): | |
632 | """Return the list of libraries to link against when building a | |
633 | shared extension. On most platforms, this is just 'ext.libraries'; | |
634 | on Windows and OS/2, we add the Python library (eg. python20.dll). | |
635 | """ | |
636 | # The python library is always needed on Windows. For MSVC, this | |
637 | # is redundant, since the library is mentioned in a pragma in | |
638 | # pyconfig.h that MSVC groks. The other Windows compilers all seem | |
639 | # to need it mentioned explicitly, though, so that's what we do. | |
640 | # Append '_d' to the python import library on debug builds. | |
641 | if sys.platform == "win32": | |
642 | from distutils.msvccompiler import MSVCCompiler | |
643 | if not isinstance(self.compiler, MSVCCompiler): | |
644 | template = "python%d%d" | |
645 | if self.debug: | |
646 | template = template + '_d' | |
647 | pythonlib = (template % | |
648 | (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) | |
649 | # don't extend ext.libraries, it may be shared with other | |
650 | # extensions, it is a reference to the original list | |
651 | return ext.libraries + [pythonlib] | |
652 | else: | |
653 | return ext.libraries | |
654 | elif sys.platform == "os2emx": | |
655 | # EMX/GCC requires the python library explicitly, and I | |
656 | # believe VACPP does as well (though not confirmed) - AIM Apr01 | |
657 | template = "python%d%d" | |
658 | # debug versions of the main DLL aren't supported, at least | |
659 | # not at this time - AIM Apr01 | |
660 | #if self.debug: | |
661 | # template = template + '_d' | |
662 | pythonlib = (template % | |
663 | (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) | |
664 | # don't extend ext.libraries, it may be shared with other | |
665 | # extensions, it is a reference to the original list | |
666 | return ext.libraries + [pythonlib] | |
667 | elif sys.platform[:6] == "cygwin": | |
668 | template = "python%d.%d" | |
669 | pythonlib = (template % | |
670 | (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) | |
671 | # don't extend ext.libraries, it may be shared with other | |
672 | # extensions, it is a reference to the original list | |
673 | return ext.libraries + [pythonlib] | |
674 | elif sys.platform[:6] == "atheos": | |
675 | from distutils import sysconfig | |
676 | ||
677 | template = "python%d.%d" | |
678 | pythonlib = (template % | |
679 | (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) | |
680 | # Get SHLIBS from Makefile | |
681 | extra = [] | |
682 | for lib in sysconfig.get_config_var('SHLIBS').split(): | |
683 | if lib.startswith('-l'): | |
684 | extra.append(lib[2:]) | |
685 | else: | |
686 | extra.append(lib) | |
687 | # don't extend ext.libraries, it may be shared with other | |
688 | # extensions, it is a reference to the original list | |
689 | return ext.libraries + [pythonlib, "m"] + extra | |
690 | else: | |
691 | return ext.libraries | |
692 | ||
693 | # class build_ext |