[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / lib / python2.4 / distutils / cygwinccompiler.py

"""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).
"""

# problems:
#
# * if you use a msvc compiled python version (1.5.2)
#   1. you have to insert a __GNUC__ section in its config.h
#   2. you have to generate a import library for its dll
#      - create a def-file for python??.dll
#      - create a import library using
#             dlltool --dllname python15.dll --def python15.def \
#                       --output-lib libpython15.a
#
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
#
# * We put export_symbols in a def-file, and don't use
#   --export-all-symbols because it doesn't worked reliable in some
#   tested configurations. And because other windows compilers also
#   need their symbols specified this no serious problem.
#
# tested configurations:
#
# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
#   (after patching python's config.h and for C++ some other include files)
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
#   (ld doesn't support -shared, so we use dllwrap)
# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
#   - using gcc -mdll instead dllwrap doesn't work without -static because
#     it tries to link against dlls instead their import libraries. (If
#     it finds the dll first.)
#     By specifying -static we force ld to link against the import libraries,
#     this is windows standard and there are normally not the necessary symbols
#     in the dlls.
#   *** only the version of June 2000 shows these problems
# * cygwin gcc 3.2/ld 2.13.90 works
#   (ld supports -shared)
# * mingw gcc 3.2/ld 2.13 works
#   (ld supports -shared)

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id: cygwinccompiler.py,v 1.29 2004/11/10 22:23:14 loewis Exp $"

import os,sys,copy
from distutils.ccompiler import gen_preprocess_options, gen_lib_options
from distutils.unixccompiler import UnixCCompiler
from distutils.file_util import write_file
from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
from distutils import log

class CygwinCCompiler (UnixCCompiler):

    compiler_type = 'cygwin'
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".dll"
    static_lib_format = "lib%s%s"
    shared_lib_format = "%s%s"
    exe_extension = ".exe"

    def __init__ (self, verbose=0, dry_run=0, force=0):

        UnixCCompiler.__init__ (self, verbose, dry_run, force)

        (status, details) = check_config_h()
        self.debug_print("Python's GCC status: %s (details: %s)" %
                         (status, details))
        if status is not CONFIG_H_OK:
            self.warn(
                "Python's pyconfig.h doesn't seem to support your compiler. "
                "Reason: %s. "
                "Compiling may fail because of undefined preprocessor macros."
                % details)

        self.gcc_version, self.ld_version, self.dllwrap_version = \
            get_versions()
        self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
                         (self.gcc_version,
                          self.ld_version,
                          self.dllwrap_version) )

        # ld_version >= "2.10.90" and < "2.13" should also be able to use
        # gcc -mdll instead of dllwrap
        # Older dllwraps had own version numbers, newer ones use the
        # same as the rest of binutils ( also ld )
        # dllwrap 2.10.90 is buggy
        if self.ld_version >= "2.10.90":
            self.linker_dll = "gcc"
        else:
            self.linker_dll = "dllwrap"

        # ld_version >= "2.13" support -shared so use it instead of
        # -mdll -static
        if self.ld_version >= "2.13":
            shared_option = "-shared"
        else:
            shared_option = "-mdll -static"

        # Hard-code GCC because that's what this is all about.
        # XXX optimization, warnings etc. should be customizable.
        self.set_executables(compiler='gcc -mcygwin -O -Wall',
                             compiler_so='gcc -mcygwin -mdll -O -Wall',
                             compiler_cxx='g++ -mcygwin -O -Wall',
                             linker_exe='gcc -mcygwin',
                             linker_so=('%s -mcygwin %s' %
                                        (self.linker_dll, shared_option)))

        # cygwin and mingw32 need different sets of libraries
        if self.gcc_version == "2.91.57":
            # cygwin shouldn't need msvcrt, but without the dlls will crash
            # (gcc version 2.91.57) -- perhaps something about initialization
            self.dll_libraries=["msvcrt"]
            self.warn(
                "Consider upgrading to a newer version of gcc")
        else:
            self.dll_libraries=[]
            # Include the appropriate MSVC runtime library if Python was built
            # with MSVC 7.0 or 7.1.
            msc_pos = sys.version.find('MSC v.')
            if msc_pos != -1:
                msc_ver = sys.version[msc_pos+6:msc_pos+10]
                if msc_ver == '1300':
                    # MSVC 7.0
                    self.dll_libraries = ['msvcr70']
                elif msc_ver == '1310':
                    # MSVC 7.1
                    self.dll_libraries = ['msvcr71']

    # __init__ ()


    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        if ext == '.rc' or ext == '.res':
            # gcc needs '.res' and '.rc' compiled to object files !!!
            try:
                self.spawn(["windres", "-i", src, "-o", obj])
            except DistutilsExecError, msg:
                raise CompileError, msg
        else: # for other files use the C-compiler
            try:
                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                           extra_postargs)
            except DistutilsExecError, msg:
                raise CompileError, msg

    def link (self,
              target_desc,
              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,
              target_lang=None):

        # use separate copies, so we can modify the lists
        extra_preargs = copy.copy(extra_preargs or [])
        libraries = copy.copy(libraries or [])
        objects = copy.copy(objects or [])

        # Additional libraries
        libraries.extend(self.dll_libraries)

        # handle export symbols by creating a def-file
        # with executables this only works with gcc/ld as linker
        if ((export_symbols is not None) and
            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
            # (The linker doesn't do anything if output is up-to-date.
            # So 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.)

            # we want to put some files in the same directory as the
            # object files are, build_temp doesn't help much
            # where are the object files
            temp_dir = os.path.dirname(objects[0])
            # name of dll to give the helper files the same base name
            (dll_name, dll_extension) = os.path.splitext(
                os.path.basename(output_filename))

            # generate the filenames for these files
            def_file = os.path.join(temp_dir, dll_name + ".def")
            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")

            # Generate .def file
            contents = [
                "LIBRARY %s" % os.path.basename(output_filename),
                "EXPORTS"]
            for sym in export_symbols:
                contents.append(sym)
            self.execute(write_file, (def_file, contents),
                         "writing %s" % def_file)

            # next add options for def-file and to creating import libraries

            # dllwrap uses different options than gcc/ld
            if self.linker_dll == "dllwrap":
                extra_preargs.extend(["--output-lib", lib_file])
                # for dllwrap we have to use a special option
                extra_preargs.extend(["--def", def_file])
            # we use gcc/ld here and can be sure ld is >= 2.9.10
            else:
                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
                # for gcc/ld the def-file is specified as any object files
                objects.append(def_file)

        #end: if ((export_symbols is not None) and
        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):

        # who wants symbols and a many times larger output file
        # should explicitly switch the debug mode on
        # otherwise we let dllwrap/ld strip the output file
        # (On my machine: 10KB < stripped_file < ??100KB
        #   unstripped_file = stripped_file + XXX KB
        #  ( XXX=254 for a typical python extension))
        if not debug:
            extra_preargs.append("-s")

        UnixCCompiler.link(self,
                           target_desc,
                           objects,
                           output_filename,
                           output_dir,
                           libraries,
                           library_dirs,
                           runtime_library_dirs,
                           None, # export_symbols, we do this in our def-file
                           debug,
                           extra_preargs,
                           extra_postargs,
                           build_temp,
                           target_lang)

    # link ()

    # -- Miscellaneous methods -----------------------------------------

    # overwrite the one from CCompiler to support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc','.res']):
                raise UnknownFileError, \
                      "unknown file type '%s' (from '%s')" % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.res' or ext == '.rc':
                # these need to be compiled to object files
                obj_names.append (os.path.join (output_dir,
                                            base + ext + self.obj_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

    # object_filenames ()

# 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)

        # ld_version >= "2.13" support -shared so use it instead of
        # -mdll -static
        if self.ld_version >= "2.13":
            shared_option = "-shared"
        else:
            shared_option = "-mdll -static"

        # A real mingw32 doesn't need to specify a different entry point,
        # but cygwin 2.91.57 in no-cygwin-mode needs it.
        if self.gcc_version <= "2.91.57":
            entry_point = '--entry _DllMain@12'
        else:
            entry_point = ''

        self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
                             compiler_so='gcc -mno-cygwin -mdll -O -Wall',
                             compiler_cxx='g++ -mno-cygwin -O -Wall',
                             linker_exe='gcc -mno-cygwin',
                             linker_so='%s -mno-cygwin %s %s'
                                        % (self.linker_dll, shared_option,
                                           entry_point))
        # Maybe we should also append -mthreads, but then the finished
        # dlls need another dll (mingwm10.dll see Mingw32 docs)
        # (-mthreads: Support thread-safe exception handling on `Mingw32')

        # no additional libraries needed
        self.dll_libraries=[]

        # Include the appropriate MSVC runtime library if Python was built
        # with MSVC 7.0 or 7.1.
        msc_pos = sys.version.find('MSC v.')
        if msc_pos != -1:
            msc_ver = sys.version[msc_pos+6:msc_pos+10]
            if msc_ver == '1300':
                # MSVC 7.0
                self.dll_libraries = ['msvcr70']
            elif msc_ver == '1310':
                # MSVC 7.1
                self.dll_libraries = ['msvcr71']

    # __init__ ()

# class Mingw32CCompiler

# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using a unmodified
# version.

CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"

def check_config_h():

    """Check if the current Python installation (specifically, pyconfig.h)
    appears amenable to building extensions with GCC.  Returns a tuple
    (status, details), where 'status' is one of the following constants:
      CONFIG_H_OK
        all is well, go ahead and compile
      CONFIG_H_NOTOK
        doesn't look good
      CONFIG_H_UNCERTAIN
        not sure -- unable to read pyconfig.h
    'details' is a human-readable string explaining the situation.

    Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    """

    # XXX since this function also checks sys.version, it's not strictly a
    # "pyconfig.h" check -- should probably be renamed...

    from distutils import sysconfig
    import string
    # if sys.version contains GCC then python was compiled with
    # GCC, and the pyconfig.h file should be OK
    if string.find(sys.version,"GCC") >= 0:
        return (CONFIG_H_OK, "sys.version mentions 'GCC'")

    fn = sysconfig.get_config_h_filename()
    try:
        # It would probably better to read single lines to search.
        # But we do this only once, and it is fast enough
        f = open(fn)
        s = f.read()
        f.close()

    except IOError, exc:
        # if we can't read this file, we cannot say it is wrong
        # the compiler will complain later about this file as missing
        return (CONFIG_H_UNCERTAIN,
                "couldn't read '%s': %s" % (fn, exc.strerror))

    else:
        # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
        if string.find(s,"__GNUC__") >= 0:
            return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
        else:
            return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)


def get_versions():
    """ Try to find out the versions of gcc, ld and dllwrap.
        If not possible it returns None for it.
    """
    from distutils.version import StrictVersion
    from distutils.spawn import find_executable
    import re

    gcc_exe = find_executable('gcc')
    if gcc_exe:
        out = os.popen(gcc_exe + ' -dumpversion','r')
        out_string = out.read()
        out.close()
        result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
        if result:
            gcc_version = StrictVersion(result.group(1))
        else:
            gcc_version = None
    else:
        gcc_version = None
    ld_exe = find_executable('ld')
    if ld_exe:
        out = os.popen(ld_exe + ' -v','r')
        out_string = out.read()
        out.close()
        result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
        if result:
            ld_version = StrictVersion(result.group(1))
        else:
            ld_version = None
    else:
        ld_version = None
    dllwrap_exe = find_executable('dllwrap')
    if dllwrap_exe:
        out = os.popen(dllwrap_exe + ' --version','r')
        out_string = out.read()
        out.close()
        result = re.search(' (\d+\.\d+(\.\d+)*)',out_string)
        if result:
            dllwrap_version = StrictVersion(result.group(1))
        else:
            dllwrap_version = None
    else:
        dllwrap_version = None
    return (gcc_version, ld_version, dllwrap_version)
Commit	Line	Data
920dae64 AT	1	"""distutils.cygwinccompiler
	2
	3	Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
	4	handles the Cygwin port of the GNU C compiler to Windows. It also contains
	5	the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
	6	cygwin in no-cygwin mode).
	7	"""
	8
	9	# problems:
	10	#
	11	# * if you use a msvc compiled python version (1.5.2)
	12	# 1. you have to insert a __GNUC__ section in its config.h
	13	# 2. you have to generate a import library for its dll
	14	# - create a def-file for python??.dll
	15	# - create a import library using
	16	# dlltool --dllname python15.dll --def python15.def \
	17	# --output-lib libpython15.a
	18	#
	19	# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
	20	#
	21	# * We put export_symbols in a def-file, and don't use
	22	# --export-all-symbols because it doesn't worked reliable in some
	23	# tested configurations. And because other windows compilers also
	24	# need their symbols specified this no serious problem.
	25	#
	26	# tested configurations:
	27	#
	28	# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
	29	# (after patching python's config.h and for C++ some other include files)
	30	# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
	31	# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
	32	# (ld doesn't support -shared, so we use dllwrap)
	33	# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
	34	# - its dllwrap doesn't work, there is a bug in binutils 2.10.90
	35	# see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
	36	# - using gcc -mdll instead dllwrap doesn't work without -static because
	37	# it tries to link against dlls instead their import libraries. (If
	38	# it finds the dll first.)
	39	# By specifying -static we force ld to link against the import libraries,
	40	# this is windows standard and there are normally not the necessary symbols
	41	# in the dlls.
	42	# *** only the version of June 2000 shows these problems
	43	# * cygwin gcc 3.2/ld 2.13.90 works
	44	# (ld supports -shared)
	45	# * mingw gcc 3.2/ld 2.13 works
	46	# (ld supports -shared)
	47
	48	# This module should be kept compatible with Python 2.1.
	49
	50	__revision__ = "$Id: cygwinccompiler.py,v 1.29 2004/11/10 22:23:14 loewis Exp $"
	51
	52	import os,sys,copy
	53	from distutils.ccompiler import gen_preprocess_options, gen_lib_options
	54	from distutils.unixccompiler import UnixCCompiler
	55	from distutils.file_util import write_file
	56	from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
	57	from distutils import log
	58
	59	class CygwinCCompiler (UnixCCompiler):
	60
	61	compiler_type = 'cygwin'
	62	obj_extension = ".o"
	63	static_lib_extension = ".a"
	64	shared_lib_extension = ".dll"
65	static_lib_format = "lib%s%s"
66	shared_lib_format = "%s%s"
67	exe_extension = ".exe"
68
69	def __init__ (self, verbose=0, dry_run=0, force=0):
70
71	UnixCCompiler.__init__ (self, verbose, dry_run, force)
72
73	(status, details) = check_config_h()
74	self.debug_print("Python's GCC status: %s (details: %s)" %
75	(status, details))
76	if status is not CONFIG_H_OK:
77	self.warn(
78	"Python's pyconfig.h doesn't seem to support your compiler. "
79	"Reason: %s. "
80	"Compiling may fail because of undefined preprocessor macros."
81	% details)
82
83	self.gcc_version, self.ld_version, self.dllwrap_version = \
84	get_versions()
85	self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
86	(self.gcc_version,
87	self.ld_version,
88	self.dllwrap_version) )
89
90	# ld_version >= "2.10.90" and < "2.13" should also be able to use
91	# gcc -mdll instead of dllwrap
92	# Older dllwraps had own version numbers, newer ones use the
93	# same as the rest of binutils ( also ld )
94	# dllwrap 2.10.90 is buggy
95	if self.ld_version >= "2.10.90":
96	self.linker_dll = "gcc"
97	else:
98	self.linker_dll = "dllwrap"
99
100	# ld_version >= "2.13" support -shared so use it instead of
101	# -mdll -static
102	if self.ld_version >= "2.13":
103	shared_option = "-shared"
104	else:
105	shared_option = "-mdll -static"
106
107	# Hard-code GCC because that's what this is all about.
108	# XXX optimization, warnings etc. should be customizable.
109	self.set_executables(compiler='gcc -mcygwin -O -Wall',
110	compiler_so='gcc -mcygwin -mdll -O -Wall',
111	compiler_cxx='g++ -mcygwin -O -Wall',
112	linker_exe='gcc -mcygwin',
113	linker_so=('%s -mcygwin %s' %
114	(self.linker_dll, shared_option)))
115
116	# cygwin and mingw32 need different sets of libraries
117	if self.gcc_version == "2.91.57":
118	# cygwin shouldn't need msvcrt, but without the dlls will crash
119	# (gcc version 2.91.57) -- perhaps something about initialization
120	self.dll_libraries=["msvcrt"]
121	self.warn(
122	"Consider upgrading to a newer version of gcc")
123	else:
124	self.dll_libraries=[]
125	# Include the appropriate MSVC runtime library if Python was built
126	# with MSVC 7.0 or 7.1.
127	msc_pos = sys.version.find('MSC v.')
128	if msc_pos != -1:
129	msc_ver = sys.version[msc_pos+6:msc_pos+10]
130	if msc_ver == '1300':
131	# MSVC 7.0
132	self.dll_libraries = ['msvcr70']
133	elif msc_ver == '1310':
134	# MSVC 7.1
135	self.dll_libraries = ['msvcr71']
136
137	# __init__ ()
138
139
140	def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
141	if ext == '.rc' or ext == '.res':
142	# gcc needs '.res' and '.rc' compiled to object files !!!
143	try:
144	self.spawn(["windres", "-i", src, "-o", obj])
145	except DistutilsExecError, msg:
146	raise CompileError, msg
147	else: # for other files use the C-compiler
148	try:
149	self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
150	extra_postargs)
151	except DistutilsExecError, msg:
152	raise CompileError, msg
153
154	def link (self,
155	target_desc,
156	objects,
157	output_filename,
158	output_dir=None,
159	libraries=None,
160	library_dirs=None,
161	runtime_library_dirs=None,
162	export_symbols=None,
163	debug=0,
164	extra_preargs=None,
165	extra_postargs=None,
166	build_temp=None,
167	target_lang=None):
168
169	# use separate copies, so we can modify the lists
170	extra_preargs = copy.copy(extra_preargs or [])
171	libraries = copy.copy(libraries or [])
172	objects = copy.copy(objects or [])
173
174	# Additional libraries
175	libraries.extend(self.dll_libraries)
176
177	# handle export symbols by creating a def-file
178	# with executables this only works with gcc/ld as linker
179	if ((export_symbols is not None) and
180	(target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
181	# (The linker doesn't do anything if output is up-to-date.
182	# So it would probably better to check if we really need this,
183	# but for this we had to insert some unchanged parts of
184	# UnixCCompiler, and this is not what we want.)
185
186	# we want to put some files in the same directory as the
187	# object files are, build_temp doesn't help much
188	# where are the object files
189	temp_dir = os.path.dirname(objects[0])
190	# name of dll to give the helper files the same base name
191	(dll_name, dll_extension) = os.path.splitext(
192	os.path.basename(output_filename))
193
194	# generate the filenames for these files
195	def_file = os.path.join(temp_dir, dll_name + ".def")
196	lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
197
198	# Generate .def file
199	contents = [
200	"LIBRARY %s" % os.path.basename(output_filename),
201	"EXPORTS"]
202	for sym in export_symbols:
203	contents.append(sym)
204	self.execute(write_file, (def_file, contents),
205	"writing %s" % def_file)
206
207	# next add options for def-file and to creating import libraries
208
209	# dllwrap uses different options than gcc/ld
210	if self.linker_dll == "dllwrap":
211	extra_preargs.extend(["--output-lib", lib_file])
212	# for dllwrap we have to use a special option
213	extra_preargs.extend(["--def", def_file])
214	# we use gcc/ld here and can be sure ld is >= 2.9.10
215	else:
216	# doesn't work: bfd_close build\...\libfoo.a: Invalid operation
217	#extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
218	# for gcc/ld the def-file is specified as any object files
219	objects.append(def_file)
220
221	#end: if ((export_symbols is not None) and
222	# (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
223
224	# who wants symbols and a many times larger output file
225	# should explicitly switch the debug mode on
226	# otherwise we let dllwrap/ld strip the output file
227	# (On my machine: 10KB < stripped_file < ??100KB
228	# unstripped_file = stripped_file + XXX KB
229	# ( XXX=254 for a typical python extension))
230	if not debug:
231	extra_preargs.append("-s")
232
233	UnixCCompiler.link(self,
234	target_desc,
235	objects,
236	output_filename,
237	output_dir,
238	libraries,
239	library_dirs,
240	runtime_library_dirs,
241	None, # export_symbols, we do this in our def-file
242	debug,
243	extra_preargs,
244	extra_postargs,
245	build_temp,
246	target_lang)
247
248	# link ()
249
250	# -- Miscellaneous methods -----------------------------------------
251
252	# overwrite the one from CCompiler to support rc and res-files
253	def object_filenames (self,
254	source_filenames,
255	strip_dir=0,
256	output_dir=''):
257	if output_dir is None: output_dir = ''
258	obj_names = []
259	for src_name in source_filenames:
260	# use normcase to make sure '.rc' is really '.rc' and not '.RC'
261	(base, ext) = os.path.splitext (os.path.normcase(src_name))
262	if ext not in (self.src_extensions + ['.rc','.res']):
263	raise UnknownFileError, \
264	"unknown file type '%s' (from '%s')" % \
265	(ext, src_name)
266	if strip_dir:
267	base = os.path.basename (base)
268	if ext == '.res' or ext == '.rc':
269	# these need to be compiled to object files
270	obj_names.append (os.path.join (output_dir,
271	base + ext + self.obj_extension))
272	else:
273	obj_names.append (os.path.join (output_dir,
274	base + self.obj_extension))
275	return obj_names
276
277	# object_filenames ()
278
279	# class CygwinCCompiler
280
281
282	# the same as cygwin plus some additional parameters
283	class Mingw32CCompiler (CygwinCCompiler):
284
285	compiler_type = 'mingw32'
286
287	def __init__ (self,
288	verbose=0,
289	dry_run=0,
290	force=0):
291
292	CygwinCCompiler.__init__ (self, verbose, dry_run, force)
293
294	# ld_version >= "2.13" support -shared so use it instead of
295	# -mdll -static
296	if self.ld_version >= "2.13":
297	shared_option = "-shared"
298	else:
299	shared_option = "-mdll -static"
300
301	# A real mingw32 doesn't need to specify a different entry point,
302	# but cygwin 2.91.57 in no-cygwin-mode needs it.
303	if self.gcc_version <= "2.91.57":
304	entry_point = '--entry _DllMain@12'
305	else:
306	entry_point = ''
307
308	self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
309	compiler_so='gcc -mno-cygwin -mdll -O -Wall',
310	compiler_cxx='g++ -mno-cygwin -O -Wall',
311	linker_exe='gcc -mno-cygwin',
312	linker_so='%s -mno-cygwin %s %s'
313	% (self.linker_dll, shared_option,
314	entry_point))
315	# Maybe we should also append -mthreads, but then the finished
316	# dlls need another dll (mingwm10.dll see Mingw32 docs)
317	# (-mthreads: Support thread-safe exception handling on `Mingw32')
318
319	# no additional libraries needed
320	self.dll_libraries=[]
321
322	# Include the appropriate MSVC runtime library if Python was built
323	# with MSVC 7.0 or 7.1.
324	msc_pos = sys.version.find('MSC v.')
325	if msc_pos != -1:
326	msc_ver = sys.version[msc_pos+6:msc_pos+10]
327	if msc_ver == '1300':
328	# MSVC 7.0
329	self.dll_libraries = ['msvcr70']
330	elif msc_ver == '1310':
331	# MSVC 7.1
332	self.dll_libraries = ['msvcr71']
333
334	# __init__ ()
335
336	# class Mingw32CCompiler
337
338	# Because these compilers aren't configured in Python's pyconfig.h file by
339	# default, we should at least warn the user if he is using a unmodified
340	# version.
341
342	CONFIG_H_OK = "ok"
343	CONFIG_H_NOTOK = "not ok"
344	CONFIG_H_UNCERTAIN = "uncertain"
345
346	def check_config_h():
347
348	"""Check if the current Python installation (specifically, pyconfig.h)
349	appears amenable to building extensions with GCC. Returns a tuple
350	(status, details), where 'status' is one of the following constants:
351	CONFIG_H_OK
352	all is well, go ahead and compile
353	CONFIG_H_NOTOK
354	doesn't look good
355	CONFIG_H_UNCERTAIN
356	not sure -- unable to read pyconfig.h
357	'details' is a human-readable string explaining the situation.
358
359	Note there are two ways to conclude "OK": either 'sys.version' contains
360	the string "GCC" (implying that this Python was built with GCC), or the
361	installed "pyconfig.h" contains the string "__GNUC__".
362	"""
363
364	# XXX since this function also checks sys.version, it's not strictly a
365	# "pyconfig.h" check -- should probably be renamed...
366
367	from distutils import sysconfig
368	import string
369	# if sys.version contains GCC then python was compiled with
370	# GCC, and the pyconfig.h file should be OK
371	if string.find(sys.version,"GCC") >= 0:
372	return (CONFIG_H_OK, "sys.version mentions 'GCC'")
373
374	fn = sysconfig.get_config_h_filename()
375	try:
376	# It would probably better to read single lines to search.
377	# But we do this only once, and it is fast enough
378	f = open(fn)
379	s = f.read()
380	f.close()
381
382	except IOError, exc:
383	# if we can't read this file, we cannot say it is wrong
384	# the compiler will complain later about this file as missing
385	return (CONFIG_H_UNCERTAIN,
386	"couldn't read '%s': %s" % (fn, exc.strerror))
387
388	else:
389	# "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
390	if string.find(s,"__GNUC__") >= 0:
391	return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
392	else:
393	return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
394
395
396
397	def get_versions():
398	""" Try to find out the versions of gcc, ld and dllwrap.
399	If not possible it returns None for it.
400	"""
401	from distutils.version import StrictVersion
402	from distutils.spawn import find_executable
403	import re
404
405	gcc_exe = find_executable('gcc')
406	if gcc_exe:
407	out = os.popen(gcc_exe + ' -dumpversion','r')
408	out_string = out.read()
409	out.close()
410	result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
411	if result:
412	gcc_version = StrictVersion(result.group(1))
413	else:
414	gcc_version = None
415	else:
416	gcc_version = None
417	ld_exe = find_executable('ld')
418	if ld_exe:
419	out = os.popen(ld_exe + ' -v','r')
420	out_string = out.read()
421	out.close()
422	result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
423	if result:
424	ld_version = StrictVersion(result.group(1))
425	else:
426	ld_version = None
427	else:
428	ld_version = None
429	dllwrap_exe = find_executable('dllwrap')
430	if dllwrap_exe:
431	out = os.popen(dllwrap_exe + ' --version','r')
432	out_string = out.read()
433	out.close()
434	result = re.search(' (\d+\.\d+(\.\d+)*)',out_string)
435	if result:
436	dllwrap_version = StrictVersion(result.group(1))
437	else:
438	dllwrap_version = None
439	else:
440	dllwrap_version = None
441	return (gcc_version, ld_version, dllwrap_version)