source: python/trunk/Lib/distutils/emxccompiler.py@ 10

Last change on this file since 10 was 10, checked in by Yuri Dario, 15 years ago

python: merged offline changes.
  • Property svn:eol-style set to native
File size: 11.6 KB
Line 
1"""distutils.emxccompiler
2
3Provides the EMXCCompiler class, a subclass of UnixCCompiler that
4handles 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: emxccompiler.py 34786 2003-12-02 12:17:59Z aimacintyre $"
23
24import os,sys,copy
25from distutils.ccompiler import gen_preprocess_options, gen_lib_options
26from distutils.unixccompiler import UnixCCompiler
27from distutils.file_util import write_file
28from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
29from distutils import log
30
31class 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 -g -O2 -march=i386 -mtune=i686 -fomit-frame-pointer -Wall',
67 compiler_so='gcc -g -O2 -march=i386 -mtune=i686 -fomit-frame-pointer -Wall',
68 linker_exe='gcc -Zomf -Zexe',
69 linker_so='gcc -Zomf -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 try_names = [lib + ".lib", lib + ".a", "lib" + lib + ".lib", "lib" + lib + ".a"]
212
213 # get EMX's default library directory search path
214 try:
215 emx_dirs = os.environ['LIBRARY_PATH'].split(';')
216 except KeyError:
217 emx_dirs = []
218
219 #print "dirs:",dirs
220 for dir in dirs + emx_dirs:
221 for name in try_names:
222 libfile = os.path.join(dir, name)
223 #print "libfile:",libfile
224 if os.path.exists(libfile):
225 return libfile
226
227 # Oops, didn't find it in *any* of 'dirs'
228 return None
229
230# class EMXCCompiler
231
232
233# Because these compilers aren't configured in Python's pyconfig.h file by
234# default, we should at least warn the user if he is using a unmodified
235# version.
236
237CONFIG_H_OK = "ok"
238CONFIG_H_NOTOK = "not ok"
239CONFIG_H_UNCERTAIN = "uncertain"
240
241def check_config_h():
242
243 """Check if the current Python installation (specifically, pyconfig.h)
244 appears amenable to building extensions with GCC. Returns a tuple
245 (status, details), where 'status' is one of the following constants:
246 CONFIG_H_OK
247 all is well, go ahead and compile
248 CONFIG_H_NOTOK
249 doesn't look good
250 CONFIG_H_UNCERTAIN
251 not sure -- unable to read pyconfig.h
252 'details' is a human-readable string explaining the situation.
253
254 Note there are two ways to conclude "OK": either 'sys.version' contains
255 the string "GCC" (implying that this Python was built with GCC), or the
256 installed "pyconfig.h" contains the string "__GNUC__".
257 """
258
259 # XXX since this function also checks sys.version, it's not strictly a
260 # "pyconfig.h" check -- should probably be renamed...
261
262 from distutils import sysconfig
263 import string
264 # if sys.version contains GCC then python was compiled with
265 # GCC, and the pyconfig.h file should be OK
266 if string.find(sys.version,"GCC") >= 0:
267 return (CONFIG_H_OK, "sys.version mentions 'GCC'")
268
269 fn = sysconfig.get_config_h_filename()
270 try:
271 # It would probably better to read single lines to search.
272 # But we do this only once, and it is fast enough
273 f = open(fn)
274 s = f.read()
275 f.close()
276
277 except IOError, exc:
278 # if we can't read this file, we cannot say it is wrong
279 # the compiler will complain later about this file as missing
280 return (CONFIG_H_UNCERTAIN,
281 "couldn't read '%s': %s" % (fn, exc.strerror))
282
283 else:
284 # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
285 if string.find(s,"__GNUC__") >= 0:
286 return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
287 else:
288 return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
289
290
291def get_versions():
292 """ Try to find out the versions of gcc and ld.
293 If not possible it returns None for it.
294 """
295 from distutils.version import StrictVersion
296 from distutils.spawn import find_executable
297 import re
298
299 gcc_exe = find_executable('gcc')
300 if gcc_exe:
301 out = os.popen(gcc_exe + ' -dumpversion','r')
302 out_string = out.read()
303 out.close()
304 result = re.search('(\d+\.\d+\.\d+)',out_string)
305 if result:
306 gcc_version = StrictVersion(result.group(1))
307 else:
308 gcc_version = None
309 else:
310 gcc_version = None
311 # EMX ld has no way of reporting version number, and we use GCC
312 # anyway - so we can link OMF DLLs
313 ld_version = None
314 return (gcc_version, ld_version)
Note: See TracBrowser for help on using the repository browser.