"""distutils.ccompiler

Contains CCompiler, an abstract base class that defines the interface

for the Distutils compiler abstraction model."""

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id: ccompiler.py 60923 2008-02-21 18:18:37Z guido.van.rossum $"

import sys, os, re

from types import *

from copy import copy

from distutils.errors import *

from distutils.spawn import spawn

from distutils.file_util import move_file

from distutils.dir_util import mkpath

from distutils.dep_util import newer_pairwise, newer_group

from distutils.util import split_quoted, execute

from distutils import log

class CCompiler:

    """Abstract base class to define the interface that must be implemented

    by real compiler classes.  Also has some utility methods used by

    several compiler classes.

    The basic idea behind a compiler abstraction class is that each

    instance can be used for all the compile/link steps in building a

    single project.  Thus, attributes common to all of those compile and

    link steps -- include directories, macros to define, libraries to link

    against, etc. -- are attributes of the compiler instance.  To allow for

    variability in how individual files are treated, most of those

    attributes may be varied on a per-compilation or per-link basis.

    """

    # 'compiler_type' is a class attribute that identifies this class.  It

    # keeps code that wants to know what kind of compiler it's dealing with

    # from having to import all possible compiler classes just to do an

    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'

    # should really, really be one of the keys of the 'compiler_class'

    # dictionary (see below -- used by the 'new_compiler()' factory

    # function) -- authors of new compiler interface classes are

    # responsible for updating 'compiler_class'!

    compiler_type = None

    # XXX things not handled by this compiler abstraction model:

    #   * client can't provide additional options for a compiler,

    #     e.g. warning, optimization, debugging flags.  Perhaps this

    #     should be the domain of concrete compiler abstraction classes

    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base

    #     class should have methods for the common ones.

    #   * can't completely override the include or library searchg

    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".

    #     I'm not sure how widely supported this is even by Unix

    #     compilers, much less on other platforms.  And I'm even less

    #     sure how useful it is; maybe for cross-compiling, but

    #     support for that is a ways off.  (And anyways, cross

    #     compilers probably have a dedicated binary with the

    #     right paths compiled in.  I hope.)

    #   * can't do really freaky things with the library list/library

    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against

    #     different versions of libfoo.a in different locations.  I

    #     think this is useless without the ability to null out the

    #     library search path anyways.

    # Subclasses that rely on the standard filename generation methods

    # implemented below should override these; see the comment near

    # those methods ('object_filenames()' et. al.) for details:

    src_extensions = None               # list of strings

    obj_extension = None                # string

    static_lib_extension = None

    shared_lib_extension = None         # string

    static_lib_format = None            # format string

    shared_lib_format = None            # prob. same as static_lib_format

    exe_extension = None                # string

    # Default language settings. language_map is used to detect a source

    # file or Extension target language, checking source filenames.

    # language_order is used to detect the language precedence, when deciding

    # what language to use when mixing source types. For example, if some

    # extension has two files with ".c" extension, and one with ".cpp", it

    # is still linked as c++.

    language_map = {".c"   : "c",

                    ".cc"  : "c++",

                    ".cpp" : "c++",

                    ".cxx" : "c++",

                    ".m"   : "objc",

                   }

    language_order = ["c++", "objc", "c"]

    def __init__ (self,

                  verbose=0,

                  dry_run=0,

                  force=0):

        self.dry_run = dry_run

        self.force = force

        self.verbose = verbose

        # 'output_dir': a common output directory for object, library,

        # shared object, and shared library files

        self.output_dir = None

        # 'macros': a list of macro definitions (or undefinitions).  A

        # macro definition is a 2-tuple (name, value), where the value is

        # either a string or None (no explicit value).  A macro

        # undefinition is a 1-tuple (name,).

        self.macros = []

        # 'include_dirs': a list of directories to search for include files

        self.include_dirs = []

        # 'libraries': a list of libraries to include in any link

        # (library names, not filenames: eg. "foo" not "libfoo.a")

        self.libraries = []

        # 'library_dirs': a list of directories to search for libraries

        self.library_dirs = []

        # 'runtime_library_dirs': a list of directories to search for

        # shared libraries/objects at runtime

        self.runtime_library_dirs = []

        # 'objects': a list of object files (or similar, such as explicitly

        # named library files) to include on any link

        self.objects = []

        for key in self.executables.keys():

            self.set_executable(key, self.executables[key])

    # __init__ ()

    def set_executables (self, **args):

        """Define the executables (and options for them) that will be run

        to perform the various stages of compilation.  The exact set of

        executables that may be specified here depends on the compiler

        class (via the 'executables' class attribute), but most will have:

          compiler      the C/C++ compiler

          linker_so     linker used to create shared objects and libraries

          linker_exe    linker used to create binary executables

          archiver      static library creator

        On platforms with a command-line (Unix, DOS/Windows), each of these

        is a string that will be split into executable name and (optional)

        list of arguments.  (Splitting the string is done similarly to how

        Unix shells operate: words are delimited by spaces, but quotes and

        backslashes can override this.  See

        'distutils.util.split_quoted()'.)

        """

        # Note that some CCompiler implementation classes will define class

        # attributes 'cpp', 'cc', etc. with hard-coded executable names;

        # this is appropriate when a compiler class is for exactly one

        # compiler/OS combination (eg. MSVCCompiler).  Other compiler

        # classes (UnixCCompiler, in particular) are driven by information

        # discovered at run-time, since there are many different ways to do

        # basically the same things with Unix C compilers.

        for key in args.keys():

            if key not in self.executables:

                raise ValueError, \

                      "unknown executable '%s' for class %s" % \

                      (key, self.__class__.__name__)

            self.set_executable(key, args[key])

    # set_executables ()

    def set_executable(self, key, value):

        if type(value) is StringType:

            setattr(self, key, split_quoted(value))

        else:

            setattr(self, key, value)

    def _find_macro (self, name):

        i = 0

        for defn in self.macros:

            if defn[0] == name:

                return i

            i = i + 1

        return None

    def _check_macro_definitions (self, definitions):

        """Ensures that every element of 'definitions' is a valid macro

        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do

        nothing if all definitions are OK, raise TypeError otherwise.

        """

        for defn in definitions:

            if not (type (defn) is TupleType and

                    (len (defn) == 1 or

                     (len (defn) == 2 and

                      (type (defn[1]) is StringType or defn[1] is None))) and

                    type (defn[0]) is StringType):

                raise TypeError, \

                      ("invalid macro definition '%s': " % defn) + \

                      "must be tuple (string,), (string, string), or " + \

                      "(string, None)"

    # -- Bookkeeping methods -------------------------------------------

    def define_macro (self, name, value=None):

        """Define a preprocessor macro for all compilations driven by this

        compiler object.  The optional parameter 'value' should be a

        string; if it is not supplied, then the macro will be defined

        without an explicit value and the exact outcome depends on the

        compiler used (XXX true? does ANSI say anything about this?)

        """

        # Delete from the list of macro definitions/undefinitions if

        # already there (so that this one will take precedence).

        i = self._find_macro (name)

        if i is not None:

            del self.macros[i]

        defn = (name, value)

        self.macros.append (defn)

    def undefine_macro (self, name):

        """Undefine a preprocessor macro for all compilations driven by

        this compiler object.  If the same macro is defined by

        'define_macro()' and undefined by 'undefine_macro()' the last call

        takes precedence (including multiple redefinitions or

        undefinitions).  If the macro is redefined/undefined on a

        per-compilation basis (ie. in the call to 'compile()'), then that

        takes precedence.

        """

        # Delete from the list of macro definitions/undefinitions if

        # already there (so that this one will take precedence).

        i = self._find_macro (name)

        if i is not None:

            del self.macros[i]

        undefn = (name,)

        self.macros.append (undefn)

    def add_include_dir (self, dir):

        """Add 'dir' to the list of directories that will be searched for

        header files.  The compiler is instructed to search directories in

        the order in which they are supplied by successive calls to

        'add_include_dir()'.

        """

        self.include_dirs.append (dir)

    def set_include_dirs (self, dirs):

        """Set the list of directories that will be searched to 'dirs' (a

        list of strings).  Overrides any preceding calls to

        'add_include_dir()'; subsequence calls to 'add_include_dir()' add

        to the list passed to 'set_include_dirs()'.  This does not affect

        any list of standard include directories that the compiler may

        search by default.

        """

        self.include_dirs = copy (dirs)

    def add_library (self, libname):

        """Add 'libname' to the list of libraries that will be included in

        all links driven by this compiler object.  Note that 'libname'

        should *not* be the name of a file containing a library, but the

        name of the library itself: the actual filename will be inferred by

        the linker, the compiler, or the compiler class (depending on the

        platform).

        The linker will be instructed to link against libraries in the

        order they were supplied to 'add_library()' and/or

        'set_libraries()'.  It is perfectly valid to duplicate library

        names; the linker will be instructed to link against libraries as

        many times as they are mentioned.

        """

        self.libraries.append (libname)

    def set_libraries (self, libnames):

        """Set the list of libraries to be included in all links driven by

        this compiler object to 'libnames' (a list of strings).  This does

        not affect any standard system libraries that the linker may

        include by default.

        """

        self.libraries = copy (libnames)

    def add_library_dir (self, dir):

        """Add 'dir' to the list of directories that will be searched for

        libraries specified to 'add_library()' and 'set_libraries()'.  The

        linker will be instructed to search for libraries in the order they

        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.

        """

        self.library_dirs.append (dir)

    def set_library_dirs (self, dirs):

        """Set the list of library search directories to 'dirs' (a list of

        strings).  This does not affect any standard library search path

        that the linker may search by default.

        """

        self.library_dirs = copy (dirs)

    def add_runtime_library_dir (self, dir):

        """Add 'dir' to the list of directories that will be searched for

        shared libraries at runtime.

        """

        self.runtime_library_dirs.append (dir)

    def set_runtime_library_dirs (self, dirs):

        """Set the list of directories to search for shared libraries at

        runtime to 'dirs' (a list of strings).  This does not affect any

        standard search path that the runtime linker may search by

        default.

        """

        self.runtime_library_dirs = copy (dirs)

    def add_link_object (self, object):

        """Add 'object' to the list of object files (or analogues, such as

        explicitly named library files or the output of "resource

        compilers") to be included in every link driven by this compiler

        object.

        """

        self.objects.append (object)

    def set_link_objects (self, objects):

        """Set the list of object files (or analogues) to be included in

        every link to 'objects'.  This does not affect any standard object

        files that the linker may include by default (such as system

        libraries).

        """

        self.objects = copy (objects)

    # -- Private utility methods --------------------------------------

    # (here for the convenience of subclasses)

    # Helper method to prep compiler in subclass compile() methods

    def _setup_compile(self, outdir, macros, incdirs, sources, depends,

                       extra):

        """Process arguments and decide which source files to compile.

        Merges _fix_compile_args() and _prep_compile().

        """

        if outdir is None:

            outdir = self.output_dir

        elif type(outdir) is not StringType:

            raise TypeError, "'output_dir' must be a string or None"

        if macros is None:

            macros = self.macros

        elif type(macros) is ListType:

            macros = macros + (self.macros or [])

        else:

            raise TypeError, "'macros' (if supplied) must be a list of tuples"

        if incdirs is None:

            incdirs = self.include_dirs

        elif type(incdirs) in (ListType, TupleType):

            incdirs = list(incdirs) + (self.include_dirs or [])

        else:

            raise TypeError, \

                  "'include_dirs' (if supplied) must be a list of strings"

        if extra is None:

            extra = []

        # Get the list of expected output (object) files

        objects = self.object_filenames(sources,

                                        strip_dir=0,

                                        output_dir=outdir)

        assert len(objects) == len(sources)

        # XXX should redo this code to eliminate skip_source entirely.

        # XXX instead create build and issue skip messages inline

        if self.force:

            skip_source = {}            # rebuild everything

            for source in sources:

                skip_source[source] = 0

        elif depends is None:

            # If depends is None, figure out which source files we

            # have to recompile according to a simplistic check. We

            # just compare the source and object file, no deep

            # dependency checking involving header files.

            skip_source = {}            # rebuild everything

            for source in sources:      # no wait, rebuild nothing

                skip_source[source] = 1

            n_sources, n_objects = newer_pairwise(sources, objects)

            for source in n_sources:    # no really, only rebuild what's

                skip_source[source] = 0 # out-of-date

        else:

            # If depends is a list of files, then do a different

            # simplistic check.  Assume that each object depends on

            # its source and all files in the depends list.

            skip_source = {}

            # L contains all the depends plus a spot at the end for a

            # particular source file

            L = depends[:] + [None]

            for i in range(len(objects)):

                source = sources[i]

                L[-1] = source

                if newer_group(L, objects[i]):

                    skip_source[source] = 0

                else:

                    skip_source[source] = 1

        pp_opts = gen_preprocess_options(macros, incdirs)

        build = {}

        for i in range(len(sources)):

            src = sources[i]

            obj = objects[i]

            ext = os.path.splitext(src)[1]

            self.mkpath(os.path.dirname(obj))

            if skip_source[src]:

                log.debug("skipping %s (%s up-to-date)", src, obj)

            else:

                build[obj] = src, ext

        return macros, objects, extra, pp_opts, build

    def _get_cc_args(self, pp_opts, debug, before):

        # works for unixccompiler, emxccompiler, cygwinccompiler

        cc_args = pp_opts + ['-c']

        if debug:

            cc_args[:0] = ['-g']

        if before:

            cc_args[:0] = before

        return cc_args

    def _fix_compile_args (self, output_dir, macros, include_dirs):

        """Typecheck and fix-up some of the arguments to the 'compile()'

        method, and return fixed-up values.  Specifically: if 'output_dir'

        is None, replaces it with 'self.output_dir'; ensures that 'macros'

        is a list, and augments it with 'self.macros'; ensures that

        'include_dirs' is a list, and augments it with 'self.include_dirs'.

        Guarantees that the returned values are of the correct type,

        i.e. for 'output_dir' either string or None, and for 'macros' and

        'include_dirs' either list or None.

        """

        if output_dir is None:

            output_dir = self.output_dir

        elif type (output_dir) is not StringType:

            raise TypeError, "'output_dir' must be a string or None"

        if macros is None:

            macros = self.macros

        elif type (macros) is ListType:

            macros = macros + (self.macros or [])

        else:

            raise TypeError, "'macros' (if supplied) must be a list of tuples"

        if include_dirs is None:

            include_dirs = self.include_dirs

        elif type (include_dirs) in (ListType, TupleType):

            include_dirs = list (include_dirs) + (self.include_dirs or [])

        else:

            raise TypeError, \

                  "'include_dirs' (if supplied) must be a list of strings"

        return output_dir, macros, include_dirs

    # _fix_compile_args ()

    def _prep_compile(self, sources, output_dir, depends=None):

        """Decide which souce files must be recompiled.

        Determine the list of object files corresponding to 'sources',

        and figure out which ones really need to be recompiled.

        Return a list of all object files and a dictionary telling

        which source files can be skipped.

        """

        # Get the list of expected output (object) files

        objects = self.object_filenames(sources, output_dir=output_dir)

        assert len(objects) == len(sources)

        if self.force:

            skip_source = {}            # rebuild everything

            for source in sources:

                skip_source[source] = 0

        elif depends is None:

            # If depends is None, figure out which source files we

            # have to recompile according to a simplistic check. We

            # just compare the source and object file, no deep

            # dependency checking involving header files.

            skip_source = {}            # rebuild everything

            for source in sources:      # no wait, rebuild nothing

                skip_source[source] = 1

            n_sources, n_objects = newer_pairwise(sources, objects)

            for source in n_sources:    # no really, only rebuild what's

                skip_source[source] = 0 # out-of-date

        else:

            # If depends is a list of files, then do a different

            # simplistic check.  Assume that each object depends on

            # its source and all files in the depends list.

            skip_source = {}

            # L contains all the depends plus a spot at the end for a

            # particular source file

            L = depends[:] + [None]

            for i in range(len(objects)):

                source = sources[i]

                L[-1] = source

                if newer_group(L, objects[i]):

                    skip_source[source] = 0

                else:

                    skip_source[source] = 1

        return objects, skip_source

    # _prep_compile ()

    def _fix_object_args (self, objects, output_dir):

        """Typecheck and fix up some arguments supplied to various methods.

        Specifically: ensure that 'objects' is a list; if output_dir is

        None, replace with self.output_dir.  Return fixed versions of

        'objects' and 'output_dir'.

        """

        if type (objects) not in (ListType, TupleType):

            raise TypeError, \

                  "'objects' must be a list or tuple of strings"

        objects = list (objects)

        if output_dir is None: