FM / distutils

/opt/alt/python27/lib64/python2.7/distutils/

/opt/alt/python27/lib64/python2.7/distutils

Name	Size	Mode	Actions
command/	-	0755	rm
archive_util.py	8219	0644	edit dl rm
archive_util.pyc	7705	0644	edit dl rm
archive_util.pyo	7705	0644	edit dl rm
bcppcompiler.py	14941	0644	edit dl rm
bcppcompiler.pyc	7999	0644	edit dl rm
bcppcompiler.pyo	7999	0644	edit dl rm
ccompiler.py	46708	0644	edit dl rm
ccompiler.pyc	37579	0644	edit dl rm
ccompiler.pyo	37438	0644	edit dl rm
cmd.py	19270	0644	edit dl rm
cmd.pyc	17285	0644	edit dl rm
cmd.pyo	17285	0644	edit dl rm
config.py	4134	0644	edit dl rm
config.pyc	3656	0644	edit dl rm
config.pyo	3656	0644	edit dl rm
core.py	9019	0644	edit dl rm
core.pyc	7588	0644	edit dl rm
core.pyo	7588	0644	edit dl rm
cygwinccompiler.py	17735	0644	edit dl rm
cygwinccompiler.pyc	9981	0644	edit dl rm
cygwinccompiler.pyo	9981	0644	edit dl rm
debug.py	162	0644	edit dl rm
debug.pyc	267	0644	edit dl rm
debug.pyo	267	0644	edit dl rm
dep_util.py	3509	0644	edit dl rm
dep_util.pyc	3232	0644	edit dl rm
dep_util.pyo	3232	0644	edit dl rm
dir_util.py	7868	0644	edit dl rm
dir_util.pyc	6877	0644	edit dl rm
dir_util.pyo	6877	0644	edit dl rm
dist.py	50049	0644	edit dl rm
dist.pyc	40047	0644	edit dl rm
dist.pyo	40047	0644	edit dl rm
emxccompiler.py	11931	0644	edit dl rm
emxccompiler.pyc	7584	0644	edit dl rm
emxccompiler.pyo	7584	0644	edit dl rm
errors.py	3494	0644	edit dl rm
errors.pyc	6545	0644	edit dl rm
errors.pyo	6545	0644	edit dl rm
extension.py	10904	0644	edit dl rm
extension.pyc	7464	0644	edit dl rm
extension.pyo	7238	0644	edit dl rm
fancy_getopt.py	17948	0644	edit dl rm
fancy_getopt.pyc	12231	0644	edit dl rm
fancy_getopt.pyo	12054	0644	edit dl rm
filelist.py	12689	0644	edit dl rm
filelist.pyc	10977	0644	edit dl rm
filelist.pyo	10977	0644	edit dl rm
file_util.py	8131	0644	edit dl rm
file_util.pyc	6815	0644	edit dl rm
file_util.pyo	6815	0644	edit dl rm
log.py	1686	0644	edit dl rm
log.pyc	2942	0644	edit dl rm
log.pyo	2942	0644	edit dl rm
msvc9compiler.py	31004	0644	edit dl rm
msvc9compiler.pyc	21900	0644	edit dl rm
msvc9compiler.pyo	21827	0644	edit dl rm
msvccompiler.py	23637	0644	edit dl rm
msvccompiler.pyc	17863	0644	edit dl rm
msvccompiler.pyo	17863	0644	edit dl rm
README	295	0644	edit dl rm
spawn.py	8648	0644	edit dl rm
spawn.pyc	6518	0644	edit dl rm
spawn.pyo	6518	0644	edit dl rm
sysconfig.py	17298	0644	edit dl rm
sysconfig.py.debug-build	17210	0644	edit dl rm
sysconfig.pyc	13559	0644	edit dl rm
sysconfig.pyo	13559	0644	edit dl rm
text_file.py	12428	0644	edit dl rm
text_file.pyc	9402	0644	edit dl rm
text_file.pyo	9402	0644	edit dl rm
unixccompiler.py	14222	0644	edit dl rm
unixccompiler.py.distutils-rpath	13677	0644	edit dl rm
unixccompiler.pyc	8385	0644	edit dl rm
unixccompiler.pyo	8385	0644	edit dl rm
util.py	18236	0644	edit dl rm
util.pyc	14568	0644	edit dl rm
util.pyo	14568	0644	edit dl rm
version.py	11433	0644	edit dl rm
version.pyc	7403	0644	edit dl rm
version.pyo	7403	0644	edit dl rm
versionpredicate.py	5095	0644	edit dl rm
versionpredicate.pyc	5633	0644	edit dl rm
versionpredicate.pyo	5633	0644	edit dl rm
__init__.py	236	0644	edit dl rm
__init__.pyc	428	0644	edit dl rm
__init__.pyo	428	0644	edit dl rm

Edit: /opt/alt/python27/lib64/python2.7/distutils/bcppcompiler.py (14941B)

"""distutils.bcppcompiler

Contains BorlandCCompiler, an implementation of the abstract CCompiler class
for the Borland C++ compiler.
"""

# This implementation by Lyle Johnson, based on the original msvccompiler.py
# module and using the directions originally published by Gordon Williams.

# XXX looks like there's a LOT of overlap between these two classes:
# someone should sit down and factor out the common code as
# WindowsCCompiler!  --GPW

__revision__ = "$Id$"

import os

from distutils.errors import (DistutilsExecError, CompileError, LibError,
                              LinkError, UnknownFileError)
from distutils.ccompiler import CCompiler, gen_preprocess_options
from distutils.file_util import write_file
from distutils.dep_util import newer
from distutils import log

class BCPPCompiler(CCompiler) :
    """Concrete class that implements an interface to the Borland C/C++
    compiler, as defined by the CCompiler abstract class.
    """

compiler_type = 'bcpp'

# Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

# Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']

# Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

def __init__ (self,
                  verbose=0,
                  dry_run=0,
                  force=0):

CCompiler.__init__ (self, verbose, dry_run, force)

# These executables are assumed to all be in the path.
        # Borland doesn't seem to use any special registry settings to
        # indicate their installation locations.

self.cc = "bcc32.exe"
        self.linker = "ilink32.exe"
        self.lib = "tlib.exe"

self.preprocess_options = None
        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']

self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_static = []
        self.ldflags_exe = ['/Gn', '/q', '/x']
        self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']

# -- Worker methods ------------------------------------------------

def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

macros, objects, extra_postargs, pp_opts, build = \
                self._setup_compile(output_dir, macros, include_dirs, sources,
                                    depends, extra_postargs)
        compile_opts = extra_preargs or []
        compile_opts.append ('-c')
        if debug:
            compile_opts.extend (self.compile_options_debug)
        else:
            compile_opts.extend (self.compile_options)

for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            # XXX why do the normpath here?
            src = os.path.normpath(src)
            obj = os.path.normpath(obj)
            # XXX _setup_compile() did a mkpath() too but before the normpath.
            # Is it possible to skip the normpath?
            self.mkpath(os.path.dirname(obj))

if ext == '.res':
                # This is already a binary file -- skip it.
                continue # the 'for' loop
            if ext == '.rc':
                # This needs to be compiled to a .res file -- do it now.
                try:
                    self.spawn (["brcc32", "-fo", obj, src])
                except DistutilsExecError, msg:
                    raise CompileError, msg
                continue # the 'for' loop

# The next two are both for the real compiler.
            if ext in self._c_extensions:
                input_opt = ""
            elif ext in self._cpp_extensions:
                input_opt = "-P"
            else:
                # Unknown file type -- no extra options.  The compiler
                # will probably fail, but let it just in case this is a
                # file the compiler recognizes even if we don't.
                input_opt = ""

output_opt = "-o" + obj

# Compiler command line syntax is: "bcc32 [options] file(s)".
            # Note that the source file names must appear at the end of
            # the command line.
            try:
                self.spawn ([self.cc] + compile_opts + pp_opts +
                            [input_opt, output_opt] +
                            extra_postargs + [src])
            except DistutilsExecError, msg:
                raise CompileError, msg

return objects

# compile ()

def create_static_lib (self,
                           objects,
                           output_libname,
                           output_dir=None,
                           debug=0,
                           target_lang=None):

(objects, output_dir) = self._fix_object_args (objects, output_dir)
        output_filename = \
            self.library_filename (output_libname, output_dir=output_dir)

if self._need_link (objects, output_filename):
            lib_args = [output_filename, '/u'] + objects
            if debug:
                pass                    # XXX what goes here?
            try:
                self.spawn ([self.lib] + lib_args)
            except DistutilsExecError, msg:
                raise LibError, msg
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

# create_static_lib ()

def link (self,
              target_desc,
              objects,
              output_filename,
              output_dir=None,
              libraries=None,
              library_dirs=None,
              runtime_library_dirs=None,
              export_symbols=None,
              debug=0,
              extra_preargs=None,
              extra_postargs=None,
              build_temp=None,
              target_lang=None):

# XXX this ignores 'build_temp'!  should follow the lead of
        # msvccompiler.py

(objects, output_dir) = self._fix_object_args (objects, output_dir)
        (libraries, library_dirs, runtime_library_dirs) = \
            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)

if runtime_library_dirs:
            log.warn("I don't know what to do with 'runtime_library_dirs': %s",
                     str(runtime_library_dirs))

if output_dir is not None:
            output_filename = os.path.join (output_dir, output_filename)

if self._need_link (objects, output_filename):

# Figure out linker args based on type of target.
            if target_desc == CCompiler.EXECUTABLE:
                startup_obj = 'c0w32'
                if debug:
                    ld_args = self.ldflags_exe_debug[:]
                else:
                    ld_args = self.ldflags_exe[:]
            else:
                startup_obj = 'c0d32'
                if debug:
                    ld_args = self.ldflags_shared_debug[:]
                else:
                    ld_args = self.ldflags_shared[:]

# Create a temporary exports file for use by the linker
            if export_symbols is None:
                def_file = ''
            else:
                head, tail = os.path.split (output_filename)
                modname, ext = os.path.splitext (tail)
                temp_dir = os.path.dirname(objects[0]) # preserve tree structure
                def_file = os.path.join (temp_dir, '%s.def' % modname)
                contents = ['EXPORTS']
                for sym in (export_symbols or []):
                    contents.append('  %s=_%s' % (sym, sym))
                self.execute(write_file, (def_file, contents),
                             "writing %s" % def_file)

# Borland C++ has problems with '/' in paths
            objects2 = map(os.path.normpath, objects)
            # split objects in .obj and .res files
            # Borland C++ needs them at different positions in the command line
            objects = [startup_obj]
            resources = []
            for file in objects2:
                (base, ext) = os.path.splitext(os.path.normcase(file))
                if ext == '.res':
                    resources.append(file)
                else:
                    objects.append(file)

for l in library_dirs:
                ld_args.append("/L%s" % os.path.normpath(l))
            ld_args.append("/L.") # we sometimes use relative paths

# list of object files
            ld_args.extend(objects)

# XXX the command-line syntax for Borland C++ is a bit wonky;
            # certain filenames are jammed together in one big string, but
            # comma-delimited.  This doesn't mesh too well with the
            # Unix-centric attitude (with a DOS/Windows quoting hack) of
            # 'spawn()', so constructing the argument list is a bit
            # awkward.  Note that doing the obvious thing and jamming all
            # the filenames and commas into one argument would be wrong,
            # because 'spawn()' would quote any filenames with spaces in
            # them.  Arghghh!.  Apparently it works fine as coded...

# name of dll/exe file
            ld_args.extend([',',output_filename])
            # no map file and start libraries
            ld_args.append(',,')

for lib in libraries:
                # see if we find it and if there is a bcpp specific lib
                # (xxx_bcpp.lib)
                libfile = self.find_library_file(library_dirs, lib, debug)
                if libfile is None:
                    ld_args.append(lib)
                    # probably a BCPP internal library -- don't warn
                else:
                    # full name which prefers bcpp_xxx.lib over xxx.lib
                    ld_args.append(libfile)

# some default libraries
            ld_args.append ('import32')
            ld_args.append ('cw32mt')

# def file for export symbols
            ld_args.extend([',',def_file])
            # add resource files
            ld_args.append(',')
            ld_args.extend(resources)

if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

self.mkpath (os.path.dirname (output_filename))
            try:
                self.spawn ([self.linker] + ld_args)
            except DistutilsExecError, msg:
                raise LinkError, msg

else:
            log.debug("skipping %s (up-to-date)", output_filename)

# link ()

# -- Miscellaneous methods -----------------------------------------

def find_library_file (self, dirs, lib, debug=0):
        # List of effective library names to try, in order of preference:
        # xxx_bcpp.lib is better than xxx.lib
        # and xxx_d.lib is better than xxx.lib if debug is set
        #
        # The "_bcpp" suffix is to handle a Python installation for people
        # with multiple compilers (primarily Distutils hackers, I suspect
        # ;-).  The idea is they'd have one static library for each
        # compiler they care about, since (almost?) every Windows compiler
        # seems to have a different format for static libraries.
        if debug:
            dlib = (lib + "_d")
            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
        else:
            try_names = (lib + "_bcpp", lib)

for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

# overwrite the one from CCompiler to support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc','.res']):
                raise UnknownFileError, \
                      "unknown file type '%s' (from '%s')" % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.res':
                # these can go unchanged
                obj_names.append (os.path.join (output_dir, base + ext))
            elif ext == '.rc':
                # these need to be compiled to .res-files
                obj_names.append (os.path.join (output_dir, base + '.res'))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

# object_filenames ()

def preprocess (self,
                    source,
                    output_file=None,
                    macros=None,
                    include_dirs=None,
                    extra_preargs=None,
                    extra_postargs=None):

(_, macros, include_dirs) = \
            self._fix_compile_args(None, macros, include_dirs)
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = ['cpp32.exe'] + pp_opts
        if output_file is not None:
            pp_args.append('-o' + output_file)
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

# We need to preprocess: either we're being forced to, or the
        # source file is newer than the target (or the target doesn't
        # exist).
        if self.force or output_file is None or newer(source, output_file):
            if output_file:
                self.mkpath(os.path.dirname(output_file))
            try:
                self.spawn(pp_args)
            except DistutilsExecError, msg:
                print msg
                raise CompileError, msg

# preprocess()

cmd: