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