cpython/Lib/distutils/cygwinccompiler.py

200 lines
7.0 KiB
Python

"""distutils.cygwinccompiler
Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
handles the Cygwin port of the GNU C compiler to Windows. It also contains
the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
cygwin in no-cygwin mode).
"""
# created 2000/05/05, Rene Liebscher
__revision__ = "$Id$"
import os,sys,string
from distutils import sysconfig
from distutils.unixccompiler import UnixCCompiler
# Because these compilers aren't configured in Python's config.h file by
# default we should at least warn the user if he is using a unmodified
# version.
def check_config_h():
"""Checks if the GCC compiler is mentioned in config.h. If it is not,
compiling probably doesn't work, so print a warning to stderr.
"""
# XXX the result of the check should be returned!
from distutils import sysconfig
import string,sys
try:
# It would probably better to read single lines to search.
# But we do this only once, and it is fast enough
f=open(sysconfig.get_config_h_filename())
s=f.read()
f.close()
try:
# is somewhere a #ifdef __GNUC__ or something similar
string.index(s,"__GNUC__")
except ValueError:
sys.stderr.write ("warning: "+
"Python's config.h doesn't seem to support your compiler.\n")
except IOError:
# if we can't read this file, we cannot say it is wrong
# the compiler will complain later about this file as missing
pass
# This is called when the module is imported, so we make this check only once
# XXX why not make it only when the compiler is needed?
check_config_h()
class CygwinCCompiler (UnixCCompiler):
compiler_type = 'cygwin'
def __init__ (self,
verbose=0,
dry_run=0,
force=0):
UnixCCompiler.__init__ (self, verbose, dry_run, force)
# Hard-code GCC because that's what this is all about.
# XXX optimization, warnings etc. should be customizable.
self.set_executables(compiler='gcc -O -Wall',
compiler_so='gcc -O -Wall',
linker_exe='gcc',
linker_so='dllwrap --target=i386-cygwin32')
# cygwin and mingw32 need different sets of libraries
self.dll_libraries=[
# cygwin shouldn't need msvcrt,
# but without the dll's will crash
# ( gcc version 2.91.57 )
# perhaps something about initialization
# mingw32 needs it in all cases
"msvcrt"
]
# __init__ ()
def link_shared_object (self,
objects,
output_filename,
output_dir=None,
libraries=None,
library_dirs=None,
runtime_library_dirs=None,
export_symbols=None,
debug=0,
extra_preargs=None,
extra_postargs=None,
build_temp=None):
if libraries == None:
libraries = []
# Additional libraries: the python library is always needed on
# Windows we need the python version without the dot, eg. '15'
pythonlib = ("python%d%d" %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
libraries.append(pythonlib)
libraries.extend(self.dll_libraries)
# name of extension
# XXX WRONG WRONG WRONG
# this is NOT the place to make guesses about Python namespaces;
# that MUST be done in build_ext.py
if not debug:
ext_name = os.path.basename(output_filename)[:-len(".pyd")]
else:
ext_name = os.path.basename(output_filename)[:-len("_d.pyd")]
def_file = os.path.join(build_temp, ext_name + ".def")
#exp_file = os.path.join(build_temp, ext_name + ".exp")
#lib_file = os.path.join(build_temp, 'lib' + ext_name + ".a")
# Make .def file
# (It would probably better to check if we really need this,
# but for this we had to insert some unchanged parts of
# UnixCCompiler, and this is not what we want.)
f = open(def_file,"w")
f.write("EXPORTS\n") # intro
if export_symbols == None:
# export a function "init" + ext_name
f.write("init" + ext_name + "\n")
else:
# if there are more symbols to export write them into f
for sym in export_symbols:
f.write(sym+"\n")
f.close()
if extra_preargs == None:
extra_preargs = []
extra_preargs = extra_preargs + [
#"--verbose",
#"--output-exp",exp_file,
#"--output-lib",lib_file,
"--def",def_file
]
# who wants symbols and a many times larger output file
# should explicitly switch the debug mode on
# otherwise we let dllwrap strip the output file
# (On my machine unstripped_file = stripped_file + 254KB
# 10KB < stripped_file < ??100KB )
if not debug:
extra_preargs = extra_preargs + ["-s"]
UnixCCompiler.link_shared_object(self,
objects,
output_filename,
output_dir,
libraries,
library_dirs,
runtime_library_dirs,
None, # export_symbols, we do this with our def-file
debug,
extra_preargs,
extra_postargs,
build_temp)
# link_shared_object ()
# class CygwinCCompiler
# the same as cygwin plus some additional parameters
class Mingw32CCompiler (CygwinCCompiler):
compiler_type = 'mingw32'
def __init__ (self,
verbose=0,
dry_run=0,
force=0):
CygwinCCompiler.__init__ (self, verbose, dry_run, force)
self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
compiler_so='gcc -mno-cygwin -O -Wall',
linker_exe='gcc -mno-cygwin',
linker_so='dllwrap'
+ ' --target=i386-mingw32'
+ ' --entry _DllMain@12')
# mingw32 doesn't really need 'target' and cygwin too (it seems,
# it is enough to specify a different entry point)
# no additional libraries need
# (only msvcrt, which is already added by CygwinCCompiler)
# __init__ ()
# class Mingw32CCompiler