[wxWidgets.git] / wxPython / 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 1.5.2.

__revision__ = "$Id$"

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',
                             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=[]

    # __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',
                             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=[]

    # __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
1e4a197e RD	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
e55c4dd1 RD	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)
1e4a197e RD	47
	48	# This module should be kept compatible with Python 1.5.2.
	49
	50	__revision__ = "$Id$"
	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
e55c4dd1	90	# ld_version >= "2.10.90" and < "2.13" should also be able to use
1e4a197e RD	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
e55c4dd1 RD	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
1e4a197e RD	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	linker_exe='gcc -mcygwin',
e55c4dd1 RD	112	linker_so=('%s -mcygwin %s' %
e55c4dd1 RD	113	(self.linker_dll, shared_option)))
1e4a197e RD	114
	115	# cygwin and mingw32 need different sets of libraries
	116	if self.gcc_version == "2.91.57":
	117	# cygwin shouldn't need msvcrt, but without the dlls will crash
	118	# (gcc version 2.91.57) -- perhaps something about initialization
	119	self.dll_libraries=["msvcrt"]
	120	self.warn(
	121	"Consider upgrading to a newer version of gcc")
	122	else:
	123	self.dll_libraries=[]
	124
	125	# __init__ ()
	126
	127
	128	def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
	129	if ext == '.rc' or ext == '.res':
	130	# gcc needs '.res' and '.rc' compiled to object files !!!
	131	try:
	132	self.spawn(["windres", "-i", src, "-o", obj])
	133	except DistutilsExecError, msg:
	134	raise CompileError, msg
	135	else: # for other files use the C-compiler
	136	try:
	137	self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
	138	extra_postargs)
	139	except DistutilsExecError, msg:
	140	raise CompileError, msg
	141
	142	def link (self,
	143	target_desc,
	144	objects,
	145	output_filename,
	146	output_dir=None,
	147	libraries=None,
	148	library_dirs=None,
	149	runtime_library_dirs=None,
	150	export_symbols=None,
	151	debug=0,
	152	extra_preargs=None,
	153	extra_postargs=None,
	154	build_temp=None,
	155	target_lang=None):
	156
	157	# use separate copies, so we can modify the lists
	158	extra_preargs = copy.copy(extra_preargs or [])
	159	libraries = copy.copy(libraries or [])
	160	objects = copy.copy(objects or [])
	161
	162	# Additional libraries
	163	libraries.extend(self.dll_libraries)
	164
	165	# handle export symbols by creating a def-file
	166	# with executables this only works with gcc/ld as linker
	167	if ((export_symbols is not None) and
	168	(target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
	169	# (The linker doesn't do anything if output is up-to-date.
	170	# So it would probably better to check if we really need this,
	171	# but for this we had to insert some unchanged parts of
	172	# UnixCCompiler, and this is not what we want.)
	173
	174	# we want to put some files in the same directory as the
	175	# object files are, build_temp doesn't help much
	176	# where are the object files
	177	temp_dir = os.path.dirname(objects[0])
178	# name of dll to give the helper files the same base name
179	(dll_name, dll_extension) = os.path.splitext(
180	os.path.basename(output_filename))
181
182	# generate the filenames for these files
183	def_file = os.path.join(temp_dir, dll_name + ".def")
184	lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
185
186	# Generate .def file
187	contents = [
188	"LIBRARY %s" % os.path.basename(output_filename),
189	"EXPORTS"]
190	for sym in export_symbols:
191	contents.append(sym)
192	self.execute(write_file, (def_file, contents),
193	"writing %s" % def_file)
194
195	# next add options for def-file and to creating import libraries
196
197	# dllwrap uses different options than gcc/ld
198	if self.linker_dll == "dllwrap":
199	extra_preargs.extend(["--output-lib", lib_file])
200	# for dllwrap we have to use a special option
201	extra_preargs.extend(["--def", def_file])
202	# we use gcc/ld here and can be sure ld is >= 2.9.10
203	else:
204	# doesn't work: bfd_close build\...\libfoo.a: Invalid operation
205	#extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
206	# for gcc/ld the def-file is specified as any object files
207	objects.append(def_file)
208
209	#end: if ((export_symbols is not None) and
210	# (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
211
212	# who wants symbols and a many times larger output file
213	# should explicitly switch the debug mode on
214	# otherwise we let dllwrap/ld strip the output file
215	# (On my machine: 10KB < stripped_file < ??100KB
216	# unstripped_file = stripped_file + XXX KB
217	# ( XXX=254 for a typical python extension))
218	if not debug:
219	extra_preargs.append("-s")
220
221	UnixCCompiler.link(self,
222	target_desc,
223	objects,
224	output_filename,
225	output_dir,
226	libraries,
227	library_dirs,
228	runtime_library_dirs,
229	None, # export_symbols, we do this in our def-file
230	debug,
231	extra_preargs,
232	extra_postargs,
233	build_temp,
234	target_lang)
235
236	# link ()
237
238	# -- Miscellaneous methods -----------------------------------------
239
240	# overwrite the one from CCompiler to support rc and res-files
241	def object_filenames (self,
242	source_filenames,
243	strip_dir=0,
244	output_dir=''):
245	if output_dir is None: output_dir = ''
246	obj_names = []
247	for src_name in source_filenames:
248	# use normcase to make sure '.rc' is really '.rc' and not '.RC'
249	(base, ext) = os.path.splitext (os.path.normcase(src_name))
250	if ext not in (self.src_extensions + ['.rc','.res']):
251	raise UnknownFileError, \
252	"unknown file type '%s' (from '%s')" % \
253	(ext, src_name)
254	if strip_dir:
255	base = os.path.basename (base)
256	if ext == '.res' or ext == '.rc':
257	# these need to be compiled to object files
258	obj_names.append (os.path.join (output_dir,
259	base + ext + self.obj_extension))
260	else:
261	obj_names.append (os.path.join (output_dir,
262	base + self.obj_extension))
263	return obj_names
264
265	# object_filenames ()
266
267	# class CygwinCCompiler
268
269
270	# the same as cygwin plus some additional parameters
271	class Mingw32CCompiler (CygwinCCompiler):
272
273	compiler_type = 'mingw32'
274
275	def __init__ (self,
276	verbose=0,
277	dry_run=0,
278	force=0):
279
280	CygwinCCompiler.__init__ (self, verbose, dry_run, force)
281
e55c4dd1 RD	282	# ld_version >= "2.13" support -shared so use it instead of
	283	# -mdll -static
	284	if self.ld_version >= "2.13":
	285	shared_option = "-shared"
	286	else:
	287	shared_option = "-mdll -static"
	288
1e4a197e RD	289	# A real mingw32 doesn't need to specify a different entry point,
	290	# but cygwin 2.91.57 in no-cygwin-mode needs it.
	291	if self.gcc_version <= "2.91.57":
	292	entry_point = '--entry _DllMain@12'
	293	else:
	294	entry_point = ''
	295
	296	self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
	297	compiler_so='gcc -mno-cygwin -mdll -O -Wall',
	298	linker_exe='gcc -mno-cygwin',
e55c4dd1 RD	299	linker_so='%s -mno-cygwin %s %s'
	300	% (self.linker_dll, shared_option,
	301	entry_point))
1e4a197e RD	302	# Maybe we should also append -mthreads, but then the finished
	303	# dlls need another dll (mingwm10.dll see Mingw32 docs)
	304	# (-mthreads: Support thread-safe exception handling on `Mingw32')
	305
	306	# no additional libraries needed
	307	self.dll_libraries=[]
	308
	309	# __init__ ()
	310
	311	# class Mingw32CCompiler
	312
	313	# Because these compilers aren't configured in Python's pyconfig.h file by
	314	# default, we should at least warn the user if he is using a unmodified
	315	# version.
	316
	317	CONFIG_H_OK = "ok"
	318	CONFIG_H_NOTOK = "not ok"
	319	CONFIG_H_UNCERTAIN = "uncertain"
	320
	321	def check_config_h():
	322
	323	"""Check if the current Python installation (specifically, pyconfig.h)
	324	appears amenable to building extensions with GCC. Returns a tuple
	325	(status, details), where 'status' is one of the following constants:
	326	CONFIG_H_OK
	327	all is well, go ahead and compile
	328	CONFIG_H_NOTOK
	329	doesn't look good
	330	CONFIG_H_UNCERTAIN
	331	not sure -- unable to read pyconfig.h
	332	'details' is a human-readable string explaining the situation.
	333
	334	Note there are two ways to conclude "OK": either 'sys.version' contains
	335	the string "GCC" (implying that this Python was built with GCC), or the
	336	installed "pyconfig.h" contains the string "__GNUC__".
	337	"""
	338
	339	# XXX since this function also checks sys.version, it's not strictly a
	340	# "pyconfig.h" check -- should probably be renamed...
	341
	342	from distutils import sysconfig
	343	import string
	344	# if sys.version contains GCC then python was compiled with
	345	# GCC, and the pyconfig.h file should be OK
	346	if string.find(sys.version,"GCC") >= 0:
	347	return (CONFIG_H_OK, "sys.version mentions 'GCC'")
	348
	349	fn = sysconfig.get_config_h_filename()
	350	try:
	351	# It would probably better to read single lines to search.
	352	# But we do this only once, and it is fast enough
	353	f = open(fn)
	354	s = f.read()
	355	f.close()
	356
	357	except IOError, exc:
	358	# if we can't read this file, we cannot say it is wrong
	359	# the compiler will complain later about this file as missing
	360	return (CONFIG_H_UNCERTAIN,
	361	"couldn't read '%s': %s" % (fn, exc.strerror))
	362
	363	else:
	364	# "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
	365	if string.find(s,"__GNUC__") >= 0:
366	return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
367	else:
368	return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
369
370
371
372	def get_versions():
373	""" Try to find out the versions of gcc, ld and dllwrap.
374	If not possible it returns None for it.
375	"""
376	from distutils.version import StrictVersion
377	from distutils.spawn import find_executable
378	import re
379
380	gcc_exe = find_executable('gcc')
381	if gcc_exe:
382	out = os.popen(gcc_exe + ' -dumpversion','r')
383	out_string = out.read()
384	out.close()
e55c4dd1	385	result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
1e4a197e RD	386	if result:
	387	gcc_version = StrictVersion(result.group(1))
	388	else:
	389	gcc_version = None
	390	else:
	391	gcc_version = None
	392	ld_exe = find_executable('ld')
	393	if ld_exe:
	394	out = os.popen(ld_exe + ' -v','r')
	395	out_string = out.read()
	396	out.close()
e55c4dd1	397	result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
1e4a197e RD	398	if result:
	399	ld_version = StrictVersion(result.group(1))
	400	else:
	401	ld_version = None
	402	else:
	403	ld_version = None
	404	dllwrap_exe = find_executable('dllwrap')
	405	if dllwrap_exe:
	406	out = os.popen(dllwrap_exe + ' --version','r')
	407	out_string = out.read()
	408	out.close()
e55c4dd1	409	result = re.search(' (\d+\.\d+(\.\d+)*)',out_string)
1e4a197e RD	410	if result:
	411	dllwrap_version = StrictVersion(result.group(1))
	412	else:
	413	dllwrap_version = None
	414	else:
	415	dllwrap_version = None
	416	return (gcc_version, ld_version, dllwrap_version)