Whenever possible, the Distutils try to use the configuration information made available by the Python interpreter used to run the setup.py script. For example, the same compiler and linker flags used to compile Python will also be used for compiling extensions. Usually this will work well, but in complicated situations this might be inappropriate. This section discusses how to override the usual Distutils behaviour.
Compiling a Python extension written in C or C++ will sometimes require specifying custom flags for the compiler and linker in order to use a particular library or produce a special kind of object code. This is especially true if the extension hasn't been tested on your platform, or if you're trying to cross-compile Python.
In the most general case, the extension author might have foreseen that compiling the extensions would be complicated, and provided a Setup file for you to edit. This will likely only be done if the module distribution contains many separate extension modules, or if they often require elaborate sets of compiler flags in order to work.
A Setup file, if present, is parsed in order to get a list of extensions to build. Each line in a Setup describes a single module. Lines have the following structure:
module ... [sourcefile ...] [cpparg ...] [library ...]
Let's examine each of the fields in turn.
If a particular platform requires a special library on your platform,
you can add it by editing the Setup file and running
python setup.py build. For example, if the module defined by the line
must be linked with the math library libm.a on your platform, simply add -lm to the line:
foo foomodule.c -lm
Arbitrary switches intended for the compiler or the linker can be supplied with the -Xcompiler arg and -Xlinker arg options:
foo foomodule.c -Xcompiler -o32 -Xlinker -shared -lm
The next option after -Xcompiler and
-Xlinker will be appended to the proper command line, so
in the above example the compiler will be passed the -o32
option, and the linker will be passed -shared. If a
compiler option requires an argument, you'll have to supply multiple
-Xcompiler options; for example, to pass
-x c++ the
Setup file would have to contain
-Xcompiler -x -Xcompiler c++.
Compiler flags can also be supplied through setting the CFLAGS environment variable. If set, the contents of CFLAGS will be added to the compiler flags specified in the Setup file.
This subsection describes the necessary steps to use Distutils with the Borland C++ compiler version 5.5.
First you have to know that Borland's object file format (OMF) is different from the format used by the Python version you can download from the Python or ActiveState Web site. (Python is built with Microsoft Visual C++, which uses COFF as the object file format.) For this reason you have to convert Python's library python25.lib into the Borland format. You can do this as follows:
coff2omf python25.lib python25_bcpp.lib
The coff2omf program comes with the Borland compiler. The file python25.lib is in the Libs directory of your Python installation. If your extension uses other libraries (zlib,...) you have to convert them too.
The converted files have to reside in the same directories as the normal libraries.
How does Distutils manage to use these libraries with their changed names? If the extension needs a library (eg. foo) Distutils checks first if it finds a library with suffix _bcpp (eg. foo_bcpp.lib) and then uses this library. In the case it doesn't find such a special library it uses the default name (foo.lib.)1
To let Distutils compile your extension with Borland C++ you now have to type:
python setup.py build --compiler=bcpp
If you want to use the Borland C++ compiler as the default, you could specify this in your personal or system-wide configuration file for Distutils (see section 5.)
These instructions only apply if you're using a version of Python prior to 2.4.1 with a MinGW prior to 3.0.0 (with binutils-2.13.90-20030111-1).
This section describes the necessary steps to use Distutils with the GNU C/C++ compilers in their Cygwin and MinGW distributions.2 For a Python interpreter that was built with Cygwin, everything should work without any of these following steps.
These compilers require some special libraries. This task is more complex than for Borland's C++, because there is no program to convert the library.
First you have to create a list of symbols which the Python DLL exports. (You can find a good program for this task at http://starship.python.net/crew/kernr/mingw32/Notes.html, see at PExports 0.42h there.)
pexports python25.dll >python25.def
The location of an installed python25.dll will depend on the installation options and the version and language of Windows. In a ``just for me'' installation, it will appear in the root of the installation directory. In a shared installation, it will be located in the system directory.
Then you can create from these information an import library for gcc.
/cygwin/bin/dlltool --dllname python25.dll --def python25.def --output-lib libpython25.a
The resulting library has to be placed in the same directory as python25.lib. (Should be the libs directory under your Python installation directory.)
If your extension uses other libraries (zlib,...) you might have to convert them too. The converted files have to reside in the same directories as the normal libraries do.
To let Distutils compile your extension with Cygwin you now have to type
python setup.py build --compiler=cygwin
and for Cygwin in no-cygwin mode3 or for MinGW type:
python setup.py build --compiler=mingw32
If you want to use any of these options/compilers as default, you should consider to write it in your personal or system-wide configuration file for Distutils (see section 5.)