[wxWidgets.git] / wxPython / distutils / emxccompiler.py

"""distutils.emxccompiler

Provides the EMXCCompiler class, a subclass of UnixCCompiler that
handles the EMX port of the GNU C compiler to OS/2.
"""

# issues:
#
# * OS/2 insists that DLLs can have names no longer than 8 characters
#   We put export_symbols in a def-file, as though the DLL can have
#   an arbitrary length name, but truncate the output filename.
#
# * only use OMF objects and use LINK386 as the linker (-Zomf)
#
# * always build for multithreading (-Zmt) as the accompanying OS/2 port
#   of Python is only distributed with threads enabled.
#
# tested configurations:
#
# * EMX gcc 2.81/EMX 0.9d fix03

__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 EMXCCompiler (UnixCCompiler):

    compiler_type = 'emx'
    obj_extension = ".obj"
    static_lib_extension = ".lib"
    shared_lib_extension = ".dll"
    static_lib_format = "%s%s"
    shared_lib_format = "%s%s"
    res_extension = ".res"      # compiled resource file
    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." % details) +
                "Compiling may fail because of undefined preprocessor macros.")

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

        # Hard-code GCC because that's what this is all about.
        # XXX optimization, warnings etc. should be customizable.
        self.set_executables(compiler='gcc -Zomf -Zmt -O2 -Wall',
                             compiler_so='gcc -Zomf -Zmt -O2 -Wall',
                             linker_exe='gcc -Zomf -Zmt -Zcrtdll',
                             linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll')

        # want the gcc library statically linked (so that we don't have
        # to distribute a version dependent on the compiler we have)
        self.dll_libraries=["gcc"]

    # __init__ ()

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        if ext == '.rc':
            # gcc requires '.rc' compiled to binary ('.res') files !!!
            try:
                self.spawn(["rc", "-r", src])
            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)):
            # (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")

            # Generate .def file
            contents = [
                "LIBRARY %s INITINSTANCE TERMINSTANCE" % \
                os.path.splitext(os.path.basename(output_filename))[0],
                "DATA MULTIPLE NONSHARED",
                "EXPORTS"]
            for sym in export_symbols:
                contents.append('  "%s"' % sym)
            self.execute(write_file, (def_file, contents),
                         "writing %s" % def_file)

            # next add options for def-file and to creating import libraries
            # for gcc/ld the def-file is specified as any other 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 -----------------------------------------

    # override the object_filenames method 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']):
                raise UnknownFileError, \
                      "unknown file type '%s' (from '%s')" % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.rc':
                # these need to be compiled to object files
                obj_names.append (os.path.join (output_dir,
                                            base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

    # object_filenames ()

    # override the find_library_file method from UnixCCompiler
    # to deal with file naming/searching differences
    def find_library_file(self, dirs, lib, debug=0):
        shortlib = '%s.lib' % lib
        longlib = 'lib%s.lib' % lib    # this form very rare

        # get EMX's default library directory search path
        try:
            emx_dirs = os.environ['LIBRARY_PATH'].split(';')
        except KeyError:
            emx_dirs = []

        for dir in dirs + emx_dirs:
            shortlibp = os.path.join(dir, shortlib)
            longlibp = os.path.join(dir, longlib)
            if os.path.exists(shortlibp):
                return shortlibp
            elif os.path.exists(longlibp):
                return longlibp

        # Oops, didn't find it in *any* of 'dirs'
        return None

# class EMXCCompiler


# 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 and ld.
        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
    # EMX ld has no way of reporting version number, and we use GCC
    # anyway - so we can link OMF DLLs
    ld_version = None
    return (gcc_version, ld_version)
Commit	Line	Data
1e4a197e RD	1	"""distutils.emxccompiler
	2
	3	Provides the EMXCCompiler class, a subclass of UnixCCompiler that
	4	handles the EMX port of the GNU C compiler to OS/2.
	5	"""
	6
	7	# issues:
	8	#
	9	# * OS/2 insists that DLLs can have names no longer than 8 characters
	10	# We put export_symbols in a def-file, as though the DLL can have
	11	# an arbitrary length name, but truncate the output filename.
	12	#
	13	# * only use OMF objects and use LINK386 as the linker (-Zomf)
	14	#
	15	# * always build for multithreading (-Zmt) as the accompanying OS/2 port
	16	# of Python is only distributed with threads enabled.
	17	#
	18	# tested configurations:
	19	#
	20	# * EMX gcc 2.81/EMX 0.9d fix03
	21
	22	__revision__ = "$Id$"
	23
	24	import os,sys,copy
	25	from distutils.ccompiler import gen_preprocess_options, gen_lib_options
	26	from distutils.unixccompiler import UnixCCompiler
	27	from distutils.file_util import write_file
	28	from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
	29	from distutils import log
	30
	31	class EMXCCompiler (UnixCCompiler):
	32
	33	compiler_type = 'emx'
	34	obj_extension = ".obj"
	35	static_lib_extension = ".lib"
	36	shared_lib_extension = ".dll"
	37	static_lib_format = "%s%s"
	38	shared_lib_format = "%s%s"
	39	res_extension = ".res" # compiled resource file
	40	exe_extension = ".exe"
	41
	42	def __init__ (self,
	43	verbose=0,
	44	dry_run=0,
	45	force=0):
	46
	47	UnixCCompiler.__init__ (self, verbose, dry_run, force)
	48
	49	(status, details) = check_config_h()
	50	self.debug_print("Python's GCC status: %s (details: %s)" %
	51	(status, details))
	52	if status is not CONFIG_H_OK:
	53	self.warn(
	54	"Python's pyconfig.h doesn't seem to support your compiler. " +
	55	("Reason: %s." % details) +
	56	"Compiling may fail because of undefined preprocessor macros.")
	57
	58	(self.gcc_version, self.ld_version) = \
	59	get_versions()
	60	self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" %
	61	(self.gcc_version,
	62	self.ld_version) )
	63
	64	# Hard-code GCC because that's what this is all about.
65	# XXX optimization, warnings etc. should be customizable.
66	self.set_executables(compiler='gcc -Zomf -Zmt -O2 -Wall',
67	compiler_so='gcc -Zomf -Zmt -O2 -Wall',
68	linker_exe='gcc -Zomf -Zmt -Zcrtdll',
69	linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll')
70
71	# want the gcc library statically linked (so that we don't have
72	# to distribute a version dependent on the compiler we have)
73	self.dll_libraries=["gcc"]
74
75	# __init__ ()
76
77	def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
78	if ext == '.rc':
79	# gcc requires '.rc' compiled to binary ('.res') files !!!
80	try:
81	self.spawn(["rc", "-r", src])
82	except DistutilsExecError, msg:
83	raise CompileError, msg
84	else: # for other files use the C-compiler
85	try:
86	self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
87	extra_postargs)
88	except DistutilsExecError, msg:
89	raise CompileError, msg
90
91	def link (self,
92	target_desc,
93	objects,
94	output_filename,
95	output_dir=None,
96	libraries=None,
97	library_dirs=None,
98	runtime_library_dirs=None,
99	export_symbols=None,
100	debug=0,
101	extra_preargs=None,
102	extra_postargs=None,
103	build_temp=None,
104	target_lang=None):
105
106	# use separate copies, so we can modify the lists
107	extra_preargs = copy.copy(extra_preargs or [])
108	libraries = copy.copy(libraries or [])
109	objects = copy.copy(objects or [])
110
111	# Additional libraries
112	libraries.extend(self.dll_libraries)
113
114	# handle export symbols by creating a def-file
115	# with executables this only works with gcc/ld as linker
116	if ((export_symbols is not None) and
117	(target_desc != self.EXECUTABLE)):
118	# (The linker doesn't do anything if output is up-to-date.
119	# So it would probably better to check if we really need this,
120	# but for this we had to insert some unchanged parts of
121	# UnixCCompiler, and this is not what we want.)
122
123	# we want to put some files in the same directory as the
124	# object files are, build_temp doesn't help much
125	# where are the object files
126	temp_dir = os.path.dirname(objects[0])
127	# name of dll to give the helper files the same base name
128	(dll_name, dll_extension) = os.path.splitext(
129	os.path.basename(output_filename))
130
131	# generate the filenames for these files
132	def_file = os.path.join(temp_dir, dll_name + ".def")
133
134	# Generate .def file
135	contents = [
136	"LIBRARY %s INITINSTANCE TERMINSTANCE" % \
137	os.path.splitext(os.path.basename(output_filename))[0],
138	"DATA MULTIPLE NONSHARED",
139	"EXPORTS"]
140	for sym in export_symbols:
141	contents.append(' "%s"' % sym)
142	self.execute(write_file, (def_file, contents),
143	"writing %s" % def_file)
144
145	# next add options for def-file and to creating import libraries
146	# for gcc/ld the def-file is specified as any other object files
147	objects.append(def_file)
148
149	#end: if ((export_symbols is not None) and
150	# (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
151
152	# who wants symbols and a many times larger output file
153	# should explicitly switch the debug mode on
154	# otherwise we let dllwrap/ld strip the output file
155	# (On my machine: 10KB < stripped_file < ??100KB
156	# unstripped_file = stripped_file + XXX KB
157	# ( XXX=254 for a typical python extension))
158	if not debug:
159	extra_preargs.append("-s")
160
161	UnixCCompiler.link(self,
162	target_desc,
163	objects,
164	output_filename,
165	output_dir,
166	libraries,
167	library_dirs,
168	runtime_library_dirs,
169	None, # export_symbols, we do this in our def-file
170	debug,
171	extra_preargs,
172	extra_postargs,
173	build_temp,
174	target_lang)
175
176	# link ()
177
178	# -- Miscellaneous methods -----------------------------------------
179
180	# override the object_filenames method from CCompiler to
181	# support rc and res-files
182	def object_filenames (self,
183	source_filenames,
184	strip_dir=0,
185	output_dir=''):
186	if output_dir is None: output_dir = ''
187	obj_names = []
188	for src_name in source_filenames:
189	# use normcase to make sure '.rc' is really '.rc' and not '.RC'
190	(base, ext) = os.path.splitext (os.path.normcase(src_name))
191	if ext not in (self.src_extensions + ['.rc']):
192	raise UnknownFileError, \
193	"unknown file type '%s' (from '%s')" % \
194	(ext, src_name)
195	if strip_dir:
196	base = os.path.basename (base)
197	if ext == '.rc':
198	# these need to be compiled to object files
199	obj_names.append (os.path.join (output_dir,
200	base + self.res_extension))
201	else:
202	obj_names.append (os.path.join (output_dir,
203	base + self.obj_extension))
204	return obj_names
205
206	# object_filenames ()
207
208	# override the find_library_file method from UnixCCompiler
209	# to deal with file naming/searching differences
210	def find_library_file(self, dirs, lib, debug=0):
211	shortlib = '%s.lib' % lib
212	longlib = 'lib%s.lib' % lib # this form very rare
213
214	# get EMX's default library directory search path
215	try:
216	emx_dirs = os.environ['LIBRARY_PATH'].split(';')
217	except KeyError:
218	emx_dirs = []
219
220	for dir in dirs + emx_dirs:
221	shortlibp = os.path.join(dir, shortlib)
222	longlibp = os.path.join(dir, longlib)
223	if os.path.exists(shortlibp):
224	return shortlibp
225	elif os.path.exists(longlibp):
226	return longlibp
227
228	# Oops, didn't find it in any of 'dirs'
229	return None
230
231	# class EMXCCompiler
232
233
234	# Because these compilers aren't configured in Python's pyconfig.h file by
235	# default, we should at least warn the user if he is using a unmodified
236	# version.
237
238	CONFIG_H_OK = "ok"
239	CONFIG_H_NOTOK = "not ok"
240	CONFIG_H_UNCERTAIN = "uncertain"
241
242	def check_config_h():
243
244	"""Check if the current Python installation (specifically, pyconfig.h)
245	appears amenable to building extensions with GCC. Returns a tuple
246	(status, details), where 'status' is one of the following constants:
247	CONFIG_H_OK
248	all is well, go ahead and compile
249	CONFIG_H_NOTOK
250	doesn't look good
251	CONFIG_H_UNCERTAIN
252	not sure -- unable to read pyconfig.h
253	'details' is a human-readable string explaining the situation.
254
255	Note there are two ways to conclude "OK": either 'sys.version' contains
256	the string "GCC" (implying that this Python was built with GCC), or the
257	installed "pyconfig.h" contains the string "__GNUC__".
258	"""
259
260	# XXX since this function also checks sys.version, it's not strictly a
261	# "pyconfig.h" check -- should probably be renamed...
262
263	from distutils import sysconfig
264	import string
265	# if sys.version contains GCC then python was compiled with
266	# GCC, and the pyconfig.h file should be OK
267	if string.find(sys.version,"GCC") >= 0:
268	return (CONFIG_H_OK, "sys.version mentions 'GCC'")
269
270	fn = sysconfig.get_config_h_filename()
271	try:
272	# It would probably better to read single lines to search.
273	# But we do this only once, and it is fast enough
274	f = open(fn)
275	s = f.read()
276	f.close()
277
278	except IOError, exc:
279	# if we can't read this file, we cannot say it is wrong
280	# the compiler will complain later about this file as missing
281	return (CONFIG_H_UNCERTAIN,
282	"couldn't read '%s': %s" % (fn, exc.strerror))
283
284	else:
285	# "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
286	if string.find(s,"__GNUC__") >= 0:
287	return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
288	else:
289	return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
290
291
292	def get_versions():
293	""" Try to find out the versions of gcc and ld.
294	If not possible it returns None for it.
295	"""
296	from distutils.version import StrictVersion
297	from distutils.spawn import find_executable
298	import re
299
300	gcc_exe = find_executable('gcc')
301	if gcc_exe:
302	out = os.popen(gcc_exe + ' -dumpversion','r')
303	out_string = out.read()
304	out.close()
305	result = re.search('(\d+\.\d+\.\d+)',out_string)
306	if result:
307	gcc_version = StrictVersion(result.group(1))
308	else:
309	gcc_version = None
310	else:
311	gcc_version = None
312	# EMX ld has no way of reporting version number, and we use GCC
313	# anyway - so we can link OMF DLLs
314	ld_version = None
315	return (gcc_version, ld_version)