Lib/distutils/unixccompiler.py

   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
  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 _is_gcc(self, compiler_name):
 270         return "gcc" in compiler_name or "g++" in compiler_name
 271
 272     def runtime_library_dir_option(self, dir):
 273         # XXX Hackish, at the very least.  See Python bug #445902:
 274         # http://sourceforge.net/tracker/index.php
 275         #   ?func=detail&aid=445902&group_id=5470&atid=105470
 276         # Linkers on different platforms need different options to
 277         # specify that directories need to be added to the list of
 278         # directories searched for dependencies when a dynamic library
 279         # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
 280         # be told to pass the -R option through to the linker, whereas
 281         # other compilers and gcc on other systems just know this.
 282         # Other compilers may need something slightly different.  At
 283         # this time, there's no way to determine this information from
 284         # the configuration data stored in the Python installation, so
 285         # we use this hack.
 286         compiler = os.path.basename(sysconfig.get_config_var("CC"))
 287         if sys.platform[:6] == "darwin":
 288             # MacOSX's linker doesn't understand the -R flag at all
 289             return "-L" + dir
 290         elif sys.platform[:5] == "hp-ux":
 291             if self._is_gcc(compiler):
 292                 return ["-Wl,+s", "-L" + dir]
 293             return ["+s", "-L" + dir]
 294         elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5":
 295             return ["-rpath", dir]
 296         elif self._is_gcc(compiler):
 297             # gcc on non-GNU systems does not need -Wl, but can
 298             # use it anyway.  Since distutils has always passed in
 299             # -Wl whenever gcc was used in the past it is probably
 300             # safest to keep doing so.
 301             if sysconfig.get_config_var("GNULD") == "yes":
 302                 # GNU ld needs an extra option to get a RUNPATH
 303                 # instead of just an RPATH.
 304                 return "-Wl,--enable-new-dtags,-R" + dir
 305             else:
 306                 return "-Wl,-R" + dir
 307         elif sys.platform[:3] == "aix":
 308             return "-blibpath:" + dir
 309         else:
 310             # No idea how --enable-new-dtags would be passed on to
 311             # ld if this system was using GNU ld.  Don't know if a
 312             # system like this even exists.
 313             return "-R" + dir
 314
 315     def library_option(self, lib):
 316         return "-l" + lib
 317
 318     def find_library_file(self, dirs, lib, debug=0):
 319         shared_f = self.library_filename(lib, lib_type='shared')
 320         dylib_f = self.library_filename(lib, lib_type='dylib')
 321         static_f = self.library_filename(lib, lib_type='static')
 322
 323         for dir in dirs:
 324             shared = os.path.join(dir, shared_f)
 325             dylib = os.path.join(dir, dylib_f)
 326             static = os.path.join(dir, static_f)
 327             # We're second-guessing the linker here, with not much hard
 328             # data to go on: GCC seems to prefer the shared library, so I'm
 329             # assuming that *all* Unix C compilers do.  And of course I'm
 330             # ignoring even GCC's "-static" option.  So sue me.
 331             if os.path.exists(dylib):
 332                 return dylib
 333             elif os.path.exists(shared):
 334                 return shared
 335             elif os.path.exists(static):
 336                 return static
 337
 338         # Oops, didn't find it in *any* of 'dirs'
 339         return None