1 """distutils.msvccompiler 2 3 Contains MSVCCompiler, an implementation of the abstract CCompiler class 4 for the Microsoft Visual Studio. 5 """ 6 7 # Written by Perry Stoll 8 # hacked by Robin Becker and Thomas Heller to do a better job of 9 # finding DevStudio (through the registry) 10 11 __revision__ = "$Id$" 12 13 import sys 14 import os 15 import string 16 17 from distutils.errors import (DistutilsExecError, DistutilsPlatformError, 18 CompileError, LibError, LinkError) 19 from distutils.ccompiler import CCompiler, gen_lib_options 20 from distutils import log 21 22 _can_read_reg = 0 23 try: 24 import _winreg 25 26 _can_read_reg = 1 27 hkey_mod = _winreg 28 29 RegOpenKeyEx = _winreg.OpenKeyEx 30 RegEnumKey = _winreg.EnumKey 31 RegEnumValue = _winreg.EnumValue 32 RegError = _winreg.error 33 34 except ImportError: 35 try: 36 import win32api 37 import win32con 38 _can_read_reg = 1 39 hkey_mod = win32con 40 41 RegOpenKeyEx = win32api.RegOpenKeyEx 42 RegEnumKey = win32api.RegEnumKey 43 RegEnumValue = win32api.RegEnumValue 44 RegError = win32api.error 45 46 except ImportError: 47 log.info("Warning: Can't read registry to find the " 48 "necessary compiler setting\n" 49 "Make sure that Python modules _winreg, " 50 "win32api or win32con are installed.") 51 pass 52 53 if _can_read_reg: 54 HKEYS = (hkey_mod.HKEY_USERS, 55 hkey_mod.HKEY_CURRENT_USER, 56 hkey_mod.HKEY_LOCAL_MACHINE, 57 hkey_mod.HKEY_CLASSES_ROOT) 58 59 def read_keys(base, key): 60 """Return list of registry keys.""" 61 62 try: 63 handle = RegOpenKeyEx(base, key) 64 except RegError: 65 return None 66 L = [] 67 i = 0 68 while 1: 69 try: 70 k = RegEnumKey(handle, i) 71 except RegError: 72 break 73 L.append(k) 74 i = i + 1 75 return L 76 77 def read_values(base, key): 78 """Return dict of registry keys and values. 79 80 All names are converted to lowercase. 81 """ 82 try: 83 handle = RegOpenKeyEx(base, key) 84 except RegError: 85 return None 86 d = {} 87 i = 0 88 while 1: 89 try: 90 name, value, type = RegEnumValue(handle, i) 91 except RegError: 92 break 93 name = name.lower() 94 d[convert_mbcs(name)] = convert_mbcs(value) 95 i = i + 1 96 return d 97 98 def convert_mbcs(s): 99 enc = getattr(s, "encode", None) 100 if enc is not None: 101 try: 102 s = enc("mbcs") 103 except UnicodeError: 104 pass 105 return s 106 107 class MacroExpander: 108 109 def __init__(self, version): 110 self.macros = {} 111 self.load_macros(version) 112 113 def set_macro(self, macro, path, key): 114 for base in HKEYS: 115 d = read_values(base, path) 116 if d: 117 self.macros["$(%s)" % macro] = d[key] 118 break 119 120 def load_macros(self, version): 121 vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version 122 self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir") 123 self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir") 124 net = r"Software\Microsoft\.NETFramework" 125 self.set_macro("FrameworkDir", net, "installroot") 126 try: 127 if version > 7.0: 128 self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1") 129 else: 130 self.set_macro("FrameworkSDKDir", net, "sdkinstallroot") 131 except KeyError: 132 raise DistutilsPlatformError, \ 133 ("""Python was built with Visual Studio 2003; 134 extensions must be built with a compiler than can generate compatible binaries. 135 Visual Studio 2003 was not found on this system. If you have Cygwin installed, 136 you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""") 137 138 p = r"Software\Microsoft\NET Framework Setup\Product" 139 for base in HKEYS: 140 try: 141 h = RegOpenKeyEx(base, p) 142 except RegError: 143 continue 144 key = RegEnumKey(h, 0) 145 d = read_values(base, r"%s\%s" % (p, key)) 146 self.macros["$(FrameworkVersion)"] = d["version"] 147 148 def sub(self, s): 149 for k, v in self.macros.items(): 150 s = string.replace(s, k, v) 151 return s 152 153 def get_build_version(): 154 """Return the version of MSVC that was used to build Python. 155 156 For Python 2.3 and up, the version number is included in 157 sys.version. For earlier versions, assume the compiler is MSVC 6. 158 """ 159 160 prefix = "MSC v." 161 i = string.find(sys.version, prefix) 162 if i == -1: 163 return 6 164 i = i + len(prefix) 165 s, rest = sys.version[i:].split(" ", 1) 166 majorVersion = int(s[:-2]) - 6 167 minorVersion = int(s[2:3]) / 10.0 168 # I don't think paths are affected by minor version in version 6 169 if majorVersion == 6: 170 minorVersion = 0 171 if majorVersion >= 6: 172 return majorVersion + minorVersion 173 # else we don't know what version of the compiler this is 174 return None 175 176 def get_build_architecture(): 177 """Return the processor architecture. 178 179 Possible results are "Intel", "Itanium", or "AMD64". 180 """ 181 182 prefix = " bit (" 183 i = string.find(sys.version, prefix) 184 if i == -1: 185 return "Intel" 186 j = string.find(sys.version, ")", i) 187 return sys.version[i+len(prefix):j] 188 189 def normalize_and_reduce_paths(paths): 190 """Return a list of normalized paths with duplicates removed. 191 192 The current order of paths is maintained. 193 """ 194 # Paths are normalized so things like: /a and /a/ aren't both preserved. 195 reduced_paths = [] 196 for p in paths: 197 np = os.path.normpath(p) 198 # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set. 199 if np not in reduced_paths: 200 reduced_paths.append(np) 201 return reduced_paths 202 203 204 class MSVCCompiler (CCompiler) : 205 """Concrete class that implements an interface to Microsoft Visual C++, 206 as defined by the CCompiler abstract class.""" 207 208 compiler_type = 'msvc' 209 210 # Just set this so CCompiler's constructor doesn't barf. We currently 211 # don't use the 'set_executables()' bureaucracy provided by CCompiler, 212 # as it really isn't necessary for this sort of single-compiler class. 213 # Would be nice to have a consistent interface with UnixCCompiler, 214 # though, so it's worth thinking about. 215 executables = {} 216 217 # Private class data (need to distinguish C from C++ source for compiler) 218 _c_extensions = ['.c'] 219 _cpp_extensions = ['.cc', '.cpp', '.cxx'] 220 _rc_extensions = ['.rc'] 221 _mc_extensions = ['.mc'] 222 223 # Needed for the filename generation methods provided by the 224 # base class, CCompiler. 225 src_extensions = (_c_extensions + _cpp_extensions + 226 _rc_extensions + _mc_extensions) 227 res_extension = '.res' 228 obj_extension = '.obj' 229 static_lib_extension = '.lib' 230 shared_lib_extension = '.dll' 231 static_lib_format = shared_lib_format = '%s%s' 232 exe_extension = '.exe' 233 234 def __init__ (self, verbose=0, dry_run=0, force=0): 235 CCompiler.__init__ (self, verbose, dry_run, force) 236 self.__version = get_build_version() 237 self.__arch = get_build_architecture() 238 if self.__arch == "Intel": 239 # x86 240 if self.__version >= 7: 241 self.__root = r"Software\Microsoft\VisualStudio" 242 self.__macros = MacroExpander(self.__version) 243 else: 244 self.__root = r"Software\Microsoft\Devstudio" 245 self.__product = "Visual Studio version %s" % self.__version 246 else: 247 # Win64. Assume this was built with the platform SDK 248 self.__product = "Microsoft SDK compiler %s" % (self.__version + 6) 249 250 self.initialized = False 251 252 def initialize(self): 253 self.__paths = [] 254 if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"): 255 # Assume that the SDK set up everything alright; don't try to be 256 # smarter 257 self.cc = "cl.exe" 258 self.linker = "link.exe" 259 self.lib = "lib.exe" 260 self.rc = "rc.exe" 261 self.mc = "mc.exe" 262 else: 263 self.__paths = self.get_msvc_paths("path") 264 265 if len (self.__paths) == 0: 266 raise DistutilsPlatformError, \ 267 ("Python was built with %s, " 268 "and extensions need to be built with the same " 269 "version of the compiler, but it isn't installed." % self.__product) 270 271 self.cc = self.find_exe("cl.exe") 272 self.linker = self.find_exe("link.exe") 273 self.lib = self.find_exe("lib.exe") 274 self.rc = self.find_exe("rc.exe") # resource compiler 275 self.mc = self.find_exe("mc.exe") # message compiler 276 self.set_path_env_var('lib') 277 self.set_path_env_var('include') 278 279 # extend the MSVC path with the current path 280 try: 281 for p in string.split(os.environ['path'], ';'): 282 self.__paths.append(p) 283 except KeyError: 284 pass 285 self.__paths = normalize_and_reduce_paths(self.__paths) 286 os.environ['path'] = string.join(self.__paths, ';') 287 288 self.preprocess_options = None 289 if self.__arch == "Intel": 290 self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GX' , 291 '/DNDEBUG'] 292 self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX', 293 '/Z7', '/D_DEBUG'] 294 else: 295 # Win64 296 self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' , 297 '/DNDEBUG'] 298 self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-', 299 '/Z7', '/D_DEBUG'] 300 301 self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO'] 302 if self.__version >= 7: 303 self.ldflags_shared_debug = [ 304 '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG' 305 ] 306 else: 307 self.ldflags_shared_debug = [ 308 '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG' 309 ] 310 self.ldflags_static = [ '/nologo'] 311 312 self.initialized = True 313 314 # -- Worker methods ------------------------------------------------ 315 316 def object_filenames (self, 317 source_filenames, 318 strip_dir=0, 319 output_dir=''): 320 # Copied from ccompiler.py, extended to return .res as 'object'-file 321 # for .rc input file 322 if output_dir is None: output_dir = '' 323 obj_names = [] 324 for src_name in source_filenames: 325 (base, ext) = os.path.splitext (src_name) 326 base = os.path.splitdrive(base)[1] # Chop off the drive 327 base = base[os.path.isabs(base):] # If abs, chop off leading / 328 if ext not in self.src_extensions: 329 # Better to raise an exception instead of silently continuing 330 # and later complain about sources and targets having 331 # different lengths 332 raise CompileError ("Don't know how to compile %s" % src_name) 333 if strip_dir: 334 base = os.path.basename (base) 335 if ext in self._rc_extensions: 336 obj_names.append (os.path.join (output_dir, 337 base + self.res_extension)) 338 elif ext in self._mc_extensions: 339 obj_names.append (os.path.join (output_dir, 340 base + self.res_extension)) 341 else: 342 obj_names.append (os.path.join (output_dir, 343 base + self.obj_extension)) 344 return obj_names 345 346 # object_filenames () 347 348 349 def compile(self, sources, 350 output_dir=None, macros=None, include_dirs=None, debug=0, 351 extra_preargs=None, extra_postargs=None, depends=None): 352 353 if not self.initialized: self.initialize() 354 macros, objects, extra_postargs, pp_opts, build = \ 355 self._setup_compile(output_dir, macros, include_dirs, sources, 356 depends, extra_postargs) 357 358 compile_opts = extra_preargs or [] 359 compile_opts.append ('/c') 360 if debug: 361 compile_opts.extend(self.compile_options_debug) 362 else: 363 compile_opts.extend(self.compile_options) 364 365 for obj in objects: 366 try: 367 src, ext = build[obj] 368 except KeyError: 369 continue 370 if debug: 371 # pass the full pathname to MSVC in debug mode, 372 # this allows the debugger to find the source file 373 # without asking the user to browse for it 374 src = os.path.abspath(src) 375 376 if ext in self._c_extensions: 377 input_opt = "/Tc" + src 378 elif ext in self._cpp_extensions: 379 input_opt = "/Tp" + src 380 elif ext in self._rc_extensions: 381 # compile .RC to .RES file 382 input_opt = src 383 output_opt = "/fo" + obj 384 try: 385 self.spawn ([self.rc] + pp_opts + 386 [output_opt] + [input_opt]) 387 except DistutilsExecError, msg: 388 raise CompileError, msg 389 continue 390 elif ext in self._mc_extensions: 391 392 # Compile .MC to .RC file to .RES file. 393 # * '-h dir' specifies the directory for the 394 # generated include file 395 # * '-r dir' specifies the target directory of the 396 # generated RC file and the binary message resource 397 # it includes 398 # 399 # For now (since there are no options to change this), 400 # we use the source-directory for the include file and 401 # the build directory for the RC file and message 402 # resources. This works at least for win32all. 403 404 h_dir = os.path.dirname (src) 405 rc_dir = os.path.dirname (obj) 406 try: 407 # first compile .MC to .RC and .H file 408 self.spawn ([self.mc] + 409 ['-h', h_dir, '-r', rc_dir] + [src]) 410 base, _ = os.path.splitext (os.path.basename (src)) 411 rc_file = os.path.join (rc_dir, base + '.rc') 412 # then compile .RC to .RES file 413 self.spawn ([self.rc] + 414 ["/fo" + obj] + [rc_file]) 415 416 except DistutilsExecError, msg: 417 raise CompileError, msg 418 continue 419 else: 420 # how to handle this file? 421 raise CompileError ( 422 "Don't know how to compile %s to %s" % \ 423 (src, obj)) 424 425 output_opt = "/Fo" + obj 426 try: 427 self.spawn ([self.cc] + compile_opts + pp_opts + 428 [input_opt, output_opt] + 429 extra_postargs) 430 except DistutilsExecError, msg: 431 raise CompileError, msg 432 433 return objects 434 435 # compile () 436 437 438 def create_static_lib (self, 439 objects, 440 output_libname, 441 output_dir=None, 442 debug=0, 443 target_lang=None): 444 445 if not self.initialized: self.initialize() 446 (objects, output_dir) = self._fix_object_args (objects, output_dir) 447 output_filename = \ 448 self.library_filename (output_libname, output_dir=output_dir) 449 450 if self._need_link (objects, output_filename): 451 lib_args = objects + ['/OUT:' + output_filename] 452 if debug: 453 pass # XXX what goes here? 454 try: 455 self.spawn ([self.lib] + lib_args) 456 except DistutilsExecError, msg: 457 raise LibError, msg 458 459 else: 460 log.debug("skipping %s (up-to-date)", output_filename) 461 462 # create_static_lib () 463 464 def link (self, 465 target_desc, 466 objects, 467 output_filename, 468 output_dir=None, 469 libraries=None, 470 library_dirs=None, 471 runtime_library_dirs=None, 472 export_symbols=None, 473 debug=0, 474 extra_preargs=None, 475 extra_postargs=None, 476 build_temp=None, 477 target_lang=None): 478 479 if not self.initialized: self.initialize() 480 (objects, output_dir) = self._fix_object_args (objects, output_dir) 481 (libraries, library_dirs, runtime_library_dirs) = \ 482 self._fix_lib_args (libraries, library_dirs, runtime_library_dirs) 483 484 if runtime_library_dirs: 485 self.warn ("I don't know what to do with 'runtime_library_dirs': " 486 + str (runtime_library_dirs)) 487 488 lib_opts = gen_lib_options (self, 489 library_dirs, runtime_library_dirs, 490 libraries) 491 if output_dir is not None: 492 output_filename = os.path.join (output_dir, output_filename) 493 494 if self._need_link (objects, output_filename): 495 496 if target_desc == CCompiler.EXECUTABLE: 497 if debug: 498 ldflags = self.ldflags_shared_debug[1:] 499 else: 500 ldflags = self.ldflags_shared[1:] 501 else: 502 if debug: 503 ldflags = self.ldflags_shared_debug 504 else: 505 ldflags = self.ldflags_shared 506 507 export_opts = [] 508 for sym in (export_symbols or []): 509 export_opts.append("/EXPORT:" + sym) 510 511 ld_args = (ldflags + lib_opts + export_opts + 512 objects + ['/OUT:' + output_filename]) 513 514 # The MSVC linker generates .lib and .exp files, which cannot be 515 # suppressed by any linker switches. The .lib files may even be 516 # needed! Make sure they are generated in the temporary build 517 # directory. Since they have different names for debug and release 518 # builds, they can go into the same directory. 519 if export_symbols is not None: 520 (dll_name, dll_ext) = os.path.splitext( 521 os.path.basename(output_filename)) 522 implib_file = os.path.join( 523 os.path.dirname(objects[0]), 524 self.library_filename(dll_name)) 525 ld_args.append ('/IMPLIB:' + implib_file) 526 527 if extra_preargs: 528 ld_args[:0] = extra_preargs 529 if extra_postargs: 530 ld_args.extend(extra_postargs) 531 532 self.mkpath (os.path.dirname (output_filename)) 533 try: 534 self.spawn ([self.linker] + ld_args) 535 except DistutilsExecError, msg: 536 raise LinkError, msg 537 538 else: 539 log.debug("skipping %s (up-to-date)", output_filename) 540 541 # link () 542 543 544 # -- Miscellaneous methods ----------------------------------------- 545 # These are all used by the 'gen_lib_options() function, in 546 # ccompiler.py. 547 548 def library_dir_option (self, dir): 549 return "/LIBPATH:" + dir 550 551 def runtime_library_dir_option (self, dir): 552 raise DistutilsPlatformError, \ 553 "don't know how to set runtime library search path for MSVC++" 554 555 def library_option (self, lib): 556 return self.library_filename (lib) 557 558 559 def find_library_file (self, dirs, lib, debug=0): 560 # Prefer a debugging library if found (and requested), but deal 561 # with it if we don't have one. 562 if debug: 563 try_names = [lib + "_d", lib] 564 else: 565 try_names = [lib] 566 for dir in dirs: 567 for name in try_names: 568 libfile = os.path.join(dir, self.library_filename (name)) 569 if os.path.exists(libfile): 570 return libfile 571 else: 572 # Oops, didn't find it in *any* of 'dirs' 573 return None 574 575 # find_library_file () 576 577 # Helper methods for using the MSVC registry settings 578 579 def find_exe(self, exe): 580 """Return path to an MSVC executable program. 581 582 Tries to find the program in several places: first, one of the 583 MSVC program search paths from the registry; next, the directories 584 in the PATH environment variable. If any of those work, return an 585 absolute path that is known to exist. If none of them work, just 586 return the original program name, 'exe'. 587 """ 588 589 for p in self.__paths: 590 fn = os.path.join(os.path.abspath(p), exe) 591 if os.path.isfile(fn): 592 return fn 593 594 # didn't find it; try existing path 595 for p in string.split(os.environ['Path'],';'): 596 fn = os.path.join(os.path.abspath(p),exe) 597 if os.path.isfile(fn): 598 return fn 599 600 return exe 601 602 def get_msvc_paths(self, path, platform='x86'): 603 """Get a list of devstudio directories (include, lib or path). 604 605 Return a list of strings. The list will be empty if unable to 606 access the registry or appropriate registry keys not found. 607 """ 608 609 if not _can_read_reg: 610 return [] 611 612 path = path + " dirs" 613 if self.__version >= 7: 614 key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories" 615 % (self.__root, self.__version)) 616 else: 617 key = (r"%s\6.0\Build System\Components\Platforms" 618 r"\Win32 (%s)\Directories" % (self.__root, platform)) 619 620 for base in HKEYS: 621 d = read_values(base, key) 622 if d: 623 if self.__version >= 7: 624 return string.split(self.__macros.sub(d[path]), ";") 625 else: 626 return string.split(d[path], ";") 627 # MSVC 6 seems to create the registry entries we need only when 628 # the GUI is run. 629 if self.__version == 6: 630 for base in HKEYS: 631 if read_values(base, r"%s\6.0" % self.__root) is not None: 632 self.warn("It seems you have Visual Studio 6 installed, " 633 "but the expected registry settings are not present.\n" 634 "You must at least run the Visual Studio GUI once " 635 "so that these entries are created.") 636 break 637 return [] 638 639 def set_path_env_var(self, name): 640 """Set environment variable 'name' to an MSVC path type value. 641 642 This is equivalent to a SET command prior to execution of spawned 643 commands. 644 """ 645 646 if name == "lib": 647 p = self.get_msvc_paths("library") 648 else: 649 p = self.get_msvc_paths(name) 650 if p: 651 os.environ[name] = string.join(p, ';') 652 653 654 if get_build_version() >= 8.0: 655 log.debug("Importing new compiler from distutils.msvc9compiler") 656 OldMSVCCompiler = MSVCCompiler 657 from distutils.msvc9compiler import MSVCCompiler 658 # get_build_architecture not really relevant now we support cross-compile 659 from distutils.msvc9compiler import MacroExpander 660
