source: python/vendor/Python-2.7.6/Lib/distutils/emxccompiler.py

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 11.7 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$"
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 -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall',
67 compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -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
238CONFIG_H_OK = "ok"
239CONFIG_H_NOTOK = "not ok"
240CONFIG_H_UNCERTAIN = "uncertain"
241
242def 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 try:
276 s = f.read()
277 finally:
278 f.close()
279
280 except IOError, exc:
281 # if we can't read this file, we cannot say it is wrong
282 # the compiler will complain later about this file as missing
283 return (CONFIG_H_UNCERTAIN,
284 "couldn't read '%s': %s" % (fn, exc.strerror))
285
286 else:
287 # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
288 if string.find(s,"__GNUC__") >= 0:
289 return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
290 else:
291 return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
292
293
294def get_versions():
295 """ Try to find out the versions of gcc and ld.
296 If not possible it returns None for it.
297 """
298 from distutils.version import StrictVersion
299 from distutils.spawn import find_executable
300 import re
301
302 gcc_exe = find_executable('gcc')
303 if gcc_exe:
304 out = os.popen(gcc_exe + ' -dumpversion','r')
305 try:
306 out_string = out.read()
307 finally:
308 out.close()
309 result = re.search('(\d+\.\d+\.\d+)',out_string)
310 if result:
311 gcc_version = StrictVersion(result.group(1))
312 else:
313 gcc_version = None
314 else:
315 gcc_version = None
316 # EMX ld has no way of reporting version number, and we use GCC
317 # anyway - so we can link OMF DLLs
318 ld_version = None
319 return (gcc_version, ld_version)
Note: See TracBrowser for help on using the repository browser.