Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""
__revision__
= "$Id: extension.py,v 1.19 2004/10/14 10:02:08 anthonybaxter Exp $"
# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext. However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
"""Just a collection of attributes that describes an extension
module and everything needed to build it (hopefully in a portable
way, but there are hooks that let you be as unportable as you need).
the full name of the extension, including any packages -- ie.
*not* a filename or pathname, but Python dotted name
list of source filenames, relative to the distribution root
(where the setup script lives), in Unix form (slash-separated)
for portability. Source files may be C, C++, SWIG (.i),
platform-specific resource files, or whatever else is recognized
by the "build_ext" command as source for a Python extension.
list of directories to search for C/C++ header files (in Unix
define_macros : [(name : string, value : string|None)]
list of macros to define; each macro is defined using a 2-tuple,
where 'value' is either the string to define it to or None to
define it without a particular value (equivalent of "#define
FOO" in source or -DFOO on Unix C compiler command line)
list of macros to undefine explicitly
list of directories to search for C/C++ libraries at link time
list of library names (not filenames or paths) to link against
runtime_library_dirs : [string]
list of directories to search for C/C++ libraries at run time
(for shared extensions, this is when the extension is loaded)
list of extra files to link with (eg. object files not implied
by 'sources', static library that must be explicitly specified,
binary resource files, etc.)
extra_compile_args : [string]
any extra platform- and compiler-specific information to use
when compiling the source files in 'sources'. For platforms and
compilers where "command line" makes sense, this is typically a
list of command-line arguments, but for other platforms it could
extra_link_args : [string]
any extra platform- and compiler-specific information to use
when linking object files together to create the extension (or
to create a new static Python interpreter). Similar
interpretation as for 'extra_compile_args'.
export_symbols : [string]
list of symbols to be exported from a shared extension. Not
used on all platforms, and not generally necessary for Python
extensions, which typically export exactly one symbol: "init" +
any extra options to pass to SWIG if a source file has the .i
list of files that the extension depends on
extension language (i.e. "c", "c++", "objc"). Will be detected
from the source extensions if not provided.
# When adding arguments to this constructor, be sure to update
# setup_keywords in core.py.
def __init__ (self
, name
, sources
,
runtime_library_dirs
=None,
**kw
# To catch unknown keywords
assert type(name
) is StringType
, "'name' must be a string"
assert (type(sources
) is ListType
and
map(type, sources
) == [StringType
]*len(sources
)), \
"'sources' must be a list of strings"
self
.include_dirs
= include_dirs
or []
self
.define_macros
= define_macros
or []
self
.undef_macros
= undef_macros
or []
self
.library_dirs
= library_dirs
or []
self
.libraries
= libraries
or []
self
.runtime_library_dirs
= runtime_library_dirs
or []
self
.extra_objects
= extra_objects
or []
self
.extra_compile_args
= extra_compile_args
or []
self
.extra_link_args
= extra_link_args
or []
self
.export_symbols
= export_symbols
or []
self
.swig_opts
= swig_opts
or []
self
.depends
= depends
or []
# If there are unknown keyword options, warn about them
msg
= "Unknown Extension options: " + string
.join(L
, ', ')
sys
.stderr
.write(msg
+ '\n')
def read_setup_file (filename
):
from distutils
.sysconfig
import \
parse_makefile
, expand_makefile_vars
, _variable_rx
from distutils
.text_file
import TextFile
from distutils
.util
import split_quoted
# First pass over the file to gather "VAR = VALUE" assignments.
vars = parse_makefile(filename
)
# Second pass to gobble up the real content: lines of the form
# <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
file = TextFile(filename
,
strip_comments
=1, skip_blanks
=1, join_lines
=1,
lstrip_ws
=1, rstrip_ws
=1)
if _variable_rx
.match(line
): # VAR=VALUE, handled in first pass
if line
[0] == line
[-1] == "*":
file.warn("'%s' lines not handled yet" % line
)
#print "original line: " + line
line
= expand_makefile_vars(line
, vars)
words
= split_quoted(line
)
#print "expanded line: " + line
# NB. this parses a slightly different syntax than the old
# makesetup script: here, there must be exactly one extension per
# line, and it must be the first word of the line. I have no idea
# why the old syntax supported multiple extensions per line, as
# they all wind up being the same.
ext
= Extension(module
, [])
if append_next_word
is not None:
append_next_word
.append(word
)
suffix
= os
.path
.splitext(word
)[1]
switch
= word
[0:2] ; value
= word
[2:]
if suffix
in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
# hmm, should we do something about C vs. C++ sources?
# or leave it up to the CCompiler implementation to
ext
.include_dirs
.append(value
)
equals
= string
.find(value
, "=")
if equals
== -1: # bare "-DFOO" -- no value
ext
.define_macros
.append((value
, None))
ext
.define_macros
.append((value
[0:equals
],
ext
.undef_macros
.append(value
)
elif switch
== "-C": # only here 'cause makesetup has it!
ext
.extra_compile_args
.append(word
)
ext
.libraries
.append(value
)
ext
.library_dirs
.append(value
)
ext
.runtime_library_dirs
.append(value
)
append_next_word
= ext
.runtime_library_dirs
append_next_word
= ext
.extra_link_args
elif word
== "-Xcompiler":
append_next_word
= ext
.extra_compile_args
ext
.extra_link_args
.append(word
)
append_next_word
= ext
.extra_link_args
elif suffix
in (".a", ".so", ".sl", ".o", ".dylib"):
# NB. a really faithful emulation of makesetup would
# append a .o file to extra_objects only if it
# had a slash in it; otherwise, it would s/.o/.c/
# and append it to sources. Hmmmm.
ext
.extra_objects
.append(word
)
file.warn("unrecognized argument '%s'" % word
)
#print "source files:", source_files
#print "cpp args:", cpp_args
#print "lib args:", library_args
#extensions[module] = { 'sources': source_files,
# 'lib_args': library_args }