class_docstr: Abstract base class to define the interface that must be implemented
  by real compiler classes.  Also has some utility methods used by
  several compiler classes.
  
  The basic idea behind a compiler abstraction class is that each
  instance can be used for all the compile/link steps in building a
  single project.  Thus, attributes common to all of those compile and
  link steps -- include directories, macros to define, libraries to link
  against, etc. -- are attributes of the compiler instance.  To allow for
  variability in how individual files are treated, most of those
  attributes may be varied on a per-compilation or per-link basis.
class_docstr_tok: ["Abstract","base","class","to","define","the","interface","that","must","be","implemented","by","real","compiler","classes",".","Also","has","some","utility","methods","used","by","several","compiler","classes",".","The","basic","idea","behind","a","compiler","abstraction","class","is","that","each","instance","can","be","used","for","all","the","compile\/link","steps","in","building","a","single","project",".","Thus",",","attributes","common","to","all","of","those","compile","and","link","steps","--","include","directories",",","macros","to","define",",","libraries","to","link","against",",","etc",".","--","are","attributes","of","the","compiler","instance",".","To","allow","for","variability","in","how","individual","files","are","treated",",","most","of","those","attributes","may","be","varied","on","a","per-compilation","or","per-link","basis","."]
docstr: Compile one or more source files.
  
  'sources' must be a list of filenames, most likely C/C++
  files, but in reality anything that can be handled by a
  particular compiler and compiler class (eg. MSVCCompiler can
  handle resource files in 'sources').  Return a list of object
  filenames, one per source filename in 'sources'.  Depending on
  the implementation, not all source files will necessarily be
  compiled, but all corresponding object filenames will be
  returned.
  
  If 'output_dir' is given, object files will be put under it, while
  retaining their original path component.  That is, "foo/bar.c"
  normally compiles to "foo/bar.o" (for a Unix implementation); if
  'output_dir' is "build", then it would compile to
  "build/foo/bar.o".
  
  'macros', if given, must be a list of macro definitions.  A macro
  definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
  The former defines a macro; if the value is None, the macro is
  defined without an explicit value.  The 1-tuple case undefines a
  macro.  Later definitions/redefinitions/ undefinitions take
  precedence.
  
  'include_dirs', if given, must be a list of strings, the
  directories to add to the default include file search path for this
  compilation only.
  
  'debug' is a boolean; if true, the compiler will be instructed to
  output debug symbols in (or alongside) the object file(s).
  
  'extra_preargs' and 'extra_postargs' are implementation- dependent.
  On platforms that have the notion of a command-line (e.g. Unix,
  DOS/Windows), they are most likely lists of strings: extra
  command-line arguments to prepend/append to the compiler command
  line.  On other platforms, consult the implementation class
  documentation.  In any event, they are intended as an escape hatch
  for those occasions when the abstract compiler framework doesn't
  cut the mustard.
  
  'depends', if given, is a list of filenames that all targets
  depend on.  If a source file is older than any file in
  depends, then the source file will be recompiled.  This
  supports dependency tracking, but only at a coarse
  granularity.
  
  Raises CompileError on failure.
code: def compile(
      self,
      sources,
      output_dir=None,
      macros=None,
      include_dirs=None,
      debug=0,
      extra_preargs=None,
      extra_postargs=None,
      depends=None,
  ):
      """Compile one or more source files.
  
      'sources' must be a list of filenames, most likely C/C++
      files, but in reality anything that can be handled by a
      particular compiler and compiler class (eg. MSVCCompiler can
      handle resource files in 'sources').  Return a list of object
      filenames, one per source filename in 'sources'.  Depending on
      the implementation, not all source files will necessarily be
      compiled, but all corresponding object filenames will be
      returned.
  
      If 'output_dir' is given, object files will be put under it, while
      retaining their original path component.  That is, "foo/bar.c"
      normally compiles to "foo/bar.o" (for a Unix implementation); if
      'output_dir' is "build", then it would compile to
      "build/foo/bar.o".
  
      'macros', if given, must be a list of macro definitions.  A macro
      definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
      The former defines a macro; if the value is None, the macro is
      defined without an explicit value.  The 1-tuple case undefines a
      macro.  Later definitions/redefinitions/ undefinitions take
      precedence.
  
      'include_dirs', if given, must be a list of strings, the
      directories to add to the default include file search path for this
      compilation only.
  
      'debug' is a boolean; if true, the compiler will be instructed to
      output debug symbols in (or alongside) the object file(s).
  
      'extra_preargs' and 'extra_postargs' are implementation- dependent.
      On platforms that have the notion of a command-line (e.g. Unix,
      DOS/Windows), they are most likely lists of strings: extra
      command-line arguments to prepend/append to the compiler command
      line.  On other platforms, consult the implementation class
      documentation.  In any event, they are intended as an escape hatch
      for those occasions when the abstract compiler framework doesn't
      cut the mustard.
  
      'depends', if given, is a list of filenames that all targets
      depend on.  If a source file is older than any file in
      depends, then the source file will be recompiled.  This
      supports dependency tracking, but only at a coarse
      granularity.
  
      Raises CompileError on failure.
      """
      # A concrete compiler class can either override this method
      # entirely or implement _compile().
      (
          macros,
          objects,
          extra_postargs,
          pp_opts,
          build,
      ) = self._setup_compile(
          output_dir,
          macros,
          include_dirs,
          sources,
          depends,
          extra_postargs,
      )
      cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
  
      for obj in objects:
          try:
              src, ext = build[obj]
          except KeyError:
              continue
          self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
  
      # Return *all* object filenames, not just the ones we just built.
      return objects
  
imports: import sys, os, re
  from distutils.errors import *
  from distutils.spawn import spawn
  from distutils.file_util import move_file
  from distutils.dir_util import mkpath
  from distutils.dep_util import newer_group
  from distutils.util import split_quoted, execute
  from distutils import log
label_desc: Use image node_id 27 for calling the CCompiler obj's underlying member method code with example usage: obj.compile(sources, output_dir, macros, include_dirs, debug, extra_preargs, extra_postargs, depends) and returns: objects