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 self.mkpath(os.path.dirname(output_filename)) 176 try: 177 if target_desc == CCompiler.EXECUTABLE: 178 linker = self.linker_exe[:] 179 else: 180 linker = self.linker_so[:] 181 if target_lang == "c++" and self.compiler_cxx: 182 # skip over environment variable settings if /usr/bin/env 183 # is used to set up the linker's environment. 184 # This is needed on OSX. Note: this assumes that the 185 # normal and C++ compiler have the same environment 186 # settings. 187 i = 0 188 if os.path.basename(linker[0]) == "env": 189 i = 1 190 while '=' in linker[i]: 191 i = i + 1 192 193 linker[i] = self.compiler_cxx[i] 194 195 if sys.platform == 'darwin': 196 linker = _osx_support.compiler_fixup(linker, ld_args) 197 198 self.spawn(linker + ld_args) 199 except DistutilsExecError, msg: 200 raise LinkError, msg 201 else: 202 log.debug("skipping %s (up-to-date)", output_filename) 203 204 # -- Miscellaneous methods ----------------------------------------- 205 # These are all used by the 'gen_lib_options() function, in 206 # ccompiler.py. 207 208 def library_dir_option(self, dir): 209 return "-L" + dir 210 211 def _is_gcc(self, compiler_name): 212 return "gcc" in compiler_name or "g++" in compiler_name 213 214 def runtime_library_dir_option(self, dir): 215 # XXX Hackish, at the very least. See Python bug #445902: 216 # http://sourceforge.net/tracker/index.php 217 # ?func=detail&aid=445902&group_id=5470&atid=105470 218 # Linkers on different platforms need different options to 219 # specify that directories need to be added to the list of 220 # directories searched for dependencies when a dynamic library 221 # is sought. GCC has to be told to pass the -R option through 222 # to the linker, whereas other compilers just know this. 223 # Other compilers may need something slightly different. At 224 # this time, there's no way to determine this information from 225 # the configuration data stored in the Python installation, so 226 # we use this hack. 227 compiler = os.path.basename(sysconfig.get_config_var("CC")) 228 if sys.platform[:6] == "darwin": 229 # MacOSX's linker doesn't understand the -R flag at all 230 return "-L" + dir 231 elif sys.platform[:5] == "hp-ux": 232 if self._is_gcc(compiler): 233 return ["-Wl,+s", "-L" + dir] 234 return ["+s", "-L" + dir] 235 elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5": 236 return ["-rpath", dir] 237 elif sys.platform[:3] == "aix": 238 return "-blibpath:" + dir 239 elif self._is_gcc(compiler): 240 return "-Wl,-R" + dir 241 else: 242 return "-R" + dir 243 244 def library_option(self, lib): 245 return "-l" + lib 246 247 def find_library_file(self, dirs, lib, debug=0): 248 shared_f = self.library_filename(lib, lib_type='shared') 249 dylib_f = self.library_filename(lib, lib_type='dylib') 250 static_f = self.library_filename(lib, lib_type='static') 251 252 if sys.platform == 'darwin': 253 # On OSX users can specify an alternate SDK using 254 # '-isysroot', calculate the SDK root if it is specified 255 # (and use it further on) 256 cflags = sysconfig.get_config_var('CFLAGS') 257 m = re.search(r'-isysroot\s+(\S+)', cflags) 258 if m is None: 259 sysroot = '/' 260 else: 261 sysroot = m.group(1) 262 263 264 265 for dir in dirs: 266 shared = os.path.join(dir, shared_f) 267 dylib = os.path.join(dir, dylib_f) 268 static = os.path.join(dir, static_f) 269 270 if sys.platform == 'darwin' and ( 271 dir.startswith('/System/') or ( 272 dir.startswith('/usr/') and not dir.startswith('/usr/local/'))): 273 274 shared = os.path.join(sysroot, dir[1:], shared_f) 275 dylib = os.path.join(sysroot, dir[1:], dylib_f) 276 static = os.path.join(sysroot, dir[1:], static_f) 277 278 # We're second-guessing the linker here, with not much hard 279 # data to go on: GCC seems to prefer the shared library, so I'm 280 # assuming that *all* Unix C compilers do. And of course I'm 281 # ignoring even GCC's "-static" option. So sue me. 282 if os.path.exists(dylib): 283 return dylib 284 elif os.path.exists(shared): 285 return shared 286 elif os.path.exists(static): 287 return static 288 289 # Oops, didn't find it in *any* of 'dirs' 290 return None 291
