Esempio n. 1
0
 def _setup_compile(self, sources, macros, include_dirs, extra, depends):
   """Process arguments and decide which source files to compile."""
   if macros is None:
     macros = self.macros
   elif typecheck.is_list(macros):
     macros = macros + (self.macros or [])
   else:
     raise TypeError("'macros' (if supplied) must be a list of tuples")
   if include_dirs is None:
     include_dirs = self._include_dirs
   elif typecheck.is_sequence(include_dirs):
     include_dirs = list(include_dirs) + (self._include_dirs or [])
   else:
     raise TypeError("'include_dirs' (if supplied) must be a list of strings")
   if extra is None:
     extra = []
   # List of expected output files
   objects = self.get_object_filenames(sources)
   assert len(objects) == len(sources)
   pp_options = self._gen_preprocess_options(macros, include_dirs)
   build = {}
   for i in range(len(sources)):
     src = sources[i]
     obj = objects[i]
     ext = path_utils.splitext(src)[1]
     path_utils.mkpath(path_utils.dirname(obj), 0777)
     build[obj] = (src, ext)
   return macros, objects, extra, pp_options, build
Esempio n. 2
0
 def compile(self, files=[], output_file=None, macros=None,
             include_dirs=[], debug=False, extra_preopts=None,
             extra_postopts=[], depends=None, link=True):
   if not typecheck.is_list(files):
     raise TypeError("'sources' must be a list")
   files = files + self.get_files()
   # Play with extra preopts and postopts
   extra_preopts = self.get_extra_preopts()
   extra_postopts = self.get_extra_postopts()
   # Setup compilation process first
   if output_file:
     self.set_output_file(output_file)
   include_dirs = set(include_dirs).update(set(self.get_include_dirs()))
   macros, objects, extra_postopts, pp_options, build = \
       self._setup_compile(files, macros, include_dirs, extra_postopts, depends)
   cc_options = self._gen_cc_options(pp_options, debug, extra_preopts)
   for obj in objects:
     try:
       src, ext = build[obj]
     except KeyError:
       continue
     logger.info("Compiling %s" % src)
     # Note: we pass a copy of files, options, etc. since we
     # need to privent their modification
     if not self.is_dry_run_mode_enabled():
       self._compile(obj, src, ext, list(cc_options), extra_postopts, pp_options)
   if link is True:
     self.link(objects, self.get_output_filename())
   return objects
Esempio n. 3
0
  def set_fields(self, fields):
    """Sets message fields.

    :param fields: A list of :class:`Field` instances.

    :raises: TypeError
    """
    self._fields = []
    if not typecheck.is_list(fields) and not typecheck.is_tuple(fields):
      raise TypeError("`fields` has to be list or tuple: %s" % fields)
    for field in fields:
      if typecheck.is_list(field) or typecheck.is_tuple(field):
        field = self.field_type(field[0], field[1])
      elif not isinstance(field, self.field_type):
        field = self.field_type(field)
      self._fields.append(field)
Esempio n. 4
0
  def add_message_handlers(self, message_handlers):
    """Add message handlers.

    :param message_handlers: A list/tuple of :class:`MessageHandler`.
    """
    if not typecheck.is_list(message_handlers):
      raise TypeError('message_handlers has to be a list')
    for handler in message_handlers:
      if isinstance(handler, MessageHandler):
        self.add_message_handler(handler)
      else:
        if not typecheck.is_tuple(handler):
          raise TypeError("handler must be a tuple: %s" % type(handler))
        if len(handler) < 2:
          raise Exception("Handler should have more than two parameters")
        handler = list(handler)
        if typecheck.is_tuple(handler[1]):
          handler[1] = Message(*handler[1])
        else:
          raise TypeError()
        if len(handler) > 2:
          if typecheck.is_tuple(handler[2]):
            handler[2] = Message(*handler[2])
          else:
            raise TypeError()
        handler = MessageHandler(*handler)
      self.add_message_handler(handler)
    return self
Esempio n. 5
0
 def add_sources(self, sources):
   """Adds a list of sources with help of add_source() method. Returns
   nothing.
   """
   if not typecheck.is_list(sources):
     raise TypeError("Not a list of sources: %s" % sources)
   for source in sources:
     self.add_source(source)
Esempio n. 6
0
  def add_mappings(self, mappings):
    """Adds mappings. See also :func:`add_mapping`.

    :param mappings: A list of :class:`Mapping` instances.
    """
    if not typecheck.is_list(mappings):
      raise TypeError("'mappings' must be list")
    for mapping in mappings:
      self.add_mapping(mapping)
Esempio n. 7
0
 def buildpath(self, path, recursive=True):
   """Path will be created if it doesn't exist."""
   if typecheck.is_list(path):
     path = path_utils.join(*path)
   elif not typecheck.is_string(path):
     raise TypeError("path can be only a string or list")
   path = path_utils.join(self.get_build_dir(), path)
   if path_utils.exists(path):
     return path
   return path_utils.touch(path, recursive=recursive)
Esempio n. 8
0
  def register_threads(self, threads):
    """Register threads.

    :param threads: A list of :class:`Thread` instances.
    :raises: :class:`TypeError`
    """
    if not typecheck.is_list(threads):
      raise TypeError()
    for thread in threads:
      self.register_thread(thread)
Esempio n. 9
0
  def add_include_dirs(self, pathes):
    """Add a list of dirs `pathes` to the list of directories that will be
    searched for header files. See :func:`add_include_dir`.

    :param pathes: A list of strings.

    :raises: TypeError
    """
    if not typecheck.is_list(pathes):
      raise TypeError()
    for path in pathes:
      self.add_include_dir(path)
Esempio n. 10
0
 def _add_callable_source(self, func):
   if not callable(func):
     raise TypeError()
   required_args = []
   if hasattr(func, "func_code"):
     if func.func_code.co_argcount >= 2:
       required_args = [self, self.get_target()]
   else:
     required_args = [self, self.get_target()]
   extra_sources = func(*required_args)
   if extra_sources:
     extra_sources = typecheck.is_list(extra_sources) and extra_sources or \
         [extra_sources]
     self.add_sources(extra_sources)
Esempio n. 11
0
 def add_dependency(self, dep):
   rule = None
   if typecheck.is_tuple(dep) or typecheck.is_list(dep):
     rule = Fork(name="r%d" % hash(dep), deps=dep)
   else:
     rule = isinstance(dep, Rule) and dep or parse_address(dep)
   if rule:
     dep = rule
   else:
     if callable(dep):
       dep = new.instancemethod(dep, self, self.__class__)
       extra_deps = dep(self.target)
       if extra_deps:
         self.add_dependencies(extra_deps)
       return
   dependency_graph.add_edge(self, dep)
   self._dependencies.append(dep)
Esempio n. 12
0
 def identify_language(self, sources):
   """Identify the language of a given file, or list of files. Uses
   language_map, and :func:`CCompiler.get_language_precedence_order` to do the
   job.
   """
   if not typecheck.is_list(sources):
     sources = [sources]
   lang = None
   index = len(self.language_order)
   for source in sources:
     base, ext = path_utils.splitext(source)
     extlang = self.language_map.get(ext)
     try:
       extindex = self.language_order.index(extlang)
       if extindex < index:
         lang = extlang
         index = extindex
     except ValueError:
       pass
   return lang
Esempio n. 13
0
  def add_file(self, path):
    """Adds file to the list of files. The path will be normalized by using
    :func:`os.path.abspath`.

    :param path: A string that represents file path.

    :returns: A normalized string path.

    :raises: TypeError
    """
    if typecheck.is_string(path):
      if not path_utils.exists(path):
        caller_frame = inspect.getouterframes(inspect.currentframe(), 2)
        filename = inspect.getsourcefile(caller_frame[2][0])
        possible_dir = path_utils.dirname(filename)
        alternative_path = path_utils.join(possible_dir, path)
        if path_utils.exists(alternative_path):
          return self.add_file(alternative_path)
      path = path_utils.abspath(path)
      if not path_utils.exists(path):
        raise Exception("Path doesn't exist: %s" % path)
      if not path in self._files:
        self._files.append(path)
      return path
    elif typecheck.is_callable(path):
      result = path()
      if not result:
        return
      elif typecheck.is_list(result):
        self.add_files(result)
      else:
        self.add_file(result)
    elif not path:
      return None
    else:
      raise TypeError("Unknown path type '%s' of '%s'" % (type(path), path))
Esempio n. 14
0
 def register_threads(self, threads):
   if not typecheck.is_list(threads):
     raise TypeError("Must be list")
   for thread in threads:
     self.register_thread(thread)
Esempio n. 15
0
  if dry_run:
    return
  cmdtuples = []
  _build_tuple(directory, cmdtuples)
  for cmd in cmdtuples:
    try:
      cmd[0](cmd[1])
      # remove dir from cache if it's already there
      abspath = abspath(cmd[1])
      if abspath in _path_created:
        del _path_created[abspath]
    except (IOError, OSError), exc:
      print exc, "error removing %s: " % directory

def touch(name, mode=0777, recursive=False):
  if typecheck.is_list(name):
    name = join(*name)
  if not typecheck.is_string(name):
    raise TypeError()
  if not typecheck.is_int(mode):
    raise TypeError()
  if not typecheck.is_bool(recursive):
    raise TypeError()
  if recursive:
    mkpath(dirname(name), mode=mode)
  open(name, "w").close()
  return name

def mkpath(name, mode=0777, verbose=0, dry_run=False):
  """Creates a file/directory and any missing ancestor directories. If the
  directory already exists (or if `name` is the empty string, which means the
Esempio n. 16
0
 def set_copts(self, copts):
   if not typecheck.is_list(copts):
     raise TypeError()
   self._copts = copts
Esempio n. 17
0
 def set_includes(self, includes):
   if not typecheck.is_list(includes):
     raise TypeError()
   self._includes = includes
Esempio n. 18
0
 def check_options(self, options):
   if not typecheck.is_list(options):
     raise TypeError()
   for option in options:
     if not typecheck.is_string(option):
       raise TypeError()
Esempio n. 19
0
 def add_dependencies(self, deps):
   if not typecheck.is_list(deps) and not typecheck.is_tuple(deps):
     raise TypeError("%s: deps has to be a list or tuple, got %s" %
                     (self, type(deps)))
   for dep in deps:
     self.add_dependency(dep)
Esempio n. 20
0
 def __init__(self, nodes=[]):
   if not typecheck.is_list(nodes):
     raise TypeError("nodes must be list")
   networkx.MultiDiGraph.__init__(self)
   if len(nodes):
     self.add_nodes(nodes)