|
1 """distutils.unixccompiler |
|
2 |
|
3 Contains the UnixCCompiler class, a subclass of CCompiler that handles |
|
4 the "typical" Unix-style command-line C compiler: |
|
5 * macros defined with -Dname[=value] |
|
6 * macros undefined with -Uname |
|
7 * include search directories specified with -Idir |
|
8 * libraries specified with -lllib |
|
9 * library search directories specified with -Ldir |
|
10 * compile handled by 'cc' (or similar) executable with -c option: |
|
11 compiles .c to .o |
|
12 * link static library handled by 'ar' command (possibly with 'ranlib') |
|
13 * link shared library handled by 'cc -shared' |
|
14 """ |
|
15 |
|
16 __revision__ = "$Id: unixccompiler.py 65012 2008-07-16 13:24:06Z jesse.noller $" |
|
17 |
|
18 import os, sys |
|
19 from types import StringType, NoneType |
|
20 |
|
21 from distutils import sysconfig |
|
22 from distutils.dep_util import newer |
|
23 from distutils.ccompiler import \ |
|
24 CCompiler, gen_preprocess_options, gen_lib_options |
|
25 from distutils.errors import \ |
|
26 DistutilsExecError, CompileError, LibError, LinkError |
|
27 from distutils import log |
|
28 |
|
29 # XXX Things not currently handled: |
|
30 # * optimization/debug/warning flags; we just use whatever's in Python's |
|
31 # Makefile and live with it. Is this adequate? If not, we might |
|
32 # have to have a bunch of subclasses GNUCCompiler, SGICCompiler, |
|
33 # SunCCompiler, and I suspect down that road lies madness. |
|
34 # * even if we don't know a warning flag from an optimization flag, |
|
35 # we need some way for outsiders to feed preprocessor/compiler/linker |
|
36 # flags in to us -- eg. a sysadmin might want to mandate certain flags |
|
37 # via a site config file, or a user might want to set something for |
|
38 # compiling this module distribution only via the setup.py command |
|
39 # line, whatever. As long as these options come from something on the |
|
40 # current system, they can be as system-dependent as they like, and we |
|
41 # should just happily stuff them into the preprocessor/compiler/linker |
|
42 # options and carry on. |
|
43 |
|
44 def _darwin_compiler_fixup(compiler_so, cc_args): |
|
45 """ |
|
46 This function will strip '-isysroot PATH' and '-arch ARCH' from the |
|
47 compile flags if the user has specified one them in extra_compile_flags. |
|
48 |
|
49 This is needed because '-arch ARCH' adds another architecture to the |
|
50 build, without a way to remove an architecture. Furthermore GCC will |
|
51 barf if multiple '-isysroot' arguments are present. |
|
52 """ |
|
53 stripArch = stripSysroot = 0 |
|
54 |
|
55 compiler_so = list(compiler_so) |
|
56 kernel_version = os.uname()[2] # 8.4.3 |
|
57 major_version = int(kernel_version.split('.')[0]) |
|
58 |
|
59 if major_version < 8: |
|
60 # OSX before 10.4.0, these don't support -arch and -isysroot at |
|
61 # all. |
|
62 stripArch = stripSysroot = True |
|
63 else: |
|
64 stripArch = '-arch' in cc_args |
|
65 stripSysroot = '-isysroot' in cc_args |
|
66 |
|
67 if stripArch or 'ARCHFLAGS' in os.environ: |
|
68 while 1: |
|
69 try: |
|
70 index = compiler_so.index('-arch') |
|
71 # Strip this argument and the next one: |
|
72 del compiler_so[index:index+2] |
|
73 except ValueError: |
|
74 break |
|
75 |
|
76 if 'ARCHFLAGS' in os.environ and not stripArch: |
|
77 # User specified different -arch flags in the environ, |
|
78 # see also distutils.sysconfig |
|
79 compiler_so = compiler_so + os.environ['ARCHFLAGS'].split() |
|
80 |
|
81 if stripSysroot: |
|
82 try: |
|
83 index = compiler_so.index('-isysroot') |
|
84 # Strip this argument and the next one: |
|
85 del compiler_so[index:index+2] |
|
86 except ValueError: |
|
87 pass |
|
88 |
|
89 # Check if the SDK that is used during compilation actually exists, |
|
90 # the universal build requires the usage of a universal SDK and not all |
|
91 # users have that installed by default. |
|
92 sysroot = None |
|
93 if '-isysroot' in cc_args: |
|
94 idx = cc_args.index('-isysroot') |
|
95 sysroot = cc_args[idx+1] |
|
96 elif '-isysroot' in compiler_so: |
|
97 idx = compiler_so.index('-isysroot') |
|
98 sysroot = compiler_so[idx+1] |
|
99 |
|
100 if sysroot and not os.path.isdir(sysroot): |
|
101 log.warn("Compiling with an SDK that doesn't seem to exist: %s", |
|
102 sysroot) |
|
103 log.warn("Please check your Xcode installation") |
|
104 |
|
105 return compiler_so |
|
106 |
|
107 class UnixCCompiler(CCompiler): |
|
108 |
|
109 compiler_type = 'unix' |
|
110 |
|
111 # These are used by CCompiler in two places: the constructor sets |
|
112 # instance attributes 'preprocessor', 'compiler', etc. from them, and |
|
113 # 'set_executable()' allows any of these to be set. The defaults here |
|
114 # are pretty generic; they will probably have to be set by an outsider |
|
115 # (eg. using information discovered by the sysconfig about building |
|
116 # Python extensions). |
|
117 executables = {'preprocessor' : None, |
|
118 'compiler' : ["cc"], |
|
119 'compiler_so' : ["cc"], |
|
120 'compiler_cxx' : ["cc"], |
|
121 'linker_so' : ["cc", "-shared"], |
|
122 'linker_exe' : ["cc"], |
|
123 'archiver' : ["ar", "-cr"], |
|
124 'ranlib' : None, |
|
125 } |
|
126 |
|
127 if sys.platform[:6] == "darwin": |
|
128 executables['ranlib'] = ["ranlib"] |
|
129 |
|
130 # Needed for the filename generation methods provided by the base |
|
131 # class, CCompiler. NB. whoever instantiates/uses a particular |
|
132 # UnixCCompiler instance should set 'shared_lib_ext' -- we set a |
|
133 # reasonable common default here, but it's not necessarily used on all |
|
134 # Unices! |
|
135 |
|
136 src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"] |
|
137 obj_extension = ".o" |
|
138 static_lib_extension = ".a" |
|
139 shared_lib_extension = ".so" |
|
140 dylib_lib_extension = ".dylib" |
|
141 static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s" |
|
142 if sys.platform == "cygwin": |
|
143 exe_extension = ".exe" |
|
144 |
|
145 def preprocess(self, source, |
|
146 output_file=None, macros=None, include_dirs=None, |
|
147 extra_preargs=None, extra_postargs=None): |
|
148 ignore, macros, include_dirs = \ |
|
149 self._fix_compile_args(None, macros, include_dirs) |
|
150 pp_opts = gen_preprocess_options(macros, include_dirs) |
|
151 pp_args = self.preprocessor + pp_opts |
|
152 if output_file: |
|
153 pp_args.extend(['-o', output_file]) |
|
154 if extra_preargs: |
|
155 pp_args[:0] = extra_preargs |
|
156 if extra_postargs: |
|
157 pp_args.extend(extra_postargs) |
|
158 pp_args.append(source) |
|
159 |
|
160 # We need to preprocess: either we're being forced to, or we're |
|
161 # generating output to stdout, or there's a target output file and |
|
162 # the source file is newer than the target (or the target doesn't |
|
163 # exist). |
|
164 if self.force or output_file is None or newer(source, output_file): |
|
165 if output_file: |
|
166 self.mkpath(os.path.dirname(output_file)) |
|
167 try: |
|
168 self.spawn(pp_args) |
|
169 except DistutilsExecError, msg: |
|
170 raise CompileError, msg |
|
171 |
|
172 def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): |
|
173 compiler_so = self.compiler_so |
|
174 if sys.platform == 'darwin': |
|
175 compiler_so = _darwin_compiler_fixup(compiler_so, cc_args + extra_postargs) |
|
176 try: |
|
177 self.spawn(compiler_so + cc_args + [src, '-o', obj] + |
|
178 extra_postargs) |
|
179 except DistutilsExecError, msg: |
|
180 raise CompileError, msg |
|
181 |
|
182 def create_static_lib(self, objects, output_libname, |
|
183 output_dir=None, debug=0, target_lang=None): |
|
184 objects, output_dir = self._fix_object_args(objects, output_dir) |
|
185 |
|
186 output_filename = \ |
|
187 self.library_filename(output_libname, output_dir=output_dir) |
|
188 |
|
189 if self._need_link(objects, output_filename): |
|
190 self.mkpath(os.path.dirname(output_filename)) |
|
191 self.spawn(self.archiver + |
|
192 [output_filename] + |
|
193 objects + self.objects) |
|
194 |
|
195 # Not many Unices required ranlib anymore -- SunOS 4.x is, I |
|
196 # think the only major Unix that does. Maybe we need some |
|
197 # platform intelligence here to skip ranlib if it's not |
|
198 # needed -- or maybe Python's configure script took care of |
|
199 # it for us, hence the check for leading colon. |
|
200 if self.ranlib: |
|
201 try: |
|
202 self.spawn(self.ranlib + [output_filename]) |
|
203 except DistutilsExecError, msg: |
|
204 raise LibError, msg |
|
205 else: |
|
206 log.debug("skipping %s (up-to-date)", output_filename) |
|
207 |
|
208 def link(self, target_desc, objects, |
|
209 output_filename, output_dir=None, libraries=None, |
|
210 library_dirs=None, runtime_library_dirs=None, |
|
211 export_symbols=None, debug=0, extra_preargs=None, |
|
212 extra_postargs=None, build_temp=None, target_lang=None): |
|
213 objects, output_dir = self._fix_object_args(objects, output_dir) |
|
214 libraries, library_dirs, runtime_library_dirs = \ |
|
215 self._fix_lib_args(libraries, library_dirs, runtime_library_dirs) |
|
216 |
|
217 lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, |
|
218 libraries) |
|
219 if type(output_dir) not in (StringType, NoneType): |
|
220 raise TypeError, "'output_dir' must be a string or None" |
|
221 if output_dir is not None: |
|
222 output_filename = os.path.join(output_dir, output_filename) |
|
223 |
|
224 if self._need_link(objects, output_filename): |
|
225 ld_args = (objects + self.objects + |
|
226 lib_opts + ['-o', output_filename]) |
|
227 if debug: |
|
228 ld_args[:0] = ['-g'] |
|
229 if extra_preargs: |
|
230 ld_args[:0] = extra_preargs |
|
231 if extra_postargs: |
|
232 ld_args.extend(extra_postargs) |
|
233 self.mkpath(os.path.dirname(output_filename)) |
|
234 try: |
|
235 if target_desc == CCompiler.EXECUTABLE: |
|
236 linker = self.linker_exe[:] |
|
237 else: |
|
238 linker = self.linker_so[:] |
|
239 if target_lang == "c++" and self.compiler_cxx: |
|
240 # skip over environment variable settings if /usr/bin/env |
|
241 # is used to set up the linker's environment. |
|
242 # This is needed on OSX. Note: this assumes that the |
|
243 # normal and C++ compiler have the same environment |
|
244 # settings. |
|
245 i = 0 |
|
246 if os.path.basename(linker[0]) == "env": |
|
247 i = 1 |
|
248 while '=' in linker[i]: |
|
249 i = i + 1 |
|
250 |
|
251 linker[i] = self.compiler_cxx[i] |
|
252 |
|
253 if sys.platform == 'darwin': |
|
254 linker = _darwin_compiler_fixup(linker, ld_args) |
|
255 |
|
256 self.spawn(linker + ld_args) |
|
257 except DistutilsExecError, msg: |
|
258 raise LinkError, msg |
|
259 else: |
|
260 log.debug("skipping %s (up-to-date)", output_filename) |
|
261 |
|
262 # -- Miscellaneous methods ----------------------------------------- |
|
263 # These are all used by the 'gen_lib_options() function, in |
|
264 # ccompiler.py. |
|
265 |
|
266 def library_dir_option(self, dir): |
|
267 return "-L" + dir |
|
268 |
|
269 def runtime_library_dir_option(self, dir): |
|
270 # XXX Hackish, at the very least. See Python bug #445902: |
|
271 # http://sourceforge.net/tracker/index.php |
|
272 # ?func=detail&aid=445902&group_id=5470&atid=105470 |
|
273 # Linkers on different platforms need different options to |
|
274 # specify that directories need to be added to the list of |
|
275 # directories searched for dependencies when a dynamic library |
|
276 # is sought. GCC has to be told to pass the -R option through |
|
277 # to the linker, whereas other compilers just know this. |
|
278 # Other compilers may need something slightly different. At |
|
279 # this time, there's no way to determine this information from |
|
280 # the configuration data stored in the Python installation, so |
|
281 # we use this hack. |
|
282 compiler = os.path.basename(sysconfig.get_config_var("CC")) |
|
283 if sys.platform[:6] == "darwin": |
|
284 # MacOSX's linker doesn't understand the -R flag at all |
|
285 return "-L" + dir |
|
286 elif sys.platform[:5] == "hp-ux": |
|
287 return "+s -L" + dir |
|
288 elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5": |
|
289 return ["-rpath", dir] |
|
290 elif compiler[:3] == "gcc" or compiler[:3] == "g++": |
|
291 return "-Wl,-R" + dir |
|
292 else: |
|
293 return "-R" + dir |
|
294 |
|
295 def library_option(self, lib): |
|
296 return "-l" + lib |
|
297 |
|
298 def find_library_file(self, dirs, lib, debug=0): |
|
299 shared_f = self.library_filename(lib, lib_type='shared') |
|
300 dylib_f = self.library_filename(lib, lib_type='dylib') |
|
301 static_f = self.library_filename(lib, lib_type='static') |
|
302 |
|
303 for dir in dirs: |
|
304 shared = os.path.join(dir, shared_f) |
|
305 dylib = os.path.join(dir, dylib_f) |
|
306 static = os.path.join(dir, static_f) |
|
307 # We're second-guessing the linker here, with not much hard |
|
308 # data to go on: GCC seems to prefer the shared library, so I'm |
|
309 # assuming that *all* Unix C compilers do. And of course I'm |
|
310 # ignoring even GCC's "-static" option. So sue me. |
|
311 if os.path.exists(dylib): |
|
312 return dylib |
|
313 elif os.path.exists(shared): |
|
314 return shared |
|
315 elif os.path.exists(static): |
|
316 return static |
|
317 |
|
318 # Oops, didn't find it in *any* of 'dirs' |
|
319 return None |