wxPython/distutils/command/config.py

   1 """distutils.command.config
   2
   3 Implements the Distutils 'config' command, a (mostly) empty command class
   4 that exists mainly to be sub-classed by specific module distributions and
   5 applications.  The idea is that while every "config" command is different,
   6 at least they're all named the same, and users always see "config" in the
   7 list of standard commands.  Also, this is a good place to put common
   8 configure-like tasks: "try to compile this C code", or "figure out where
   9 this header file lives".
  10 """
  11
  12 # This module should be kept compatible with Python 1.5.2.
  13
  14 __revision__ = "$Id$"
  15
  16 import sys, os, string, re
  17 from types import *
  18 from distutils.core import Command
  19 from distutils.errors import DistutilsExecError
  20 from distutils.sysconfig import customize_compiler
  21 from distutils import log
  22
  23 LANG_EXT = {'c': '.c',
  24             'c++': '.cxx'}
  25
  26 class config (Command):
  27
  28     description = "prepare to build"
  29
  30     user_options = [
  31         ('compiler=', None,
  32          "specify the compiler type"),
  33         ('cc=', None,
  34          "specify the compiler executable"),
  35         ('include-dirs=', 'I',
  36          "list of directories to search for header files"),
  37         ('define=', 'D',
  38          "C preprocessor macros to define"),
  39         ('undef=', 'U',
  40          "C preprocessor macros to undefine"),
  41         ('libraries=', 'l',
  42          "external C libraries to link with"),
  43         ('library-dirs=', 'L',
  44          "directories to search for external C libraries"),
  45
  46         ('noisy', None,
  47          "show every action (compile, link, run, ...) taken"),
  48         ('dump-source', None,
  49          "dump generated source files before attempting to compile them"),
  50         ]
  51
  52
  53     # The three standard command methods: since the "config" command
  54     # does nothing by default, these are empty.
  55
  56     def initialize_options (self):
  57         self.compiler = None
  58         self.cc = None
  59         self.include_dirs = None
  60         #self.define = None
  61         #self.undef = None
  62         self.libraries = None
  63         self.library_dirs = None
  64
  65         # maximal output for now
  66         self.noisy = 1
  67         self.dump_source = 1
  68
  69         # list of temporary files generated along-the-way that we have
  70         # to clean at some point
  71         self.temp_files = []
  72
  73     def finalize_options (self):
  74         if self.include_dirs is None:
  75             self.include_dirs = self.distribution.include_dirs or []
  76         elif type(self.include_dirs) is StringType:
  77             self.include_dirs = string.split(self.include_dirs, os.pathsep)
  78
  79         if self.libraries is None:
  80             self.libraries = []
  81         elif type(self.libraries) is StringType:
  82             self.libraries = [self.libraries]
  83
  84         if self.library_dirs is None:
  85             self.library_dirs = []
  86         elif type(self.library_dirs) is StringType:
  87             self.library_dirs = string.split(self.library_dirs, os.pathsep)
  88
  89
  90     def run (self):
  91         pass
  92
  93
  94     # Utility methods for actual "config" commands.  The interfaces are
  95     # loosely based on Autoconf macros of similar names.  Sub-classes
  96     # may use these freely.
  97
  98     def _check_compiler (self):
  99         """Check that 'self.compiler' really is a CCompiler object;
 100         if not, make it one.
 101         """
 102         # We do this late, and only on-demand, because this is an expensive
 103         # import.
 104         from distutils.ccompiler import CCompiler, new_compiler
 105         if not isinstance(self.compiler, CCompiler):
 106             self.compiler = new_compiler(compiler=self.compiler,
 107                                          dry_run=self.dry_run, force=1)
 108             customize_compiler(self.compiler)
 109             if self.include_dirs:
 110                 self.compiler.set_include_dirs(self.include_dirs)
 111             if self.libraries:
 112                 self.compiler.set_libraries(self.libraries)
 113             if self.library_dirs:
 114                 self.compiler.set_library_dirs(self.library_dirs)
 115
 116
 117     def _gen_temp_sourcefile (self, body, headers, lang):
 118         filename = "_configtest" + LANG_EXT[lang]
 119         file = open(filename, "w")
 120         if headers:
 121             for header in headers:
 122                 file.write("#include <%s>\n" % header)
 123             file.write("\n")
 124         file.write(body)
 125         if body[-1] != "\n":
 126             file.write("\n")
 127         file.close()
 128         return filename
 129
 130     def _preprocess (self, body, headers, include_dirs, lang):
 131         src = self._gen_temp_sourcefile(body, headers, lang)
 132         out = "_configtest.i"
 133         self.temp_files.extend([src, out])
 134         self.compiler.preprocess(src, out, include_dirs=include_dirs)
 135         return (src, out)
 136
 137     def _compile (self, body, headers, include_dirs, lang):
 138         src = self._gen_temp_sourcefile(body, headers, lang)
 139         if self.dump_source:
 140             dump_file(src, "compiling '%s':" % src)
 141         (obj,) = self.compiler.object_filenames([src])
 142         self.temp_files.extend([src, obj])
 143         self.compiler.compile([src], include_dirs=include_dirs)
 144         return (src, obj)
 145
 146     def _link (self, body,
 147                headers, include_dirs,
 148                libraries, library_dirs, lang):
 149         (src, obj) = self._compile(body, headers, include_dirs, lang)
 150         prog = os.path.splitext(os.path.basename(src))[0]
 151         self.compiler.link_executable([obj], prog,
 152                                       libraries=libraries,
 153                                       library_dirs=library_dirs,
 154                                       target_lang=lang)
 155
 156         if self.compiler.exe_extension is not None:
 157             prog = prog + self.compiler.exe_extension
 158         self.temp_files.append(prog)
 159
 160         return (src, obj, prog)
 161
 162     def _clean (self, *filenames):
 163         if not filenames:
 164             filenames = self.temp_files
 165             self.temp_files = []
 166         log.info("removing: %s", string.join(filenames))
 167         for filename in filenames:
 168             try:
 169                 os.remove(filename)
 170             except OSError:
 171                 pass
 172
 173
 174     # XXX these ignore the dry-run flag: what to do, what to do? even if
 175     # you want a dry-run build, you still need some sort of configuration
 176     # info.  My inclination is to make it up to the real config command to
 177     # consult 'dry_run', and assume a default (minimal) configuration if
 178     # true.  The problem with trying to do it here is that you'd have to
 179     # return either true or false from all the 'try' methods, neither of
 180     # which is correct.
 181
 182     # XXX need access to the header search path and maybe default macros.
 183
 184     def try_cpp (self, body=None, headers=None, include_dirs=None, lang="c"):
 185         """Construct a source file from 'body' (a string containing lines
 186         of C/C++ code) and 'headers' (a list of header files to include)
 187         and run it through the preprocessor.  Return true if the
 188         preprocessor succeeded, false if there were any errors.
 189         ('body' probably isn't of much use, but what the heck.)
 190         """
 191         from distutils.ccompiler import CompileError
 192         self._check_compiler()
 193         ok = 1
 194         try:
 195             self._preprocess(body, headers, include_dirs, lang)
 196         except CompileError:
 197             ok = 0
 198
 199         self._clean()
 200         return ok
 201
 202     def search_cpp (self, pattern, body=None,
 203                     headers=None, include_dirs=None, lang="c"):
 204         """Construct a source file (just like 'try_cpp()'), run it through
 205         the preprocessor, and return true if any line of the output matches
 206         'pattern'.  'pattern' should either be a compiled regex object or a
 207         string containing a regex.  If both 'body' and 'headers' are None,
 208         preprocesses an empty file -- which can be useful to determine the
 209         symbols the preprocessor and compiler set by default.
 210         """
 211
 212         self._check_compiler()
 213         (src, out) = self._preprocess(body, headers, include_dirs, lang)
 214
 215         if type(pattern) is StringType:
 216             pattern = re.compile(pattern)
 217
 218         file = open(out)
 219         match = 0
 220         while 1:
 221             line = file.readline()
 222             if line == '':
 223                 break
 224             if pattern.search(line):
 225                 match = 1
 226                 break
 227
 228         file.close()
 229         self._clean()
 230         return match
 231
 232     def try_compile (self, body, headers=None, include_dirs=None, lang="c"):
 233         """Try to compile a source file built from 'body' and 'headers'.
 234         Return true on success, false otherwise.
 235         """
 236         from distutils.ccompiler import CompileError
 237         self._check_compiler()
 238         try:
 239             self._compile(body, headers, include_dirs, lang)
 240             ok = 1
 241         except CompileError:
 242             ok = 0
 243
 244         log.info(ok and "success!" or "failure.")
 245         self._clean()
 246         return ok
 247
 248     def try_link (self, body,
 249                   headers=None, include_dirs=None,
 250                   libraries=None, library_dirs=None,
 251                   lang="c"):
 252         """Try to compile and link a source file, built from 'body' and
 253         'headers', to executable form.  Return true on success, false
 254         otherwise.
 255         """
 256         from distutils.ccompiler import CompileError, LinkError
 257         self._check_compiler()
 258         try:
 259             self._link(body, headers, include_dirs,
 260                        libraries, library_dirs, lang)
 261             ok = 1
 262         except (CompileError, LinkError):
 263             ok = 0
 264
 265         log.info(ok and "success!" or "failure.")
 266         self._clean()
 267         return ok
 268
 269     def try_run (self, body,
 270                  headers=None, include_dirs=None,
 271                  libraries=None, library_dirs=None,
 272                  lang="c"):
 273         """Try to compile, link to an executable, and run a program
 274         built from 'body' and 'headers'.  Return true on success, false
 275         otherwise.
 276         """
 277         from distutils.ccompiler import CompileError, LinkError
 278         self._check_compiler()
 279         try:
 280             src, obj, exe = self._link(body, headers, include_dirs,
 281                                        libraries, library_dirs, lang)
 282             self.spawn([exe])
 283             ok = 1
 284         except (CompileError, LinkError, DistutilsExecError):
 285             ok = 0
 286
 287         log.info(ok and "success!" or "failure.")
 288         self._clean()
 289         return ok
 290
 291
 292     # -- High-level methods --------------------------------------------
 293     # (these are the ones that are actually likely to be useful
 294     # when implementing a real-world config command!)
 295
 296     def check_func (self, func,
 297                     headers=None, include_dirs=None,
 298                     libraries=None, library_dirs=None,
 299                     decl=0, call=0):
 300
 301         """Determine if function 'func' is available by constructing a
 302         source file that refers to 'func', and compiles and links it.
 303         If everything succeeds, returns true; otherwise returns false.
 304
 305         The constructed source file starts out by including the header
 306         files listed in 'headers'.  If 'decl' is true, it then declares
 307         'func' (as "int func()"); you probably shouldn't supply 'headers'
 308         and set 'decl' true in the same call, or you might get errors about
 309         a conflicting declarations for 'func'.  Finally, the constructed
 310         'main()' function either references 'func' or (if 'call' is true)
 311         calls it.  'libraries' and 'library_dirs' are used when
 312         linking.
 313         """
 314
 315         self._check_compiler()
 316         body = []
 317         if decl:
 318             body.append("int %s ();" % func)
 319         body.append("int main () {")
 320         if call:
 321             body.append("  %s();" % func)
 322         else:
 323             body.append("  %s;" % func)
 324         body.append("}")
 325         body = string.join(body, "\n") + "\n"
 326
 327         return self.try_link(body, headers, include_dirs,
 328                              libraries, library_dirs)
 329
 330     # check_func ()
 331
 332     def check_lib (self, library, library_dirs=None,
 333                    headers=None, include_dirs=None, other_libraries=[]):
 334         """Determine if 'library' is available to be linked against,
 335         without actually checking that any particular symbols are provided
 336         by it.  'headers' will be used in constructing the source file to
 337         be compiled, but the only effect of this is to check if all the
 338         header files listed are available.  Any libraries listed in
 339         'other_libraries' will be included in the link, in case 'library'
 340         has symbols that depend on other libraries.
 341         """
 342         self._check_compiler()
 343         return self.try_link("int main (void) { }",
 344                              headers, include_dirs,
 345                              [library]+other_libraries, library_dirs)
 346
 347     def check_header (self, header, include_dirs=None,
 348                       library_dirs=None, lang="c"):
 349         """Determine if the system header file named by 'header_file'
 350         exists and can be found by the preprocessor; return true if so,
 351         false otherwise.
 352         """
 353         return self.try_cpp(body="/* No body */", headers=[header],
 354                             include_dirs=include_dirs)
 355
 356
 357 # class config
 358
 359
 360 def dump_file (filename, head=None):
 361     if head is None:
 362         print filename + ":"
 363     else:
 364         print head
 365
 366     file = open(filename)
 367     sys.stdout.write(file.read())
 368     file.close()