Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes
distutils.msvc9compiler.MSVCCompiler Class Reference
Inheritance diagram for distutils.msvc9compiler.MSVCCompiler:
Inheritance graph
[legend]
Collaboration diagram for distutils.msvc9compiler.MSVCCompiler:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def initialize
def object_filenames
def compile
def create_static_lib
def link
def library_dir_option
def runtime_library_dir_option
def library_option
def find_library_file
def find_exe
def set_executables
def set_executable
def define_macro
def undefine_macro
def add_include_dir
def set_include_dirs
def add_library
def set_libraries
def add_library_dir
def set_library_dirs
def add_runtime_library_dir
def set_runtime_library_dirs
def add_link_object
def set_link_objects
def detect_language
def preprocess
def link_shared_lib
def link_shared_object
def link_executable
def has_function
def shared_object_filename
def executable_filename
def library_filename
def announce
def debug_print
def warn
def execute
def spawn
def move_file
def mkpath

Public Attributes

 plat_name
 initialized
 cc
 linker
 lib
 rc
 mc
 preprocess_options
 compile_options
 compile_options_debug
 ldflags_shared
 ldflags_shared_debug
 ldflags_static
 dry_run
 force
 verbose
 output_dir
 macros
 include_dirs
 libraries
 library_dirs
 runtime_library_dirs
 objects

Static Public Attributes

string compiler_type = 'msvc'
dictionary executables = {}
tuple src_extensions
string res_extension = '.res'
string obj_extension = '.obj'
string static_lib_extension = '.lib'
string shared_lib_extension = '.dll'
string static_lib_format = '%s%s'
string exe_extension = '.exe'
 shared_lib_format = None
dictionary language_map
list language_order = ["c++", "objc", "c"]
string SHARED_OBJECT = "shared_object"
string SHARED_LIBRARY = "shared_library"
string EXECUTABLE = "executable"

Private Member Functions

def _remove_visual_c_ref

Private Attributes

 __version
 __root
 __paths
 __arch

Static Private Attributes

list _c_extensions = ['.c']
list _cpp_extensions = ['.cc', '.cpp', '.cxx']
list _rc_extensions = ['.rc']
list _mc_extensions = ['.mc']

Detailed Description

Concrete class that implements an interface to Microsoft Visual C++,
   as defined by the CCompiler abstract class.

Definition at line 297 of file msvc9compiler.py.


Constructor & Destructor Documentation

def distutils.msvc9compiler.MSVCCompiler.__init__ (   self,
  verbose = 0,
  dry_run = 0,
  force = 0 
)

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 327 of file msvc9compiler.py.

00327 
00328     def __init__(self, verbose=0, dry_run=0, force=0):
00329         CCompiler.__init__ (self, verbose, dry_run, force)
00330         self.__version = VERSION
00331         self.__root = r"Software\Microsoft\VisualStudio"
00332         # self.__macros = MACROS
00333         self.__paths = []
00334         # target platform (.plat_name is consistent with 'bdist')
00335         self.plat_name = None
00336         self.__arch = None # deprecated name
00337         self.initialized = False

Here is the caller graph for this function:


Member Function Documentation

def distutils.msvc9compiler.MSVCCompiler._remove_visual_c_ref (   self,
  manifest_file 
) [private]

Definition at line 671 of file msvc9compiler.py.

00671 
00672     def _remove_visual_c_ref(self, manifest_file):
00673         try:
00674             # Remove references to the Visual C runtime, so they will
00675             # fall through to the Visual C dependency of Python.exe.
00676             # This way, when installed for a restricted user (e.g.
00677             # runtimes are not in WinSxS folder, but in Python's own
00678             # folder), the runtimes do not need to be in every folder
00679             # with .pyd's.
00680             manifest_f = open(manifest_file)
00681             try:
00682                 manifest_buf = manifest_f.read()
00683             finally:
00684                 manifest_f.close()
00685             pattern = re.compile(
00686                 r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
00687                 r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
00688                 re.DOTALL)
00689             manifest_buf = re.sub(pattern, "", manifest_buf)
00690             pattern = "<dependentAssembly>\s*</dependentAssembly>"
00691             manifest_buf = re.sub(pattern, "", manifest_buf)
00692             manifest_f = open(manifest_file, 'w')
00693             try:
00694                 manifest_f.write(manifest_buf)
00695             finally:
00696                 manifest_f.close()
00697         except IOError:
00698             pass

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.add_include_dir (   self,
  dir 
) [inherited]
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()'.

Definition at line 217 of file ccompiler.py.

00217 
00218     def add_include_dir(self, dir):
00219         """Add 'dir' to the list of directories that will be searched for
00220         header files.  The compiler is instructed to search directories in
00221         the order in which they are supplied by successive calls to
00222         'add_include_dir()'.
00223         """
00224         self.include_dirs.append(dir)

def distutils.ccompiler.CCompiler.add_library (   self,
  libname 
) [inherited]
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.

Definition at line 235 of file ccompiler.py.

00235 
00236     def add_library(self, libname):
00237         """Add 'libname' to the list of libraries that will be included in
00238         all links driven by this compiler object.  Note that 'libname'
00239         should *not* be the name of a file containing a library, but the
00240         name of the library itself: the actual filename will be inferred by
00241         the linker, the compiler, or the compiler class (depending on the
00242         platform).
00243 
00244         The linker will be instructed to link against libraries in the
00245         order they were supplied to 'add_library()' and/or
00246         'set_libraries()'.  It is perfectly valid to duplicate library
00247         names; the linker will be instructed to link against libraries as
00248         many times as they are mentioned.
00249         """
00250         self.libraries.append(libname)

def distutils.ccompiler.CCompiler.add_library_dir (   self,
  dir 
) [inherited]
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()'.

Definition at line 259 of file ccompiler.py.

00259 
00260     def add_library_dir(self, dir):
00261         """Add 'dir' to the list of directories that will be searched for
00262         libraries specified to 'add_library()' and 'set_libraries()'.  The
00263         linker will be instructed to search for libraries in the order they
00264         are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
00265         """
00266         self.library_dirs.append(dir)

def distutils.ccompiler.CCompiler.add_link_object (   self,
  object 
) [inherited]
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.

Definition at line 288 of file ccompiler.py.

00288 
00289     def add_link_object(self, object):
00290         """Add 'object' to the list of object files (or analogues, such as
00291         explicitly named library files or the output of "resource
00292         compilers") to be included in every link driven by this compiler
00293         object.
00294         """
00295         self.objects.append(object)

def distutils.ccompiler.CCompiler.add_runtime_library_dir (   self,
  dir 
) [inherited]
Add 'dir' to the list of directories that will be searched for
shared libraries at runtime.

Definition at line 274 of file ccompiler.py.

00274 
00275     def add_runtime_library_dir(self, dir):
00276         """Add 'dir' to the list of directories that will be searched for
00277         shared libraries at runtime.
00278         """
00279         self.runtime_library_dirs.append(dir)

def distutils.ccompiler.CCompiler.announce (   self,
  msg,
  level = 1 
) [inherited]

Definition at line 894 of file ccompiler.py.

00894 
00895     def announce(self, msg, level=1):
00896         log.debug(msg)

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.compile (   self,
  sources,
  output_dir = None,
  macros = None,
  include_dirs = None,
  debug = 0,
  extra_preargs = None,
  extra_postargs = None,
  depends = None 
)
Compile one or more source files.

'sources' must be a list of filenames, most likely C/C++
files, but in reality anything that can be handled by a
particular compiler and compiler class (eg. MSVCCompiler can
handle resource files in 'sources').  Return a list of object
filenames, one per source filename in 'sources'.  Depending on
the implementation, not all source files will necessarily be
compiled, but all corresponding object filenames will be
returned.

If 'output_dir' is given, object files will be put under it, while
retaining their original path component.  That is, "foo/bar.c"
normally compiles to "foo/bar.o" (for a Unix implementation); if
'output_dir' is "build", then it would compile to
"build/foo/bar.o".

'macros', if given, must be a list of macro definitions.  A macro
definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
The former defines a macro; if the value is None, the macro is
defined without an explicit value.  The 1-tuple case undefines a
macro.  Later definitions/redefinitions/ undefinitions take
precedence.

'include_dirs', if given, must be a list of strings, the
directories to add to the default include file search path for this
compilation only.

'debug' is a boolean; if true, the compiler will be instructed to
output debug symbols in (or alongside) the object file(s).

'extra_preargs' and 'extra_postargs' are implementation- dependent.
On platforms that have the notion of a command-line (e.g. Unix,
DOS/Windows), they are most likely lists of strings: extra
command-line arguments to prepand/append to the compiler command
line.  On other platforms, consult the implementation class
documentation.  In any event, they are intended as an escape hatch
for those occasions when the abstract compiler framework doesn't
cut the mustard.

'depends', if given, is a list of filenames that all targets
depend on.  If a source file is older than any file in
depends, then the source file will be recompiled.  This
supports dependency tracking, but only at a coarse
granularity.

Raises CompileError on failure.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 457 of file msvc9compiler.py.

00457 
00458                 extra_preargs=None, extra_postargs=None, depends=None):
00459 
00460         if not self.initialized:
00461             self.initialize()
00462         compile_info = self._setup_compile(output_dir, macros, include_dirs,
00463                                            sources, depends, extra_postargs)
00464         macros, objects, extra_postargs, pp_opts, build = compile_info
00465 
00466         compile_opts = extra_preargs or []
00467         compile_opts.append ('/c')
00468         if debug:
00469             compile_opts.extend(self.compile_options_debug)
00470         else:
00471             compile_opts.extend(self.compile_options)
00472 
00473         for obj in objects:
00474             try:
00475                 src, ext = build[obj]
00476             except KeyError:
00477                 continue
00478             if debug:
00479                 # pass the full pathname to MSVC in debug mode,
00480                 # this allows the debugger to find the source file
00481                 # without asking the user to browse for it
00482                 src = os.path.abspath(src)
00483 
00484             if ext in self._c_extensions:
00485                 input_opt = "/Tc" + src
00486             elif ext in self._cpp_extensions:
00487                 input_opt = "/Tp" + src
00488             elif ext in self._rc_extensions:
00489                 # compile .RC to .RES file
00490                 input_opt = src
00491                 output_opt = "/fo" + obj
00492                 try:
00493                     self.spawn([self.rc] + pp_opts +
00494                                [output_opt] + [input_opt])
00495                 except DistutilsExecError as msg:
00496                     raise CompileError(msg)
00497                 continue
00498             elif ext in self._mc_extensions:
00499                 # Compile .MC to .RC file to .RES file.
00500                 #   * '-h dir' specifies the directory for the
00501                 #     generated include file
00502                 #   * '-r dir' specifies the target directory of the
00503                 #     generated RC file and the binary message resource
00504                 #     it includes
00505                 #
00506                 # For now (since there are no options to change this),
00507                 # we use the source-directory for the include file and
00508                 # the build directory for the RC file and message
00509                 # resources. This works at least for win32all.
00510                 h_dir = os.path.dirname(src)
00511                 rc_dir = os.path.dirname(obj)
00512                 try:
00513                     # first compile .MC to .RC and .H file
00514                     self.spawn([self.mc] +
00515                                ['-h', h_dir, '-r', rc_dir] + [src])
00516                     base, _ = os.path.splitext (os.path.basename (src))
00517                     rc_file = os.path.join (rc_dir, base + '.rc')
00518                     # then compile .RC to .RES file
00519                     self.spawn([self.rc] +
00520                                ["/fo" + obj] + [rc_file])
00521 
00522                 except DistutilsExecError as msg:
00523                     raise CompileError(msg)
00524                 continue
00525             else:
00526                 # how to handle this file?
00527                 raise CompileError("Don't know how to compile %s to %s"
00528                                    % (src, obj))
00529 
00530             output_opt = "/Fo" + obj
00531             try:
00532                 self.spawn([self.cc] + compile_opts + pp_opts +
00533                            [input_opt, output_opt] +
00534                            extra_postargs)
00535             except DistutilsExecError as msg:
00536                 raise CompileError(msg)
00537 
00538         return objects
00539 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.create_static_lib (   self,
  objects,
  output_libname,
  output_dir = None,
  debug = 0,
  target_lang = None 
)
Link a bunch of stuff together to create a static library file.
The "bunch of stuff" consists of the list of object files supplied
as 'objects', the extra object files supplied to
'add_link_object()' and/or 'set_link_objects()', the libraries
supplied to 'add_library()' and/or 'set_libraries()', and the
libraries supplied as 'libraries' (if any).

'output_libname' should be a library name, not a filename; the
filename will be inferred from the library name.  'output_dir' is
the directory where the library file will be put.

'debug' is a boolean; if true, debugging information will be
included in the library (note that on most platforms, it is the
compile step where this matters: the 'debug' flag is included here
just for consistency).

'target_lang' is the target language for which the given objects
are being compiled. This allows specific linkage time treatment of
certain languages.

Raises LibError on failure.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 545 of file msvc9compiler.py.

00545 
00546                           target_lang=None):
00547 
00548         if not self.initialized:
00549             self.initialize()
00550         (objects, output_dir) = self._fix_object_args(objects, output_dir)
00551         output_filename = self.library_filename(output_libname,
00552                                                 output_dir=output_dir)
00553 
00554         if self._need_link(objects, output_filename):
00555             lib_args = objects + ['/OUT:' + output_filename]
00556             if debug:
00557                 pass # XXX what goes here?
00558             try:
00559                 self.spawn([self.lib] + lib_args)
00560             except DistutilsExecError as msg:
00561                 raise LibError(msg)
00562         else:
00563             log.debug("skipping %s (up-to-date)", output_filename)
00564 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.debug_print (   self,
  msg 
) [inherited]

Definition at line 897 of file ccompiler.py.

00897 
00898     def debug_print(self, msg):
00899         from distutils.debug import DEBUG
00900         if DEBUG:
00901             print(msg)

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.define_macro (   self,
  name,
  value = None 
) [inherited]
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?)

Definition at line 184 of file ccompiler.py.

00184 
00185     def define_macro(self, name, value=None):
00186         """Define a preprocessor macro for all compilations driven by this
00187         compiler object.  The optional parameter 'value' should be a
00188         string; if it is not supplied, then the macro will be defined
00189         without an explicit value and the exact outcome depends on the
00190         compiler used (XXX true? does ANSI say anything about this?)
00191         """
00192         # Delete from the list of macro definitions/undefinitions if
00193         # already there (so that this one will take precedence).
00194         i = self._find_macro (name)
00195         if i is not None:
00196             del self.macros[i]
00197 
00198         self.macros.append((name, value))

Here is the call graph for this function:

def distutils.ccompiler.CCompiler.detect_language (   self,
  sources 
) [inherited]
Detect the language of a given file, or list of files. Uses
language_map, and language_order to do the job.

Definition at line 474 of file ccompiler.py.

00474 
00475     def detect_language(self, sources):
00476         """Detect the language of a given file, or list of files. Uses
00477         language_map, and language_order to do the job.
00478         """
00479         if not isinstance(sources, list):
00480             sources = [sources]
00481         lang = None
00482         index = len(self.language_order)
00483         for source in sources:
00484             base, ext = os.path.splitext(source)
00485             extlang = self.language_map.get(ext)
00486             try:
00487                 extindex = self.language_order.index(extlang)
00488                 if extindex < index:
00489                     lang = extlang
00490                     index = extindex
00491             except ValueError:
00492                 pass
00493         return lang
00494 

Here is the call graph for this function:

def distutils.ccompiler.CCompiler.executable_filename (   self,
  basename,
  strip_dir = 0,
  output_dir = '' 
) [inherited]

Definition at line 869 of file ccompiler.py.

00869 
00870     def executable_filename(self, basename, strip_dir=0, output_dir=''):
00871         assert output_dir is not None
00872         if strip_dir:
00873             basename = os.path.basename(basename)
00874         return os.path.join(output_dir, basename + (self.exe_extension or ''))

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.execute (   self,
  func,
  args,
  msg = None,
  level = 1 
) [inherited]

Definition at line 905 of file ccompiler.py.

00905 
00906     def execute(self, func, args, msg=None, level=1):
00907         execute(func, args, msg, self.dry_run)

Here is the caller graph for this function:

Return path to an MSVC executable program.

Tries to find the program in several places: first, one of the
MSVC program search paths from the registry; next, the directories
in the PATH environment variable.  If any of those work, return an
absolute path that is known to exist.  If none of them work, just
return the original program name, 'exe'.

Definition at line 732 of file msvc9compiler.py.

00732 
00733     def find_exe(self, exe):
00734         """Return path to an MSVC executable program.
00735 
00736         Tries to find the program in several places: first, one of the
00737         MSVC program search paths from the registry; next, the directories
00738         in the PATH environment variable.  If any of those work, return an
00739         absolute path that is known to exist.  If none of them work, just
00740         return the original program name, 'exe'.
00741         """
00742         for p in self.__paths:
00743             fn = os.path.join(os.path.abspath(p), exe)
00744             if os.path.isfile(fn):
00745                 return fn
00746 
00747         # didn't find it; try existing path
00748         for p in os.environ['Path'].split(';'):
00749             fn = os.path.join(os.path.abspath(p),exe)
00750             if os.path.isfile(fn):
00751                 return fn
00752 
00753         return exe

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.find_library_file (   self,
  dirs,
  lib,
  debug = 0 
)
Search the specified list of directories for a static or shared
library file 'lib' and return the full path to that file.  If
'debug' true, look for a debugging version (if that makes sense on
the current platform).  Return None if 'lib' wasn't found in any of
the specified directories.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 714 of file msvc9compiler.py.

00714 
00715     def find_library_file(self, dirs, lib, debug=0):
00716         # Prefer a debugging library if found (and requested), but deal
00717         # with it if we don't have one.
00718         if debug:
00719             try_names = [lib + "_d", lib]
00720         else:
00721             try_names = [lib]
00722         for dir in dirs:
00723             for name in try_names:
00724                 libfile = os.path.join(dir, self.library_filename (name))
00725                 if os.path.exists(libfile):
00726                     return libfile
00727         else:
00728             # Oops, didn't find it in *any* of 'dirs'
00729             return None

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.has_function (   self,
  funcname,
  includes = None,
  include_dirs = None,
  libraries = None,
  library_dirs = None 
) [inherited]
Return a boolean indicating whether funcname is supported on
the current platform.  The optional arguments can be used to
augment the compilation environment.

Definition at line 761 of file ccompiler.py.

00761 
00762                      libraries=None, library_dirs=None):
00763         """Return a boolean indicating whether funcname is supported on
00764         the current platform.  The optional arguments can be used to
00765         augment the compilation environment.
00766         """
00767         # this can't be included at module scope because it tries to
00768         # import math which might not be available at that point - maybe
00769         # the necessary logic should just be inlined?
00770         import tempfile
00771         if includes is None:
00772             includes = []
00773         if include_dirs is None:
00774             include_dirs = []
00775         if libraries is None:
00776             libraries = []
00777         if library_dirs is None:
00778             library_dirs = []
00779         fd, fname = tempfile.mkstemp(".c", funcname, text=True)
00780         f = os.fdopen(fd, "w")
00781         try:
00782             for incl in includes:
00783                 f.write("""#include "%s"\n""" % incl)
00784             f.write("""\
00785 main (int argc, char **argv) {
00786     %s();
00787 }
00788 """ % funcname)
00789         finally:
00790             f.close()
00791         try:
00792             objects = self.compile([fname], include_dirs=include_dirs)
00793         except CompileError:
00794             return False
00795 
00796         try:
00797             self.link_executable(objects, "a.out",
00798                                  libraries=libraries,
00799                                  library_dirs=library_dirs)
00800         except (LinkError, TypeError):
00801             return False
00802         return True

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.initialize (   self,
  plat_name = None 
)

Definition at line 338 of file msvc9compiler.py.

00338 
00339     def initialize(self, plat_name=None):
00340         # multi-init means we would need to check platform same each time...
00341         assert not self.initialized, "don't init multiple times"
00342         if plat_name is None:
00343             plat_name = get_platform()
00344         # sanity check for platforms to prevent obscure errors later.
00345         ok_plats = 'win32', 'win-amd64', 'win-ia64'
00346         if plat_name not in ok_plats:
00347             raise DistutilsPlatformError("--plat-name must be one of %s" %
00348                                          (ok_plats,))
00349 
00350         if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
00351             # Assume that the SDK set up everything alright; don't try to be
00352             # smarter
00353             self.cc = "cl.exe"
00354             self.linker = "link.exe"
00355             self.lib = "lib.exe"
00356             self.rc = "rc.exe"
00357             self.mc = "mc.exe"
00358         else:
00359             # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
00360             # to cross compile, you use 'x86_amd64'.
00361             # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
00362             # compile use 'x86' (ie, it runs the x86 compiler directly)
00363             # No idea how itanium handles this, if at all.
00364             if plat_name == get_platform() or plat_name == 'win32':
00365                 # native build or cross-compile to win32
00366                 plat_spec = PLAT_TO_VCVARS[plat_name]
00367             else:
00368                 # cross compile from win32 -> some 64bit
00369                 plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
00370                             PLAT_TO_VCVARS[plat_name]
00371 
00372             vc_env = query_vcvarsall(VERSION, plat_spec)
00373 
00374             self.__paths = vc_env['path'].split(os.pathsep)
00375             os.environ['lib'] = vc_env['lib']
00376             os.environ['include'] = vc_env['include']
00377 
00378             if len(self.__paths) == 0:
00379                 raise DistutilsPlatformError("Python was built with %s, "
00380                        "and extensions need to be built with the same "
00381                        "version of the compiler, but it isn't installed."
00382                        % self.__product)
00383 
00384             self.cc = self.find_exe("cl.exe")
00385             self.linker = self.find_exe("link.exe")
00386             self.lib = self.find_exe("lib.exe")
00387             self.rc = self.find_exe("rc.exe")   # resource compiler
00388             self.mc = self.find_exe("mc.exe")   # message compiler
00389             #self.set_path_env_var('lib')
00390             #self.set_path_env_var('include')
00391 
00392         # extend the MSVC path with the current path
00393         try:
00394             for p in os.environ['path'].split(';'):
00395                 self.__paths.append(p)
00396         except KeyError:
00397             pass
00398         self.__paths = normalize_and_reduce_paths(self.__paths)
00399         os.environ['path'] = ";".join(self.__paths)
00400 
00401         self.preprocess_options = None
00402         if self.__arch == "x86":
00403             self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3',
00404                                      '/DNDEBUG']
00405             self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
00406                                           '/Z7', '/D_DEBUG']
00407         else:
00408             # Win64
00409             self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
00410                                      '/DNDEBUG']
00411             self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
00412                                           '/Z7', '/D_DEBUG']
00413 
00414         self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
00415         if self.__version >= 7:
00416             self.ldflags_shared_debug = [
00417                 '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG', '/pdb:None'
00418                 ]
00419         self.ldflags_static = [ '/nologo']
00420 
00421         self.initialized = True

Here is the call graph for this function:

Here is the caller graph for this function:

Return the compiler option to add 'dir' to the list of
directories searched for libraries.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 703 of file msvc9compiler.py.

00703 
00704     def library_dir_option(self, dir):
00705         return "/LIBPATH:" + dir

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.library_filename (   self,
  libname,
  lib_type = 'static',
  strip_dir = 0,
  output_dir = '' 
) [inherited]

Definition at line 876 of file ccompiler.py.

00876 
00877                          strip_dir=0, output_dir=''):
00878         assert output_dir is not None
00879         if lib_type not in ("static", "shared", "dylib"):
00880             raise ValueError(
00881                   "'lib_type' must be \"static\", \"shared\" or \"dylib\"")
00882         fmt = getattr(self, lib_type + "_lib_format")
00883         ext = getattr(self, lib_type + "_lib_extension")
00884 
00885         dir, base = os.path.split(libname)
00886         filename = fmt % (base, ext)
00887         if strip_dir:
00888             dir = ''
00889 
00890         return os.path.join(output_dir, dir, filename)
00891 

Here is the call graph for this function:

Here is the caller graph for this function:

Return the compiler option to add 'dir' to the list of libraries
linked into the shared library or executable.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 710 of file msvc9compiler.py.

00710 
00711     def library_option(self, lib):
00712         return self.library_filename(lib)
00713 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.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 
)
Link a bunch of stuff together to create an executable or
shared library file.

The "bunch of stuff" consists of the list of object files supplied
as 'objects'.  'output_filename' should be a filename.  If
'output_dir' is supplied, 'output_filename' is relative to it
(i.e. 'output_filename' can provide directory components if
needed).

'libraries' is a list of libraries to link against.  These are
library names, not filenames, since they're translated into
filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
on Unix and "foo.lib" on DOS/Windows).  However, they can include a
directory component, which means the linker will look in that
specific directory rather than searching all the normal locations.

'library_dirs', if supplied, should be a list of directories to
search for libraries that were specified as bare library names
(ie. no directory component).  These are on top of the system
default and those supplied to 'add_library_dir()' and/or
'set_library_dirs()'.  'runtime_library_dirs' is a list of
directories that will be embedded into the shared library and used
to search for other shared libraries that *it* depends on at
run-time.  (This may only be relevant on Unix.)

'export_symbols' is a list of symbols that the shared library will
export.  (This appears to be relevant only on Windows.)

'debug' is as for 'compile()' and 'create_static_lib()', with the
slight distinction that it actually matters on most platforms (as
opposed to 'create_static_lib()', which includes a 'debug' flag
mostly for form's sake).

'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
of course that they supply command-line arguments for the
particular linker being used).

'target_lang' is the target language for which the given objects
are being compiled. This allows specific linkage time treatment of
certain languages.

Raises LinkError on failure.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 578 of file msvc9compiler.py.

00578 
00579              target_lang=None):
00580 
00581         if not self.initialized:
00582             self.initialize()
00583         (objects, output_dir) = self._fix_object_args(objects, output_dir)
00584         fixed_args = self._fix_lib_args(libraries, library_dirs,
00585                                         runtime_library_dirs)
00586         (libraries, library_dirs, runtime_library_dirs) = fixed_args
00587 
00588         if runtime_library_dirs:
00589             self.warn ("I don't know what to do with 'runtime_library_dirs': "
00590                        + str (runtime_library_dirs))
00591 
00592         lib_opts = gen_lib_options(self,
00593                                    library_dirs, runtime_library_dirs,
00594                                    libraries)
00595         if output_dir is not None:
00596             output_filename = os.path.join(output_dir, output_filename)
00597 
00598         if self._need_link(objects, output_filename):
00599             if target_desc == CCompiler.EXECUTABLE:
00600                 if debug:
00601                     ldflags = self.ldflags_shared_debug[1:]
00602                 else:
00603                     ldflags = self.ldflags_shared[1:]
00604             else:
00605                 if debug:
00606                     ldflags = self.ldflags_shared_debug
00607                 else:
00608                     ldflags = self.ldflags_shared
00609 
00610             export_opts = []
00611             for sym in (export_symbols or []):
00612                 export_opts.append("/EXPORT:" + sym)
00613 
00614             ld_args = (ldflags + lib_opts + export_opts +
00615                        objects + ['/OUT:' + output_filename])
00616 
00617             # The MSVC linker generates .lib and .exp files, which cannot be
00618             # suppressed by any linker switches. The .lib files may even be
00619             # needed! Make sure they are generated in the temporary build
00620             # directory. Since they have different names for debug and release
00621             # builds, they can go into the same directory.
00622             build_temp = os.path.dirname(objects[0])
00623             if export_symbols is not None:
00624                 (dll_name, dll_ext) = os.path.splitext(
00625                     os.path.basename(output_filename))
00626                 implib_file = os.path.join(
00627                     build_temp,
00628                     self.library_filename(dll_name))
00629                 ld_args.append ('/IMPLIB:' + implib_file)
00630 
00631             # Embedded manifests are recommended - see MSDN article titled
00632             # "How to: Embed a Manifest Inside a C/C++ Application"
00633             # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
00634             # Ask the linker to generate the manifest in the temp dir, so
00635             # we can embed it later.
00636             temp_manifest = os.path.join(
00637                     build_temp,
00638                     os.path.basename(output_filename) + ".manifest")
00639             ld_args.append('/MANIFESTFILE:' + temp_manifest)
00640 
00641             if extra_preargs:
00642                 ld_args[:0] = extra_preargs
00643             if extra_postargs:
00644                 ld_args.extend(extra_postargs)
00645 
00646             self.mkpath(os.path.dirname(output_filename))
00647             try:
00648                 self.spawn([self.linker] + ld_args)
00649             except DistutilsExecError as msg:
00650                 raise LinkError(msg)
00651 
00652             # embed the manifest
00653             # XXX - this is somewhat fragile - if mt.exe fails, distutils
00654             # will still consider the DLL up-to-date, but it will not have a
00655             # manifest.  Maybe we should link to a temp file?  OTOH, that
00656             # implies a build environment error that shouldn't go undetected.
00657             if target_desc == CCompiler.EXECUTABLE:
00658                 mfid = 1
00659             else:
00660                 mfid = 2
00661                 # Remove references to the Visual C runtime
00662                 self._remove_visual_c_ref(temp_manifest)
00663             out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
00664             try:
00665                 self.spawn(['mt.exe', '-nologo', '-manifest',
00666                             temp_manifest, out_arg])
00667             except DistutilsExecError as msg:
00668                 raise LinkError(msg)
00669         else:
00670             log.debug("skipping %s (up-to-date)", output_filename)

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.link_executable (   self,
  objects,
  output_progname,
  output_dir = None,
  libraries = None,
  library_dirs = None,
  runtime_library_dirs = None,
  debug = 0,
  extra_preargs = None,
  extra_postargs = None,
  target_lang = None 
) [inherited]

Definition at line 730 of file ccompiler.py.

00730 
00731                         target_lang=None):
00732         self.link(CCompiler.EXECUTABLE, objects,
00733                   self.executable_filename(output_progname), output_dir,
00734                   libraries, library_dirs, runtime_library_dirs, None,
00735                   debug, extra_preargs, extra_postargs, None, target_lang)
00736 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.link_shared_lib (   self,
  objects,
  output_libname,
  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 
) [inherited]

Definition at line 691 of file ccompiler.py.

00691 
00692                         target_lang=None):
00693         self.link(CCompiler.SHARED_LIBRARY, objects,
00694                   self.library_filename(output_libname, lib_type='shared'),
00695                   output_dir,
00696                   libraries, library_dirs, runtime_library_dirs,
00697                   export_symbols, debug,
00698                   extra_preargs, extra_postargs, build_temp, target_lang)
00699 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.link_shared_object (   self,
  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 
) [inherited]

Definition at line 712 of file ccompiler.py.

00712 
00713                            target_lang=None):
00714         self.link(CCompiler.SHARED_OBJECT, objects,
00715                   output_filename, output_dir,
00716                   libraries, library_dirs, runtime_library_dirs,
00717                   export_symbols, debug,
00718                   extra_preargs, extra_postargs, build_temp, target_lang)
00719 

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.mkpath (   self,
  name,
  mode = 0o777 
) [inherited]

Definition at line 914 of file ccompiler.py.

00914 
00915     def mkpath (self, name, mode=0o777):
00916         mkpath(name, mode, dry_run=self.dry_run)
00917 
00918 
00919 # Map a sys.platform/os.name ('posix', 'nt') to the default compiler
00920 # type for that platform. Keys are interpreted as re match
00921 # patterns. Order is important; platform mappings are preferred over
# OS names.

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.move_file (   self,
  src,
  dst 
) [inherited]

Definition at line 911 of file ccompiler.py.

00911 
00912     def move_file(self, src, dst):
00913         return move_file(src, dst, dry_run=self.dry_run)

Here is the caller graph for this function:

def distutils.msvc9compiler.MSVCCompiler.object_filenames (   self,
  source_filenames,
  strip_dir = 0,
  output_dir = '' 
)

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 427 of file msvc9compiler.py.

00427 
00428                          output_dir=''):
00429         # Copied from ccompiler.py, extended to return .res as 'object'-file
00430         # for .rc input file
00431         if output_dir is None: output_dir = ''
00432         obj_names = []
00433         for src_name in source_filenames:
00434             (base, ext) = os.path.splitext (src_name)
00435             base = os.path.splitdrive(base)[1] # Chop off the drive
00436             base = base[os.path.isabs(base):]  # If abs, chop off leading /
00437             if ext not in self.src_extensions:
00438                 # Better to raise an exception instead of silently continuing
00439                 # and later complain about sources and targets having
00440                 # different lengths
00441                 raise CompileError ("Don't know how to compile %s" % src_name)
00442             if strip_dir:
00443                 base = os.path.basename (base)
00444             if ext in self._rc_extensions:
00445                 obj_names.append (os.path.join (output_dir,
00446                                                 base + self.res_extension))
00447             elif ext in self._mc_extensions:
00448                 obj_names.append (os.path.join (output_dir,
00449                                                 base + self.res_extension))
00450             else:
00451                 obj_names.append (os.path.join (output_dir,
00452                                                 base + self.obj_extension))
00453         return obj_names
00454 

Here is the call graph for this function:

def distutils.ccompiler.CCompiler.preprocess (   self,
  source,
  output_file = None,
  macros = None,
  include_dirs = None,
  extra_preargs = None,
  extra_postargs = None 
) [inherited]
Preprocess a single C/C++ source file, named in 'source'.
Output will be written to file named 'output_file', or stdout if
'output_file' not supplied.  'macros' is a list of macro
definitions as for 'compile()', which will augment the macros set
with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
list of directory names that will be added to the default list.

Raises PreprocessError on failure.

Definition at line 499 of file ccompiler.py.

00499 
00500                    include_dirs=None, extra_preargs=None, extra_postargs=None):
00501         """Preprocess a single C/C++ source file, named in 'source'.
00502         Output will be written to file named 'output_file', or stdout if
00503         'output_file' not supplied.  'macros' is a list of macro
00504         definitions as for 'compile()', which will augment the macros set
00505         with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
00506         list of directory names that will be added to the default list.
00507 
00508         Raises PreprocessError on failure.
00509         """
00510         pass

Here is the call graph for this function:

Here is the caller graph for this function:

Return the compiler option to add 'dir' to the list of
directories searched for runtime libraries.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 706 of file msvc9compiler.py.

00706 
00707     def runtime_library_dir_option(self, dir):
00708         raise DistutilsPlatformError(
00709               "don't know how to set runtime library search path for MSVC++")

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.set_executable (   self,
  key,
  value 
) [inherited]

Definition at line 153 of file ccompiler.py.

00153 
00154     def set_executable(self, key, value):
00155         if isinstance(value, str):
00156             setattr(self, key, split_quoted(value))
00157         else:
00158             setattr(self, key, value)

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.set_executables (   self,
  kwargs 
) [inherited]
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()'.)

Definition at line 121 of file ccompiler.py.

00121 
00122     def set_executables(self, **kwargs):
00123         """Define the executables (and options for them) that will be run
00124         to perform the various stages of compilation.  The exact set of
00125         executables that may be specified here depends on the compiler
00126         class (via the 'executables' class attribute), but most will have:
00127           compiler      the C/C++ compiler
00128           linker_so     linker used to create shared objects and libraries
00129           linker_exe    linker used to create binary executables
00130           archiver      static library creator
00131 
00132         On platforms with a command-line (Unix, DOS/Windows), each of these
00133         is a string that will be split into executable name and (optional)
00134         list of arguments.  (Splitting the string is done similarly to how
00135         Unix shells operate: words are delimited by spaces, but quotes and
00136         backslashes can override this.  See
00137         'distutils.util.split_quoted()'.)
00138         """
00139 
00140         # Note that some CCompiler implementation classes will define class
00141         # attributes 'cpp', 'cc', etc. with hard-coded executable names;
00142         # this is appropriate when a compiler class is for exactly one
00143         # compiler/OS combination (eg. MSVCCompiler).  Other compiler
00144         # classes (UnixCCompiler, in particular) are driven by information
00145         # discovered at run-time, since there are many different ways to do
00146         # basically the same things with Unix C compilers.
00147 
00148         for key in kwargs:
00149             if key not in self.executables:
00150                 raise ValueError("unknown executable '%s' for class %s" %
00151                       (key, self.__class__.__name__))
00152             self.set_executable(key, kwargs[key])

Here is the call graph for this function:

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.set_include_dirs (   self,
  dirs 
) [inherited]
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.

Definition at line 225 of file ccompiler.py.

00225 
00226     def set_include_dirs(self, dirs):
00227         """Set the list of directories that will be searched to 'dirs' (a
00228         list of strings).  Overrides any preceding calls to
00229         'add_include_dir()'; subsequence calls to 'add_include_dir()' add
00230         to the list passed to 'set_include_dirs()'.  This does not affect
00231         any list of standard include directories that the compiler may
00232         search by default.
00233         """
00234         self.include_dirs = dirs[:]

def distutils.ccompiler.CCompiler.set_libraries (   self,
  libnames 
) [inherited]
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.

Definition at line 251 of file ccompiler.py.

00251 
00252     def set_libraries(self, libnames):
00253         """Set the list of libraries to be included in all links driven by
00254         this compiler object to 'libnames' (a list of strings).  This does
00255         not affect any standard system libraries that the linker may
00256         include by default.
00257         """
00258         self.libraries = libnames[:]

def distutils.ccompiler.CCompiler.set_library_dirs (   self,
  dirs 
) [inherited]
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.

Definition at line 267 of file ccompiler.py.

00267 
00268     def set_library_dirs(self, dirs):
00269         """Set the list of library search directories to 'dirs' (a list of
00270         strings).  This does not affect any standard library search path
00271         that the linker may search by default.
00272         """
00273         self.library_dirs = dirs[:]

def distutils.ccompiler.CCompiler.set_link_objects (   self,
  objects 
) [inherited]
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).

Definition at line 296 of file ccompiler.py.

00296 
00297     def set_link_objects(self, objects):
00298         """Set the list of object files (or analogues) to be included in
00299         every link to 'objects'.  This does not affect any standard object
00300         files that the linker may include by default (such as system
00301         libraries).
00302         """
00303         self.objects = objects[:]
00304 

Here is the call graph for this function:

def distutils.ccompiler.CCompiler.set_runtime_library_dirs (   self,
  dirs 
) [inherited]
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.

Definition at line 280 of file ccompiler.py.

00280 
00281     def set_runtime_library_dirs(self, dirs):
00282         """Set the list of directories to search for shared libraries at
00283         runtime to 'dirs' (a list of strings).  This does not affect any
00284         standard search path that the runtime linker may search by
00285         default.
00286         """
00287         self.runtime_library_dirs = dirs[:]

def distutils.ccompiler.CCompiler.shared_object_filename (   self,
  basename,
  strip_dir = 0,
  output_dir = '' 
) [inherited]

Definition at line 863 of file ccompiler.py.

00863 
00864     def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
00865         assert output_dir is not None
00866         if strip_dir:
00867             basename = os.path.basename(basename)
00868         return os.path.join(output_dir, basename + self.shared_lib_extension)

def distutils.ccompiler.CCompiler.spawn (   self,
  cmd 
) [inherited]

Definition at line 908 of file ccompiler.py.

00908 
00909     def spawn(self, cmd):
00910         spawn(cmd, dry_run=self.dry_run)

Here is the caller graph for this function:

def distutils.ccompiler.CCompiler.undefine_macro (   self,
  name 
) [inherited]
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.

Definition at line 199 of file ccompiler.py.

00199 
00200     def undefine_macro(self, name):
00201         """Undefine a preprocessor macro for all compilations driven by
00202         this compiler object.  If the same macro is defined by
00203         'define_macro()' and undefined by 'undefine_macro()' the last call
00204         takes precedence (including multiple redefinitions or
00205         undefinitions).  If the macro is redefined/undefined on a
00206         per-compilation basis (ie. in the call to 'compile()'), then that
00207         takes precedence.
00208         """
00209         # Delete from the list of macro definitions/undefinitions if
00210         # already there (so that this one will take precedence).
00211         i = self._find_macro (name)
00212         if i is not None:
00213             del self.macros[i]
00214 
00215         undefn = (name,)
00216         self.macros.append(undefn)

Here is the call graph for this function:

def distutils.ccompiler.CCompiler.warn (   self,
  msg 
) [inherited]

Definition at line 902 of file ccompiler.py.

00902 
00903     def warn(self, msg):
00904         sys.stderr.write("warning: %s\n" % msg)

Here is the caller graph for this function:


Member Data Documentation

Definition at line 335 of file msvc9compiler.py.

Definition at line 332 of file msvc9compiler.py.

Definition at line 330 of file msvc9compiler.py.

Definition at line 329 of file msvc9compiler.py.

Definition at line 311 of file msvc9compiler.py.

list distutils.msvc9compiler.MSVCCompiler._cpp_extensions = ['.cc', '.cpp', '.cxx'] [static, private]

Definition at line 312 of file msvc9compiler.py.

Definition at line 314 of file msvc9compiler.py.

Definition at line 313 of file msvc9compiler.py.

Definition at line 352 of file msvc9compiler.py.

Definition at line 402 of file msvc9compiler.py.

Definition at line 404 of file msvc9compiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 301 of file msvc9compiler.py.

Definition at line 86 of file ccompiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 325 of file msvc9compiler.py.

string distutils.ccompiler.CCompiler.EXECUTABLE = "executable" [static, inherited]

Definition at line 615 of file ccompiler.py.

Definition at line 308 of file msvc9compiler.py.

Definition at line 87 of file ccompiler.py.

Definition at line 101 of file ccompiler.py.

Definition at line 336 of file msvc9compiler.py.

Initial value:
{".c"   : "c",
                    ".cc"  : "c++",
                    ".cpp" : "c++",
                    ".cxx" : "c++",
                    ".m"   : "objc",
                   }

Definition at line 77 of file ccompiler.py.

list distutils.ccompiler.CCompiler.language_order = ["c++", "objc", "c"] [static, inherited]

Definition at line 83 of file ccompiler.py.

Definition at line 413 of file msvc9compiler.py.

Definition at line 415 of file msvc9compiler.py.

Definition at line 418 of file msvc9compiler.py.

Definition at line 354 of file msvc9compiler.py.

Definition at line 105 of file ccompiler.py.

Definition at line 108 of file ccompiler.py.

Definition at line 353 of file msvc9compiler.py.

Definition at line 98 of file ccompiler.py.

Definition at line 356 of file msvc9compiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 321 of file msvc9compiler.py.

Definition at line 116 of file ccompiler.py.

Definition at line 92 of file ccompiler.py.

Definition at line 334 of file msvc9compiler.py.

Definition at line 400 of file msvc9compiler.py.

Definition at line 355 of file msvc9compiler.py.

Definition at line 320 of file msvc9compiler.py.

Definition at line 112 of file ccompiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 323 of file msvc9compiler.py.

Definition at line 68 of file ccompiler.py.

string distutils.ccompiler.CCompiler.SHARED_LIBRARY = "shared_library" [static, inherited]

Definition at line 614 of file ccompiler.py.

string distutils.ccompiler.CCompiler.SHARED_OBJECT = "shared_object" [static, inherited]

Definition at line 613 of file ccompiler.py.

Initial value:
(_c_extensions + _cpp_extensions +
                      _rc_extensions + _mc_extensions)

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 318 of file msvc9compiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 322 of file msvc9compiler.py.

Reimplemented from distutils.ccompiler.CCompiler.

Definition at line 324 of file msvc9compiler.py.

Definition at line 88 of file ccompiler.py.


The documentation for this class was generated from the following file: