home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Freeware 31 / FreelogHS31.iso / Texte / scribus / scribus-1.3.3.9-win32-install.exe / lib / distutils / emxccompiler.py < prev    next >
Text File  |  2004-06-01  |  12KB  |  316 lines
  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: emxccompiler.py,v 1.11 2003/12/02 12:17:59 aimacintyre Exp $"
  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.         s = f.read()
  276.         f.close()
  277.  
  278.     except IOError, exc:
  279.         # if we can't read this file, we cannot say it is wrong
  280.         # the compiler will complain later about this file as missing
  281.         return (CONFIG_H_UNCERTAIN,
  282.                 "couldn't read '%s': %s" % (fn, exc.strerror))
  283.  
  284.     else:
  285.         # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
  286.         if string.find(s,"__GNUC__") >= 0:
  287.             return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
  288.         else:
  289.             return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
  290.  
  291.  
  292. def get_versions():
  293.     """ Try to find out the versions of gcc and ld.
  294.         If not possible it returns None for it.
  295.     """
  296.     from distutils.version import StrictVersion
  297.     from distutils.spawn import find_executable
  298.     import re
  299.  
  300.     gcc_exe = find_executable('gcc')
  301.     if gcc_exe:
  302.         out = os.popen(gcc_exe + ' -dumpversion','r')
  303.         out_string = out.read()
  304.         out.close()
  305.         result = re.search('(\d+\.\d+\.\d+)',out_string)
  306.         if result:
  307.             gcc_version = StrictVersion(result.group(1))
  308.         else:
  309.             gcc_version = None
  310.     else:
  311.         gcc_version = None
  312.     # EMX ld has no way of reporting version number, and we use GCC
  313.     # anyway - so we can link OMF DLLs
  314.     ld_version = None
  315.     return (gcc_version, ld_version)
  316.