<h2>Edit File - bcppcompiler.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python2.7/distutils/bcppcompiler.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;distutils.bcppcompiler

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

# 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&#039;s a LOT of overlap between these two classes:
# someone should sit down and factor out the common code as
# WindowsCCompiler!  --GPW

__revision__ = &quot;$Id$&quot;

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) :
    &quot;&quot;&quot;Concrete class that implements an interface to the Borland C/C++
    compiler, as defined by the CCompiler abstract class.
    &quot;&quot;&quot;

    compiler_type = &#039;bcpp&#039;

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

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

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


    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&#039;t seem to use any special registry settings to
        # indicate their installation locations.

        self.cc = &quot;bcc32.exe&quot;
        self.linker = &quot;ilink32.exe&quot;
        self.lib = &quot;tlib.exe&quot;

        self.preprocess_options = None
        self.compile_options = [&#039;/tWM&#039;, &#039;/O2&#039;, &#039;/q&#039;, &#039;/g0&#039;]
        self.compile_options_debug = [&#039;/tWM&#039;, &#039;/Od&#039;, &#039;/q&#039;, &#039;/g0&#039;]

        self.ldflags_shared = [&#039;/Tpd&#039;, &#039;/Gn&#039;, &#039;/q&#039;, &#039;/x&#039;]
        self.ldflags_shared_debug = [&#039;/Tpd&#039;, &#039;/Gn&#039;, &#039;/q&#039;, &#039;/x&#039;]
        self.ldflags_static = []
        self.ldflags_exe = [&#039;/Gn&#039;, &#039;/q&#039;, &#039;/x&#039;]
        self.ldflags_exe_debug = [&#039;/Gn&#039;, &#039;/q&#039;, &#039;/x&#039;,&#039;/r&#039;]


    # -- 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 (&#039;-c&#039;)
        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 == &#039;.res&#039;:
                # This is already a binary file -- skip it.
                continue # the &#039;for&#039; loop
            if ext == &#039;.rc&#039;:
                # This needs to be compiled to a .res file -- do it now.
                try:
                    self.spawn ([&quot;brcc32&quot;, &quot;-fo&quot;, obj, src])
                except DistutilsExecError, msg:
                    raise CompileError, msg
                continue # the &#039;for&#039; loop

            # The next two are both for the real compiler.
            if ext in self._c_extensions:
                input_opt = &quot;&quot;
            elif ext in self._cpp_extensions:
                input_opt = &quot;-P&quot;
            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&#039;t.
                input_opt = &quot;&quot;

            output_opt = &quot;-o&quot; + obj

            # Compiler command line syntax is: &quot;bcc32 [options] file(s)&quot;.
            # 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, &#039;/u&#039;] + objects
            if debug:
                pass                    # XXX what goes here?
            try:
                self.spawn ([self.lib] + lib_args)
            except DistutilsExecError, msg:
                raise LibError, msg
        else:
            log.debug(&quot;skipping %s (up-to-date)&quot;, 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 &#039;build_temp&#039;!  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(&quot;I don&#039;t know what to do with &#039;runtime_library_dirs&#039;: %s&quot;,
                     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 = &#039;c0w32&#039;
                if debug:
                    ld_args = self.ldflags_exe_debug[:]
                else:
                    ld_args = self.ldflags_exe[:]
            else:
                startup_obj = &#039;c0d32&#039;
                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 = &#039;&#039;
            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, &#039;%s.def&#039; % modname)
                contents = [&#039;EXPORTS&#039;]
                for sym in (export_symbols or []):
                    contents.append(&#039;  %s=_%s&#039; % (sym, sym))
                self.execute(write_file, (def_file, contents),
                             &quot;writing %s&quot; % def_file)

            # Borland C++ has problems with &#039;/&#039; 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 == &#039;.res&#039;:
                    resources.append(file)
                else:
                    objects.append(file)


            for l in library_dirs:
                ld_args.append(&quot;/L%s&quot; % os.path.normpath(l))
            ld_args.append(&quot;/L.&quot;) # 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&#039;t mesh too well with the
            # Unix-centric attitude (with a DOS/Windows quoting hack) of
            # &#039;spawn()&#039;, 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 &#039;spawn()&#039; would quote any filenames with spaces in
            # them.  Arghghh!.  Apparently it works fine as coded...

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

            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&#039;t warn
                else:
                    # full name which prefers bcpp_xxx.lib over xxx.lib
                    ld_args.append(libfile)

            # some default libraries
            ld_args.append (&#039;import32&#039;)
            ld_args.append (&#039;cw32mt&#039;)

            # def file for export symbols
            ld_args.extend([&#039;,&#039;,def_file])
            # add resource files
            ld_args.append(&#039;,&#039;)
            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(&quot;skipping %s (up-to-date)&quot;, 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 &quot;_bcpp&quot; suffix is to handle a Python installation for people
        # with multiple compilers (primarily Distutils hackers, I suspect
        # ;-).  The idea is they&#039;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 + &quot;_d&quot;)
            try_names = (dlib + &quot;_bcpp&quot;, lib + &quot;_bcpp&quot;, dlib, lib)
        else:
            try_names = (lib + &quot;_bcpp&quot;, 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&#039;t find it in *any* of &#039;dirs&#039;
            return None

    # overwrite the one from CCompiler to support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=&#039;&#039;):
        if output_dir is None: output_dir = &#039;&#039;
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure &#039;.rc&#039; is really &#039;.rc&#039; and not &#039;.RC&#039;
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + [&#039;.rc&#039;,&#039;.res&#039;]):
                raise UnknownFileError, \
                      &quot;unknown file type &#039;%s&#039; (from &#039;%s&#039;)&quot; % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == &#039;.res&#039;:
                # these can go unchanged
                obj_names.append (os.path.join (output_dir, base + ext))
            elif ext == &#039;.rc&#039;:
                # these need to be compiled to .res-files
                obj_names.append (os.path.join (output_dir, base + &#039;.res&#039;))
            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 = [&#039;cpp32.exe&#039;] + pp_opts
        if output_file is not None:
            pp_args.append(&#039;-o&#039; + 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&#039;re being forced to, or the
        # source file is newer than the target (or the target doesn&#039;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()
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>