Lib/distutils/cygwinccompiler.py

   1 """distutils.cygwinccompiler
   2
   3 Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
   4 handles the Cygwin port of the GNU C compiler to Windows.  It also contains
   5 the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
   6 cygwin in no-cygwin mode).
   7 """
   8
   9 # problems:
  10 #
  11 # * if you use a msvc compiled python version (1.5.2)
  12 #   1. you have to insert a __GNUC__ section in its config.h
  13 #   2. you have to generate a import library for its dll
  14 #      - create a def-file for python??.dll
  15 #      - create a import library using
  16 #             dlltool --dllname python15.dll --def python15.def \
  17 #                       --output-lib libpython15.a
  18 #
  19 #   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
  20 #
  21 # * We put export_symbols in a def-file, and don't use
  22 #   --export-all-symbols because it doesn't worked reliable in some
  23 #   tested configurations. And because other windows compilers also
  24 #   need their symbols specified this no serious problem.
  25 #
  26 # tested configurations:
  27 #
  28 # * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
  29 #   (after patching python's config.h and for C++ some other include files)
  30 #   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
  31 # * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
  32 #   (ld doesn't support -shared, so we use dllwrap)
  33 # * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
  34 #   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
  35 #     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
  36 #   - using gcc -mdll instead dllwrap doesn't work without -static because
  37 #     it tries to link against dlls instead their import libraries. (If
  38 #     it finds the dll first.)
  39 #     By specifying -static we force ld to link against the import libraries,
  40 #     this is windows standard and there are normally not the necessary symbols
  41 #     in the dlls.
  42 #   *** only the version of June 2000 shows these problems
  43 # * cygwin gcc 3.2/ld 2.13.90 works
  44 #   (ld supports -shared)
  45 # * mingw gcc 3.2/ld 2.13 works
  46 #   (ld supports -shared)
  47
  48 # This module should be kept compatible with Python 2.1.
  49
  50 __revision__ = "$Id$"
  51
  52 import os,sys,copy
  53 from distutils.ccompiler import gen_preprocess_options, gen_lib_options
  54 from distutils.unixccompiler import UnixCCompiler
  55 from distutils.file_util import write_file
  56 from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
  57 from distutils import log
  58
  59 class CygwinCCompiler (UnixCCompiler):
  60
  61     compiler_type = 'cygwin'
  62     obj_extension = ".o"
  63     static_lib_extension = ".a"
  64     shared_lib_extension = ".dll"
  65     static_lib_format = "lib%s%s"
  66     shared_lib_format = "%s%s"
  67     exe_extension = ".exe"
  68
  69     def __init__ (self, verbose=0, dry_run=0, force=0):
  70
  71         UnixCCompiler.__init__ (self, verbose, dry_run, force)
  72
  73         (status, details) = check_config_h()
  74         self.debug_print("Python's GCC status: %s (details: %s)" %
  75                          (status, details))
  76         if status is not CONFIG_H_OK:
  77             self.warn(
  78                 "Python's pyconfig.h doesn't seem to support your compiler. "
  79                 "Reason: %s. "
  80                 "Compiling may fail because of undefined preprocessor macros."
  81                 % details)
  82
  83         self.gcc_version, self.ld_version, self.dllwrap_version = \
  84             get_versions()
  85         self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
  86                          (self.gcc_version,
  87                           self.ld_version,
  88                           self.dllwrap_version) )
  89
  90         # ld_version >= "2.10.90" and < "2.13" should also be able to use
  91         # gcc -mdll instead of dllwrap
  92         # Older dllwraps had own version numbers, newer ones use the
  93         # same as the rest of binutils ( also ld )
  94         # dllwrap 2.10.90 is buggy
  95         if self.ld_version >= "2.10.90":
  96             self.linker_dll = "gcc"
  97         else:
  98             self.linker_dll = "dllwrap"
  99
 100         # ld_version >= "2.13" support -shared so use it instead of
 101         # -mdll -static
 102         if self.ld_version >= "2.13":
 103             shared_option = "-shared"
 104         else:
 105             shared_option = "-mdll -static"
 106
 107         # Hard-code GCC because that's what this is all about.
 108         # XXX optimization, warnings etc. should be customizable.
 109         self.set_executables(compiler='gcc -mcygwin -O -Wall',
 110                              compiler_so='gcc -mcygwin -mdll -O -Wall',
 111                              compiler_cxx='g++ -mcygwin -O -Wall',
 112                              linker_exe='gcc -mcygwin',
 113                              linker_so=('%s -mcygwin %s' %
 114                                         (self.linker_dll, shared_option)))
 115
 116         # cygwin and mingw32 need different sets of libraries
 117         if self.gcc_version == "2.91.57":
 118             # cygwin shouldn't need msvcrt, but without the dlls will crash
 119             # (gcc version 2.91.57) -- perhaps something about initialization
 120             self.dll_libraries=["msvcrt"]
 121             self.warn(
 122                 "Consider upgrading to a newer version of gcc")
 123         else:
 124             self.dll_libraries=[]
 125             # Include the appropriate MSVC runtime library if Python was built
 126             # with MSVC 7.0 or 7.1.
 127             msc_pos = sys.version.find('MSC v.')
 128             if msc_pos != -1:
 129                 msc_ver = sys.version[msc_pos+6:msc_pos+10]
 130                 if msc_ver == '1300':
 131                     # MSVC 7.0
 132                     self.dll_libraries = ['msvcr70']
 133                 elif msc_ver == '1310':
 134                     # MSVC 7.1
 135                     self.dll_libraries = ['msvcr71']
 136
 137     # __init__ ()
 138
 139
 140     def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
 141         if ext == '.rc' or ext == '.res':
 142             # gcc needs '.res' and '.rc' compiled to object files !!!
 143             try:
 144                 self.spawn(["windres", "-i", src, "-o", obj])
 145             except DistutilsExecError, msg:
 146                 raise CompileError, msg
 147         else: # for other files use the C-compiler
 148             try:
 149                 self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
 150                            extra_postargs)
 151             except DistutilsExecError, msg:
 152                 raise CompileError, msg
 153
 154     def link (self,
 155               target_desc,
 156               objects,
 157               output_filename,
 158               output_dir=None,
 159               libraries=None,
 160               library_dirs=None,
 161               runtime_library_dirs=None,
 162               export_symbols=None,
 163               debug=0,
 164               extra_preargs=None,
 165               extra_postargs=None,
 166               build_temp=None,
 167               target_lang=None):
 168
 169         # use separate copies, so we can modify the lists
 170         extra_preargs = copy.copy(extra_preargs or [])
 171         libraries = copy.copy(libraries or [])
 172         objects = copy.copy(objects or [])
 173
 174         # Additional libraries
 175         libraries.extend(self.dll_libraries)
 176
 177         # handle export symbols by creating a def-file
 178         # with executables this only works with gcc/ld as linker
 179         if ((export_symbols is not None) and
 180             (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
 181             # (The linker doesn't do anything if output is up-to-date.
 182             # So it would probably better to check if we really need this,
 183             # but for this we had to insert some unchanged parts of
 184             # UnixCCompiler, and this is not what we want.)
 185
 186             # we want to put some files in the same directory as the
 187             # object files are, build_temp doesn't help much
 188             # where are the object files
 189             temp_dir = os.path.dirname(objects[0])
 190             # name of dll to give the helper files the same base name
 191             (dll_name, dll_extension) = os.path.splitext(
 192                 os.path.basename(output_filename))
 193
 194             # generate the filenames for these files
 195             def_file = os.path.join(temp_dir, dll_name + ".def")
 196             lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
 197
 198             # Generate .def file
 199             contents = [
 200                 "LIBRARY %s" % os.path.basename(output_filename),
 201                 "EXPORTS"]
 202             for sym in export_symbols:
 203                 contents.append(sym)
 204             self.execute(write_file, (def_file, contents),
 205                          "writing %s" % def_file)
 206
 207             # next add options for def-file and to creating import libraries
 208
 209             # dllwrap uses different options than gcc/ld
 210             if self.linker_dll == "dllwrap":
 211                 extra_preargs.extend(["--output-lib", lib_file])
 212                 # for dllwrap we have to use a special option
 213                 extra_preargs.extend(["--def", def_file])
 214             # we use gcc/ld here and can be sure ld is >= 2.9.10
 215             else:
 216                 # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
 217                 #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
 218                 # for gcc/ld the def-file is specified as any object files
 219                 objects.append(def_file)
 220
 221         #end: if ((export_symbols is not None) and
 222         #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
 223
 224         # who wants symbols and a many times larger output file
 225         # should explicitly switch the debug mode on
 226         # otherwise we let dllwrap/ld strip the output file
 227         # (On my machine: 10KB < stripped_file < ??100KB
 228         #   unstripped_file = stripped_file + XXX KB
 229         #  ( XXX=254 for a typical python extension))
 230         if not debug:
 231             extra_preargs.append("-s")
 232
 233         UnixCCompiler.link(self,
 234                            target_desc,
 235                            objects,
 236                            output_filename,
 237                            output_dir,
 238                            libraries,
 239                            library_dirs,
 240                            runtime_library_dirs,
 241                            None, # export_symbols, we do this in our def-file
 242                            debug,
 243                            extra_preargs,
 244                            extra_postargs,
 245                            build_temp,
 246                            target_lang)
 247
 248     # link ()
 249
 250     # -- Miscellaneous methods -----------------------------------------
 251
 252     # overwrite the one from CCompiler to support rc and res-files
 253     def object_filenames (self,
 254                           source_filenames,
 255                           strip_dir=0,
 256                           output_dir=''):
 257         if output_dir is None: output_dir = ''
 258         obj_names = []
 259         for src_name in source_filenames:
 260             # use normcase to make sure '.rc' is really '.rc' and not '.RC'
 261             (base, ext) = os.path.splitext (os.path.normcase(src_name))
 262             if ext not in (self.src_extensions + ['.rc','.res']):
 263                 raise UnknownFileError, \
 264                       "unknown file type '%s' (from '%s')" % \
 265                       (ext, src_name)
 266             if strip_dir:
 267                 base = os.path.basename (base)
 268             if ext == '.res' or ext == '.rc':
 269                 # these need to be compiled to object files
 270                 obj_names.append (os.path.join (output_dir,
 271                                             base + ext + self.obj_extension))
 272             else:
 273                 obj_names.append (os.path.join (output_dir,
 274                                             base + self.obj_extension))
 275         return obj_names
 276
 277     # object_filenames ()
 278
 279 # class CygwinCCompiler
 280
 281
 282 # the same as cygwin plus some additional parameters
 283 class Mingw32CCompiler (CygwinCCompiler):
 284
 285     compiler_type = 'mingw32'
 286
 287     def __init__ (self,
 288                   verbose=0,
 289                   dry_run=0,
 290                   force=0):
 291
 292         CygwinCCompiler.__init__ (self, verbose, dry_run, force)
 293
 294         # ld_version >= "2.13" support -shared so use it instead of
 295         # -mdll -static
 296         if self.ld_version >= "2.13":
 297             shared_option = "-shared"
 298         else:
 299             shared_option = "-mdll -static"
 300
 301         # A real mingw32 doesn't need to specify a different entry point,
 302         # but cygwin 2.91.57 in no-cygwin-mode needs it.
 303         if self.gcc_version <= "2.91.57":
 304             entry_point = '--entry _DllMain@12'
 305         else:
 306             entry_point = ''
 307
 308         self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
 309                              compiler_so='gcc -mno-cygwin -mdll -O -Wall',
 310                              compiler_cxx='g++ -mno-cygwin -O -Wall',
 311                              linker_exe='gcc -mno-cygwin',
 312                              linker_so='%s -mno-cygwin %s %s'
 313                                         % (self.linker_dll, shared_option,
 314                                            entry_point))
 315         # Maybe we should also append -mthreads, but then the finished
 316         # dlls need another dll (mingwm10.dll see Mingw32 docs)
 317         # (-mthreads: Support thread-safe exception handling on `Mingw32')
 318
 319         # no additional libraries needed
 320         self.dll_libraries=[]
 321
 322         # Include the appropriate MSVC runtime library if Python was built
 323         # with MSVC 7.0 or 7.1.
 324         msc_pos = sys.version.find('MSC v.')
 325         if msc_pos != -1:
 326             msc_ver = sys.version[msc_pos+6:msc_pos+10]
 327             if msc_ver == '1300':
 328                 # MSVC 7.0
 329                 self.dll_libraries = ['msvcr70']
 330             elif msc_ver == '1310':
 331                 # MSVC 7.1
 332                 self.dll_libraries = ['msvcr71']
 333
 334     # __init__ ()
 335
 336 # class Mingw32CCompiler
 337
 338 # Because these compilers aren't configured in Python's pyconfig.h file by
 339 # default, we should at least warn the user if he is using a unmodified
 340 # version.
 341
 342 CONFIG_H_OK = "ok"
 343 CONFIG_H_NOTOK = "not ok"
 344 CONFIG_H_UNCERTAIN = "uncertain"
 345
 346 def check_config_h():
 347
 348     """Check if the current Python installation (specifically, pyconfig.h)
 349     appears amenable to building extensions with GCC.  Returns a tuple
 350     (status, details), where 'status' is one of the following constants:
 351       CONFIG_H_OK
 352         all is well, go ahead and compile
 353       CONFIG_H_NOTOK
 354         doesn't look good
 355       CONFIG_H_UNCERTAIN
 356         not sure -- unable to read pyconfig.h
 357     'details' is a human-readable string explaining the situation.
 358
 359     Note there are two ways to conclude "OK": either 'sys.version' contains
 360     the string "GCC" (implying that this Python was built with GCC), or the
 361     installed "pyconfig.h" contains the string "__GNUC__".
 362     """
 363
 364     # XXX since this function also checks sys.version, it's not strictly a
 365     # "pyconfig.h" check -- should probably be renamed...
 366
 367     from distutils import sysconfig
 368     import string
 369     # if sys.version contains GCC then python was compiled with
 370     # GCC, and the pyconfig.h file should be OK
 371     if string.find(sys.version,"GCC") >= 0:
 372         return (CONFIG_H_OK, "sys.version mentions 'GCC'")
 373
 374     fn = sysconfig.get_config_h_filename()
 375     try:
 376         # It would probably better to read single lines to search.
 377         # But we do this only once, and it is fast enough
 378         f = open(fn)
 379         s = f.read()
 380         f.close()
 381
 382     except IOError, exc:
 383         # if we can't read this file, we cannot say it is wrong
 384         # the compiler will complain later about this file as missing
 385         return (CONFIG_H_UNCERTAIN,
 386                 "couldn't read '%s': %s" % (fn, exc.strerror))
 387
 388     else:
 389         # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
 390         if string.find(s,"__GNUC__") >= 0:
 391             return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
 392         else:
 393             return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
 394
 395
 396
 397 def get_versions():
 398     """ Try to find out the versions of gcc, ld and dllwrap.
 399         If not possible it returns None for it.
 400     """
 401     from distutils.version import StrictVersion
 402     from distutils.spawn import find_executable
 403     import re
 404
 405     gcc_exe = find_executable('gcc')
 406     if gcc_exe:
 407         out = os.popen(gcc_exe + ' -dumpversion','r')
 408         out_string = out.read()
 409         out.close()
 410         result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
 411         if result:
 412             gcc_version = StrictVersion(result.group(1))
 413         else:
 414             gcc_version = None
 415     else:
 416         gcc_version = None
 417     ld_exe = find_executable('ld')
 418     if ld_exe:
 419         out = os.popen(ld_exe + ' -v','r')
 420         out_string = out.read()
 421         out.close()
 422         result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
 423         if result:
 424             ld_version = StrictVersion(result.group(1))
 425         else:
 426             ld_version = None
 427     else:
 428         ld_version = None
 429     dllwrap_exe = find_executable('dllwrap')
 430     if dllwrap_exe:
 431         out = os.popen(dllwrap_exe + ' --version','r')
 432         out_string = out.read()
 433         out.close()
 434         result = re.search(' (\d+\.\d+(\.\d+)*)',out_string)
 435         if result:
 436             dllwrap_version = StrictVersion(result.group(1))
 437         else:
 438             dllwrap_version = None
 439     else:
 440         dllwrap_version = None
 441     return (gcc_version, ld_version, dllwrap_version)