Home | History | Annotate | Download | only in distutils
      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