AppPkg/Applications/Python/Python-2.7.2/Lib/distutils/emxccompiler.py

   1 """distutils.emxccompiler
   2
   3 Provides the EMXCCompiler class, a subclass of UnixCCompiler that
   4 handles the EMX port of the GNU C compiler to OS/2.
   5 """
   6
   7 # issues:
   8 #
   9 # * OS/2 insists that DLLs can have names no longer than 8 characters
  10 #   We put export_symbols in a def-file, as though the DLL can have
  11 #   an arbitrary length name, but truncate the output filename.
  12 #
  13 # * only use OMF objects and use LINK386 as the linker (-Zomf)
  14 #
  15 # * always build for multithreading (-Zmt) as the accompanying OS/2 port
  16 #   of Python is only distributed with threads enabled.
  17 #
  18 # tested configurations:
  19 #
  20 # * EMX gcc 2.81/EMX 0.9d fix03
  21
  22 __revision__ = "$Id$"
  23
  24 import os,sys,copy
  25 from distutils.ccompiler import gen_preprocess_options, gen_lib_options
  26 from distutils.unixccompiler import UnixCCompiler
  27 from distutils.file_util import write_file
  28 from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
  29 from distutils import log
  30
  31 class EMXCCompiler (UnixCCompiler):
  32
  33     compiler_type = 'emx'
  34     obj_extension = ".obj"
  35     static_lib_extension = ".lib"
  36     shared_lib_extension = ".dll"
  37     static_lib_format = "%s%s"
  38     shared_lib_format = "%s%s"
  39     res_extension = ".res"      # compiled resource file
  40     exe_extension = ".exe"
  41
  42     def __init__ (self,
  43                   verbose=0,
  44                   dry_run=0,
  45                   force=0):
  46
  47         UnixCCompiler.__init__ (self, verbose, dry_run, force)
  48
  49         (status, details) = check_config_h()
  50         self.debug_print("Python's GCC status: %s (details: %s)" %
  51                          (status, details))
  52         if status is not CONFIG_H_OK:
  53             self.warn(
  54                 "Python's pyconfig.h doesn't seem to support your compiler.  " +
  55                 ("Reason: %s." % details) +
  56                 "Compiling may fail because of undefined preprocessor macros.")
  57
  58         (self.gcc_version, self.ld_version) = \
  59             get_versions()
  60         self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" %
  61                          (self.gcc_version,
  62                           self.ld_version) )
  63
  64         # Hard-code GCC because that's what this is all about.
  65         # XXX optimization, warnings etc. should be customizable.
  66         self.set_executables(compiler='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall',
  67                              compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall',
  68                              linker_exe='gcc -Zomf -Zmt -Zcrtdll',
  69                              linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll')
  70
  71         # want the gcc library statically linked (so that we don't have
  72         # to distribute a version dependent on the compiler we have)
  73         self.dll_libraries=["gcc"]
  74
  75     # __init__ ()
  76
  77     def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
  78         if ext == '.rc':
  79             # gcc requires '.rc' compiled to binary ('.res') files !!!
  80             try:
  81                 self.spawn(["rc", "-r", src])
  82             except DistutilsExecError, msg:
  83                 raise CompileError, msg
  84         else: # for other files use the C-compiler
  85             try:
  86                 self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
  87                            extra_postargs)
  88             except DistutilsExecError, msg:
  89                 raise CompileError, msg
  90
  91     def link (self,
  92               target_desc,
  93               objects,
  94               output_filename,
  95               output_dir=None,
  96               libraries=None,
  97               library_dirs=None,
  98               runtime_library_dirs=None,
  99               export_symbols=None,
 100               debug=0,
 101               extra_preargs=None,
 102               extra_postargs=None,
 103               build_temp=None,
 104               target_lang=None):
 105
 106         # use separate copies, so we can modify the lists
 107         extra_preargs = copy.copy(extra_preargs or [])
 108         libraries = copy.copy(libraries or [])
 109         objects = copy.copy(objects or [])
 110
 111         # Additional libraries
 112         libraries.extend(self.dll_libraries)
 113
 114         # handle export symbols by creating a def-file
 115         # with executables this only works with gcc/ld as linker
 116         if ((export_symbols is not None) and
 117             (target_desc != self.EXECUTABLE)):
 118             # (The linker doesn't do anything if output is up-to-date.
 119             # So it would probably better to check if we really need this,
 120             # but for this we had to insert some unchanged parts of
 121             # UnixCCompiler, and this is not what we want.)
 122
 123             # we want to put some files in the same directory as the
 124             # object files are, build_temp doesn't help much
 125             # where are the object files
 126             temp_dir = os.path.dirname(objects[0])
 127             # name of dll to give the helper files the same base name
 128             (dll_name, dll_extension) = os.path.splitext(
 129                 os.path.basename(output_filename))
 130
 131             # generate the filenames for these files
 132             def_file = os.path.join(temp_dir, dll_name + ".def")
 133
 134             # Generate .def file
 135             contents = [
 136                 "LIBRARY %s INITINSTANCE TERMINSTANCE" % \
 137                 os.path.splitext(os.path.basename(output_filename))[0],
 138                 "DATA MULTIPLE NONSHARED",
 139                 "EXPORTS"]
 140             for sym in export_symbols:
 141                 contents.append('  "%s"' % sym)
 142             self.execute(write_file, (def_file, contents),
 143                          "writing %s" % def_file)
 144
 145             # next add options for def-file and to creating import libraries
 146             # for gcc/ld the def-file is specified as any other object files
 147             objects.append(def_file)
 148
 149         #end: if ((export_symbols is not None) and
 150         #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
 151
 152         # who wants symbols and a many times larger output file
 153         # should explicitly switch the debug mode on
 154         # otherwise we let dllwrap/ld strip the output file
 155         # (On my machine: 10KB < stripped_file < ??100KB
 156         #   unstripped_file = stripped_file + XXX KB
 157         #  ( XXX=254 for a typical python extension))
 158         if not debug:
 159             extra_preargs.append("-s")
 160
 161         UnixCCompiler.link(self,
 162                            target_desc,
 163                            objects,
 164                            output_filename,
 165                            output_dir,
 166                            libraries,
 167                            library_dirs,
 168                            runtime_library_dirs,
 169                            None, # export_symbols, we do this in our def-file
 170                            debug,
 171                            extra_preargs,
 172                            extra_postargs,
 173                            build_temp,
 174                            target_lang)
 175
 176     # link ()
 177
 178     # -- Miscellaneous methods -----------------------------------------
 179
 180     # override the object_filenames method from CCompiler to
 181     # support rc and res-files
 182     def object_filenames (self,
 183                           source_filenames,
 184                           strip_dir=0,
 185                           output_dir=''):
 186         if output_dir is None: output_dir = ''
 187         obj_names = []
 188         for src_name in source_filenames:
 189             # use normcase to make sure '.rc' is really '.rc' and not '.RC'
 190             (base, ext) = os.path.splitext (os.path.normcase(src_name))
 191             if ext not in (self.src_extensions + ['.rc']):
 192                 raise UnknownFileError, \
 193                       "unknown file type '%s' (from '%s')" % \
 194                       (ext, src_name)
 195             if strip_dir:
 196                 base = os.path.basename (base)
 197             if ext == '.rc':
 198                 # these need to be compiled to object files
 199                 obj_names.append (os.path.join (output_dir,
 200                                             base + self.res_extension))
 201             else:
 202                 obj_names.append (os.path.join (output_dir,
 203                                             base + self.obj_extension))
 204         return obj_names
 205
 206     # object_filenames ()
 207
 208     # override the find_library_file method from UnixCCompiler
 209     # to deal with file naming/searching differences
 210     def find_library_file(self, dirs, lib, debug=0):
 211         shortlib = '%s.lib' % lib
 212         longlib = 'lib%s.lib' % lib    # this form very rare
 213
 214         # get EMX's default library directory search path
 215         try:
 216             emx_dirs = os.environ['LIBRARY_PATH'].split(';')
 217         except KeyError:
 218             emx_dirs = []
 219
 220         for dir in dirs + emx_dirs:
 221             shortlibp = os.path.join(dir, shortlib)
 222             longlibp = os.path.join(dir, longlib)
 223             if os.path.exists(shortlibp):
 224                 return shortlibp
 225             elif os.path.exists(longlibp):
 226                 return longlibp
 227
 228         # Oops, didn't find it in *any* of 'dirs'
 229         return None
 230
 231 # class EMXCCompiler
 232
 233
 234 # Because these compilers aren't configured in Python's pyconfig.h file by
 235 # default, we should at least warn the user if he is using a unmodified
 236 # version.
 237
 238 CONFIG_H_OK = "ok"
 239 CONFIG_H_NOTOK = "not ok"
 240 CONFIG_H_UNCERTAIN = "uncertain"
 241
 242 def check_config_h():
 243
 244     """Check if the current Python installation (specifically, pyconfig.h)
 245     appears amenable to building extensions with GCC.  Returns a tuple
 246     (status, details), where 'status' is one of the following constants:
 247       CONFIG_H_OK
 248         all is well, go ahead and compile
 249       CONFIG_H_NOTOK
 250         doesn't look good
 251       CONFIG_H_UNCERTAIN
 252         not sure -- unable to read pyconfig.h
 253     'details' is a human-readable string explaining the situation.
 254
 255     Note there are two ways to conclude "OK": either 'sys.version' contains
 256     the string "GCC" (implying that this Python was built with GCC), or the
 257     installed "pyconfig.h" contains the string "__GNUC__".
 258     """
 259
 260     # XXX since this function also checks sys.version, it's not strictly a
 261     # "pyconfig.h" check -- should probably be renamed...
 262
 263     from distutils import sysconfig
 264     import string
 265     # if sys.version contains GCC then python was compiled with
 266     # GCC, and the pyconfig.h file should be OK
 267     if string.find(sys.version,"GCC") >= 0:
 268         return (CONFIG_H_OK, "sys.version mentions 'GCC'")
 269
 270     fn = sysconfig.get_config_h_filename()
 271     try:
 272         # It would probably better to read single lines to search.
 273         # But we do this only once, and it is fast enough
 274         f = open(fn)
 275         try:
 276             s = f.read()
 277         finally:
 278             f.close()
 279
 280     except IOError, exc:
 281         # if we can't read this file, we cannot say it is wrong
 282         # the compiler will complain later about this file as missing
 283         return (CONFIG_H_UNCERTAIN,
 284                 "couldn't read '%s': %s" % (fn, exc.strerror))
 285
 286     else:
 287         # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
 288         if string.find(s,"__GNUC__") >= 0:
 289             return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
 290         else:
 291             return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
 292
 293
 294 def get_versions():
 295     """ Try to find out the versions of gcc and ld.
 296         If not possible it returns None for it.
 297     """
 298     from distutils.version import StrictVersion
 299     from distutils.spawn import find_executable
 300     import re
 301
 302     gcc_exe = find_executable('gcc')
 303     if gcc_exe:
 304         out = os.popen(gcc_exe + ' -dumpversion','r')
 305         try:
 306             out_string = out.read()
 307         finally:
 308             out.close()
 309         result = re.search('(\d+\.\d+\.\d+)',out_string)
 310         if result:
 311             gcc_version = StrictVersion(result.group(1))
 312         else:
 313             gcc_version = None
 314     else:
 315         gcc_version = None
 316     # EMX ld has no way of reporting version number, and we use GCC
 317     # anyway - so we can link OMF DLLs
 318     ld_version = None
 319     return (gcc_version, ld_version)