1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
"""distutils.ccompiler
Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio """
# created 1999/08/19, Perry Stoll
#
__rcsid__ = "$Id$"
import os
import sys
from distutils.errors import *
from distutils.ccompiler import \
CCompiler, gen_preprocess_options, gen_lib_options
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,
dry_run=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
self.add_library ( "python" + sys.version[0] + sys.version[2] )
self.add_library_dir( os.path.join( sys.exec_prefix, 'libs' ) )
self.cc = "cl.exe"
self.link = "link.exe"
self.preprocess_options = None
self.compile_options = [ '/nologo' ]
self.ldflags_shared = ['/DLL', '/nologo']
self.ldflags_static = [ '/nologo']
# -- Worker methods ------------------------------------------------
# (must be implemented by subclasses)
_c_extensions = [ '.c' ]
_cpp_extensions = [ '.cc', '.cpp' ]
_obj_ext = '.obj'
_exe_ext = '.exe'
_shared_lib_ext = '.dll'
_static_lib_ext = '.lib'
def compile (self,
sources,
macros=None,
includes=None):
"""Compile one or more C/C++ source files. 'sources' must be
a list of strings, each one the name of a C/C++ source
file. Return a list of the object filenames generated
(one for each source filename in 'sources').
'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.
'includes', if given, must be a list of strings, the directories
to add to the default include file search path for this
compilation only."""
if macros is None:
macros = []
if includes is None:
includes = []
objectFiles = []
base_pp_opts = gen_preprocess_options (self.macros + macros,
self.include_dirs + includes)
base_pp_opts.append('/c')
for srcFile in sources:
base,ext = os.path.splitext(srcFile)
objFile = base + ".obj"
if ext in self._c_extensions:
fileOpt = "/Tc"
elif ext in self._cpp_extensions:
fileOpt = "/Tp"
inputOpt = fileOpt + srcFile
outputOpt = "/Fo" + objFile
pp_opts = base_pp_opts + [ outputOpt, inputOpt ]
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()'?
def link_static_lib (self,
objects,
output_libname,
libraries=None,
library_dirs=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.
'library_dirs', if supplied, should be a list of additional
directories to search on top of the system default and those
supplied to 'add_library_dir()' and/or 'set_library_dirs()'."""
if libraries is None:
libraries = []
if library_dirs is None:
library_dirs = []
if build_info is None:
build_info = {}
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'] )
ld_args = self.ldflags_static + lib_opts + \
objects + ['/OUT:' + output_filename]
self.spawn ( [ self.link ] + ld_args )
def link_shared_lib (self,
objects,
output_libname,
libraries=None,
library_dirs=None,
build_info=None):
"""Link a bunch of stuff together to create a shared library
file. Has the same effect as 'link_static_lib()' except
that the filename inferred from 'output_libname' will most
likely be different, and the type of file generated will
almost certainly be different."""
# XXX should we sanity check the library name? (eg. no
# slashes)
self.link_shared_object (objects, self.shared_library_name(output_libname),
build_info=build_info )
def link_shared_object (self,
objects,
output_filename,
libraries=None,
library_dirs=None,
build_info=None):
"""Link a bunch of stuff together to create a shared object
file. Much like 'link_shared_lib()', except the output
filename is explicitly supplied as 'output_filename'."""
if libraries is None:
libraries = []
if library_dirs is None:
library_dirs = []
if build_info is None:
build_info = {}
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'] )
ld_args = self.ldflags_shared + lib_opts + \
objects + ['/OUT:' + output_filename]
self.spawn ( [ self.link ] + ld_args )
# -- Filename mangling methods -------------------------------------
def _change_extensions( self, filenames, newExtension ):
object_filenames = []
for srcFile in filenames:
base,ext = os.path.splitext( srcFile )
# XXX should we strip off any existing path?
object_filenames.append( base + newExtension )
return object_filenames
def object_filenames (self, source_filenames):
"""Return the list of object filenames corresponding to each
specified source filename."""
return self._change_extensions( source_filenames, self._obj_ext )
def shared_object_filename (self, source_filename):
"""Return the shared object filename corresponding to a
specified source filename."""
return self._change_extensions( source_filenames, self._shared_lib_ext )
def library_filename (self, libname):
"""Return the static library filename corresponding to the
specified library name."""
return "lib%s%s" %( libname, self._static_lib_ext )
def shared_library_filename (self, libname):
"""Return the shared library filename corresponding to the
specified library name."""
return "lib%s%s" %( libname, self._shared_lib_ext )
# class MSVCCompiler
|
