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
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
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)
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
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)
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)
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)
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)
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)
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)
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)
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
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))
def register_threads(self, threads): if not typecheck.is_list(threads): raise TypeError("Must be list") for thread in threads: self.register_thread(thread)
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
def set_copts(self, copts): if not typecheck.is_list(copts): raise TypeError() self._copts = copts
def set_includes(self, includes): if not typecheck.is_list(includes): raise TypeError() self._includes = includes
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()
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)
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)