import os
import sys
from distutils.errors import *
-from distutils.ccompiler import CCompiler
+from distutils.ccompiler import \
+ CCompiler, gen_preprocess_options, gen_lib_options
-class MSVCCompiler ( CCompiler) :
- """Abstract base class to define the interface that must be implemented
- by real compiler abstraction classes. Might have some use as a
- place for shared code, but it's not yet clear what code can be
- shared between compiler abstraction models for different platforms.
-
- The basic idea behind a compiler abstraction class is that each
- instance can be used for all the compile/link steps in building
- a single project. Thus, attributes common to all of those compile
- and link steps -- include directories, macros to define, libraries
- to link against, etc. -- are attributes of the compiler instance.
- To allow for variability in how individual files are treated,
- most (all?) of those attributes may be varied on a per-compilation
- or per-link basis."""
+class MSVCCompiler (CCompiler) :
+ """Concrete class that implements an interface to Microsoft Visual C++,
+ as defined by the CCompiler abstract class."""
def __init__ (self,
verbose=0,
CCompiler.__init__ (self, verbose, dry_run)
-
# XXX This is a nasty dependency to add on something otherwise
- # pretty clean. move it to build_ext under an nt
- # specific part.
- # shared libraries need to link against python15.lib
+ # pretty clean. move it to build_ext under an nt specific part.
+ # shared libraries need to link against python15.lib
self.add_library ( "python" + sys.version[0] + sys.version[2] )
self.add_library_dir( os.path.join( sys.exec_prefix, 'libs' ) )
self.ldflags_shared = ['/DLL', '/nologo']
self.ldflags_static = [ '/nologo']
- # XXX things not handled by this compiler abstraction model:
- # * client can't provide additional options for a compiler,
- # e.g. warning, optimization, debugging flags. Perhaps this
- # should be the domain of concrete compiler abstraction classes
- # (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
- # class should have methods for the common ones.
- # * can't put output files (object files, libraries, whatever)
- # into a separate directory from their inputs. Should this be
- # handled by an 'output_dir' attribute of the whole object, or a
- # parameter to the compile/link_* methods, or both?
- # * can't completely override the include or library searchg
- # path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
- # I'm not sure how widely supported this is even by Unix
- # compilers, much less on other platforms. And I'm even less
- # sure how useful it is; maybe for cross-compiling, but
- # support for that is a ways off. (And anyways, cross
- # compilers probably have a dedicated binary with the
- # right paths compiled in. I hope.)
- # * can't do really freaky things with the library list/library
- # dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
- # different versions of libfoo.a in different locations. I
- # think this is useless without the ability to null out the
- # library search path anyways.
-
# -- Worker methods ------------------------------------------------
# (must be implemented by subclasses)
_c_extensions = [ '.c' ]
- _cpp_extensions = [ '.cc', 'cpp' ]
+ _cpp_extensions = [ '.cc', '.cpp' ]
_obj_ext = '.obj'
- _exe_ext = 'exe'
+ _exe_ext = '.exe'
_shared_lib_ext = '.dll'
_static_lib_ext = '.lib'
objectFiles = []
- base_pp_opts = _gen_preprocess_options (self.macros + macros,
- self.include_dirs + includes)
+ base_pp_opts = gen_preprocess_options (self.macros + macros,
+ self.include_dirs + includes)
base_pp_opts.append('/c')
pp_opts = base_pp_opts + [ outputOpt, inputOpt ]
- returnCode = self.spawn( [ self.cc ] + self.compile_options + pp_opts )
- # XXX check for valid return code
-
+ self.spawn( [ self.cc ] + self.compile_options + pp_opts)
objectFiles.append( objFile )
-
return objectFiles
-
+
+
# XXX this is kind of useless without 'link_binary()' or
# 'link_executable()' or something -- or maybe 'link_static_lib()'
# should not exist at all, and we just have 'link_binary()'?
if build_info is None:
build_info = {}
- lib_opts = _gen_lib_options (self.libraries + libraries,
- self.library_dirs + library_dirs)
+ lib_opts = gen_lib_options (self.libraries + libraries,
+ self.library_dirs + library_dirs,
+ "%s.lib", "/LIBPATH:%s")
if build_info.has_key('def_file') :
lib_opts.append('/DEF:' + build_info['def_file'] )
if build_info is None:
build_info = {}
- lib_opts = _gen_lib_options (self.libraries + libraries,
- self.library_dirs + library_dirs)
+ lib_opts = gen_lib_options (self.libraries + libraries,
+ self.library_dirs + library_dirs,
+ "%s.lib", "/LIBPATH:%s")
if build_info.has_key('def_file') :
lib_opts.append('/DEF:' + build_info['def_file'] )
return "lib%s%s" %( libname, self._shared_lib_ext )
# class MSVCCompiler
-
-def _gen_preprocess_options (macros, includes):
-
- # XXX it would be nice (mainly aesthetic, and so we don't generate
- # stupid-looking command lines) to go over 'macros' and eliminate
- # redundant definitions/undefinitions (ie. ensure that only the
- # latest mention of a particular macro winds up on the command
- # line). I don't think it's essential, though, since most (all?)
- # Unix C compilers only pay attention to the latest -D or -U
- # mention of a macro on their command line. Similar situation for
- # 'includes'. I'm punting on both for now. Anyways, weeding out
- # redundancies like this should probably be the province of
- # CCompiler, since the data structures used are inherited from it
- # and therefore common to all CCompiler classes.
-
-
- pp_opts = []
- for macro in macros:
- if len (macro) == 1: # undefine this macro
- pp_opts.append ("-U%s" % macro[0])
- elif len (macro) == 2:
- if macro[1] is None: # define with no explicit value
- pp_opts.append ("-D%s" % macro[0])
- else:
- # XXX *don't* need to be clever about quoting the
- # macro value here, because we're going to avoid the
- # shell at all costs when we spawn the command!
- pp_opts.append ("-D%s=%s" % macro)
-
- for dir in includes:
- pp_opts.append ("-I%s" % dir)
-
- return pp_opts
-
-def _gen_lib_options (libraries, library_dirs):
-
- lib_opts = []
-
- for dir in library_dirs:
- lib_opts.append ("/LIBPATH:%s" % dir)
-
- # XXX it's important that we *not* remove redundant library mentions!
- # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
- # resolve all symbols. I just hope we never have to say "-lfoo obj.o
- # -lbar" to get things to work -- that's certainly a possibility, but a
- # pretty nasty way to arrange your C code.
-
- for lib in libraries:
- lib_opts.append ("%s.lib" % lib) # import libraries end in .lib
-
- return lib_opts
-
-# _gen_lib_options ()
-
-
projects / python / commitdiff