--- /dev/null
+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2005-2008 (ita)
+
+"""
+The class task_gen encapsulates the creation of task objects (low-level code)
+The instances can have various parameters, but the creation of task nodes (Task.py)
+is delayed. To achieve this, various methods are called from the method "apply"
+
+The class task_gen contains lots of methods, and a configuration table:
+* the methods to call (self.meths) can be specified dynamically (removing, adding, ..)
+* the order of the methods (self.prec or by default task_gen.prec) is configurable
+* new methods can be inserted dynamically without pasting old code
+
+Additionally, task_gen provides the method apply_core
+* file extensions are mapped to methods: def meth(self, name_or_node)
+* if a mapping is not found in self.mappings, it is searched in task_gen.mappings
+* when called, the functions may modify self.allnodes to re-add source to process
+* the mappings can map an extension or a filename (see the code below)
+
+WARNING: subclasses must reimplement the clone method
+"""
+
+import os, traceback, copy
+import Build, Task, Utils, Logs, Options
+from Logs import debug, error, warn
+from Constants import *
+
+typos = {
+'sources':'source',
+'targets':'target',
+'include':'includes',
+'define':'defines',
+'importpath':'importpaths',
+'install_var':'install_path',
+'install_subdir':'install_path',
+'inst_var':'install_path',
+'inst_dir':'install_path',
+'feature':'features',
+}
+
+class register_obj(type):
+ """no decorators for classes, so we use a metaclass
+ we store into task_gen.classes the classes that inherit task_gen
+ and whose names end in '_taskgen'
+ """
+ def __init__(cls, name, bases, dict):
+ super(register_obj, cls).__init__(name, bases, dict)
+ name = cls.__name__
+ suffix = '_taskgen'
+ if name.endswith(suffix):
+ task_gen.classes[name.replace(suffix, '')] = cls
+
+class task_gen(object):
+ """
+ Most methods are of the form 'def meth(self):' without any parameters
+ there are many of them, and they do many different things:
+ * task creation
+ * task results installation
+ * environment modification
+ * attribute addition/removal
+
+ The inheritance approach is complicated
+ * mixing several languages at once
+ * subclassing is needed even for small changes
+ * inserting new methods is complicated
+
+ This new class uses a configuration table:
+ * adding new methods easily
+ * obtaining the order in which to call the methods
+ * postponing the method calls (post() -> apply)
+
+ Additionally, a 'traits' static attribute is provided:
+ * this list contains methods
+ * the methods can remove or add methods from self.meths
+ Example1: the attribute 'staticlib' is set on an instance
+ a method set in the list of traits is executed when the
+ instance is posted, it finds that flag and adds another method for execution
+ Example2: a method set in the list of traits finds the msvc
+ compiler (from self.env['MSVC']==1); more methods are added to self.meths
+ """
+
+ __metaclass__ = register_obj
+ mappings = {}
+ mapped = {}
+ prec = Utils.DefaultDict(list)
+ traits = Utils.DefaultDict(set)
+ classes = {}
+
+ def __init__(self, *kw, **kwargs):
+ self.prec = Utils.DefaultDict(list)
+ "map precedence of function names to call"
+ # so we will have to play with directed acyclic graphs
+ # detect cycles, etc
+
+ self.source = ''
+ self.target = ''
+
+ # list of methods to execute - does not touch it by hand unless you know
+ self.meths = []
+
+ # list of mappings extension -> function
+ self.mappings = {}
+
+ # list of features (see the documentation on traits)
+ self.features = list(kw)
+
+ # not always a good idea
+ self.tasks = []
+
+ self.default_chmod = O644
+ self.default_install_path = None
+
+ # kind of private, beware of what you put in it, also, the contents are consumed
+ self.allnodes = []
+
+ self.bld = kwargs.get('bld', Build.bld)
+ self.env = self.bld.env.copy()
+
+ self.path = self.bld.path # emulate chdir when reading scripts
+ self.name = '' # give a name to the target (static+shlib with the same targetname ambiguity)
+
+ # provide a unique id
+ self.idx = self.bld.idx[self.path.id] = self.bld.idx.get(self.path.id, 0) + 1
+
+ for key, val in kwargs.iteritems():
+ setattr(self, key, val)
+
+ self.bld.task_manager.add_task_gen(self)
+ self.bld.all_task_gen.append(self)
+
+ def __str__(self):
+ return ("<task_gen '%s' of type %s defined in %s>"
+ % (self.name or self.target, self.__class__.__name__, str(self.path)))
+
+ def __setattr__(self, name, attr):
+ real = typos.get(name, name)
+ if real != name:
+ warn('typo %s -> %s' % (name, real))
+ if Logs.verbose > 0:
+ traceback.print_stack()
+ object.__setattr__(self, real, attr)
+
+ def to_list(self, value):
+ "helper: returns a list"
+ if isinstance(value, str): return value.split()
+ else: return value
+
+ def apply(self):
+ "order the methods to execute using self.prec or task_gen.prec"
+ keys = set(self.meths)
+
+ # add the methods listed in the features
+ self.features = Utils.to_list(self.features)
+ for x in self.features + ['*']:
+ st = task_gen.traits[x]
+ if not st:
+ warn('feature %r does not exist - bind at least one method to it' % x)
+ keys.update(st)
+
+ # copy the precedence table
+ prec = {}
+ prec_tbl = self.prec or task_gen.prec
+ for x in prec_tbl:
+ if x in keys:
+ prec[x] = prec_tbl[x]
+
+ # elements disconnected
+ tmp = []
+ for a in keys:
+ for x in prec.values():
+ if a in x: break
+ else:
+ tmp.append(a)
+
+ # topological sort
+ out = []
+ while tmp:
+ e = tmp.pop()
+ if e in keys: out.append(e)
+ try:
+ nlst = prec[e]
+ except KeyError:
+ pass
+ else:
+ del prec[e]
+ for x in nlst:
+ for y in prec:
+ if x in prec[y]:
+ break
+ else:
+ tmp.append(x)
+
+ if prec: raise Utils.WafError("graph has a cycle %s" % str(prec))
+ out.reverse()
+ self.meths = out
+
+ # then we run the methods in order
+ debug('task_gen: posting %s %d', self, id(self))
+ for x in out:
+ try:
+ v = getattr(self, x)
+ except AttributeError:
+ raise Utils.WafError("tried to retrieve %s which is not a valid method" % x)
+ debug('task_gen: -> %s (%d)', x, id(self))
+ v()
+
+ def post(self):
+ "runs the code to create the tasks, do not subclass"
+ if not self.name:
+ if isinstance(self.target, list):
+ self.name = ' '.join(self.target)
+ else:
+ self.name = self.target
+
+ if getattr(self, 'posted', None):
+ #error("OBJECT ALREADY POSTED" + str( self))
+ return
+
+ self.apply()
+ self.posted = True
+ debug('task_gen: posted %s', self.name)
+
+ def get_hook(self, ext):
+ try: return self.mappings[ext]
+ except KeyError:
+ try: return task_gen.mappings[ext]
+ except KeyError: return None
+
+ # TODO waf 1.6: always set the environment
+ # TODO waf 1.6: create_task(self, name, inputs, outputs)
+ def create_task(self, name, src=None, tgt=None, env=None):
+ env = env or self.env
+ task = Task.TaskBase.classes[name](env.copy(), generator=self)
+ if src:
+ task.set_inputs(src)
+ if tgt:
+ task.set_outputs(tgt)
+ self.tasks.append(task)
+ return task
+
+ def name_to_obj(self, name):
+ return self.bld.name_to_obj(name, self.env)
+
+ def find_sources_in_dirs(self, dirnames, excludes=[], exts=[]):
+ """
+ The attributes "excludes" and "exts" must be lists to avoid the confusion
+ find_sources_in_dirs('a', 'b', 'c') <-> find_sources_in_dirs('a b c')
+
+ do not use absolute paths
+ do not use paths outside of the source tree
+ the files or folder beginning by . are not returned
+
+ # TODO: remove in Waf 1.6
+ """
+
+ err_msg = "'%s' attribute must be a list"
+ if not isinstance(excludes, list):
+ raise Utils.WscriptError(err_msg % 'excludes')
+ if not isinstance(exts, list):
+ raise Utils.WscriptError(err_msg % 'exts')
+
+ lst = []
+
+ #make sure dirnames is a list helps with dirnames with spaces
+ dirnames = self.to_list(dirnames)
+
+ ext_lst = exts or list(self.mappings.keys()) + list(task_gen.mappings.keys())
+
+ for name in dirnames:
+ anode = self.path.find_dir(name)
+
+ if not anode or not anode.is_child_of(self.bld.srcnode):
+ raise Utils.WscriptError("Unable to use '%s' - either because it's not a relative path" \
+ ", or it's not child of '%s'." % (name, self.bld.srcnode))
+
+ self.bld.rescan(anode)
+ for name in self.bld.cache_dir_contents[anode.id]:
+
+ # ignore hidden files
+ if name.startswith('.'):
+ continue
+
+ (base, ext) = os.path.splitext(name)
+ if ext in ext_lst and not name in lst and not name in excludes:
+ lst.append((anode.relpath_gen(self.path) or '.') + os.path.sep + name)
+
+ lst.sort()
+ self.source = self.to_list(self.source)
+ if not self.source: self.source = lst
+ else: self.source += lst
+
+ def clone(self, env):
+ """when creating a clone in a task generator method,
+ make sure to set posted=False on the clone
+ else the other task generator will not create its tasks"""
+ newobj = task_gen(bld=self.bld)
+ for x in self.__dict__:
+ if x in ['env', 'bld']:
+ continue
+ elif x in ["path", "features"]:
+ setattr(newobj, x, getattr(self, x))
+ else:
+ setattr(newobj, x, copy.copy(getattr(self, x)))
+
+ newobj.__class__ = self.__class__
+ if isinstance(env, str):
+ newobj.env = self.bld.all_envs[env].copy()
+ else:
+ newobj.env = env.copy()
+
+ return newobj
+
+ def get_inst_path(self):
+ return getattr(self, '_install_path', getattr(self, 'default_install_path', ''))
+
+ def set_inst_path(self, val):
+ self._install_path = val
+
+ install_path = property(get_inst_path, set_inst_path)
+
+
+ def get_chmod(self):
+ return getattr(self, '_chmod', getattr(self, 'default_chmod', O644))
+
+ def set_chmod(self, val):
+ self._chmod = val
+
+ chmod = property(get_chmod, set_chmod)
+
+def declare_extension(var, func):
+ try:
+ for x in Utils.to_list(var):
+ task_gen.mappings[x] = func
+ except:
+ raise Utils.WscriptError('declare_extension takes either a list or a string %r' % var)
+ task_gen.mapped[func.__name__] = func
+
+def declare_order(*k):
+ assert(len(k) > 1)
+ n = len(k) - 1
+ for i in xrange(n):
+ f1 = k[i]
+ f2 = k[i+1]
+ if not f1 in task_gen.prec[f2]:
+ task_gen.prec[f2].append(f1)
+
+def declare_chain(name='', action='', ext_in='', ext_out='', reentrant=True, color='BLUE',
+ install=0, before=[], after=[], decider=None, rule=None, scan=None):
+ """
+ see Tools/flex.py for an example
+ while i do not like such wrappers, some people really do
+ """
+
+ action = action or rule
+ if isinstance(action, str):
+ act = Task.simple_task_type(name, action, color=color)
+ else:
+ act = Task.task_type_from_func(name, action, color=color)
+ act.ext_in = tuple(Utils.to_list(ext_in))
+ act.ext_out = tuple(Utils.to_list(ext_out))
+ act.before = Utils.to_list(before)
+ act.after = Utils.to_list(after)
+ act.scan = scan
+
+ def x_file(self, node):
+ if decider:
+ ext = decider(self, node)
+ else:
+ ext = ext_out
+
+ if isinstance(ext, str):
+ out_source = node.change_ext(ext)
+ if reentrant:
+ self.allnodes.append(out_source)
+ elif isinstance(ext, list):
+ out_source = [node.change_ext(x) for x in ext]
+ if reentrant:
+ for i in xrange((reentrant is True) and len(out_source) or reentrant):
+ self.allnodes.append(out_source[i])
+ else:
+ # XXX: useless: it will fail on Utils.to_list above...
+ raise Utils.WafError("do not know how to process %s" % str(ext))
+
+ tsk = self.create_task(name, node, out_source)
+
+ if node.__class__.bld.is_install:
+ tsk.install = install
+
+ declare_extension(act.ext_in, x_file)
+ return x_file
+
+def bind_feature(name, methods):
+ lst = Utils.to_list(methods)
+ task_gen.traits[name].update(lst)
+
+"""
+All the following decorators are registration decorators, i.e add an attribute to current class
+ (task_gen and its derivatives), with same name as func, which points to func itself.
+For example:
+ @taskgen
+ def sayHi(self):
+ print("hi")
+Now taskgen.sayHi() may be called
+
+If python were really smart, it could infer itself the order of methods by looking at the
+attributes. A prerequisite for execution is to have the attribute set before.
+Intelligent compilers binding aspect-oriented programming and parallelization, what a nice topic for studies.
+"""
+def taskgen(func):
+ """
+ register a method as a task generator method
+ """
+ setattr(task_gen, func.__name__, func)
+ return func
+
+def feature(*k):
+ """
+ declare a task generator method that will be executed when the
+ object attribute 'feature' contains the corresponding key(s)
+ """
+ def deco(func):
+ setattr(task_gen, func.__name__, func)
+ for name in k:
+ task_gen.traits[name].update([func.__name__])
+ return func
+ return deco
+
+def before(*k):
+ """
+ declare a task generator method which will be executed
+ before the functions of given name(s)
+ """
+ def deco(func):
+ setattr(task_gen, func.__name__, func)
+ for fun_name in k:
+ if not func.__name__ in task_gen.prec[fun_name]:
+ task_gen.prec[fun_name].append(func.__name__)
+ return func
+ return deco
+
+def after(*k):
+ """
+ declare a task generator method which will be executed
+ after the functions of given name(s)
+ """
+ def deco(func):
+ setattr(task_gen, func.__name__, func)
+ for fun_name in k:
+ if not fun_name in task_gen.prec[func.__name__]:
+ task_gen.prec[func.__name__].append(fun_name)
+ return func
+ return deco
+
+def extension(var):
+ """
+ declare a task generator method which will be invoked during
+ the processing of source files for the extension given
+ """
+ def deco(func):
+ setattr(task_gen, func.__name__, func)
+ try:
+ for x in Utils.to_list(var):
+ task_gen.mappings[x] = func
+ except:
+ raise Utils.WafError('extension takes either a list or a string %r' % var)
+ task_gen.mapped[func.__name__] = func
+ return func
+ return deco
+
+# TODO make certain the decorators may be used here
+
+def apply_core(self):
+ """Process the attribute source
+ transform the names into file nodes
+ try to process the files by name first, later by extension"""
+ # get the list of folders to use by the scanners
+ # all our objects share the same include paths anyway
+ find_resource = self.path.find_resource
+
+ for filename in self.to_list(self.source):
+ # if self.mappings or task_gen.mappings contains a file of the same name
+ x = self.get_hook(filename)
+ if x:
+ x(self, filename)
+ else:
+ node = find_resource(filename)
+ if not node: raise Utils.WafError("source not found: '%s' in '%s'" % (filename, str(self.path)))
+ self.allnodes.append(node)
+
+ for node in self.allnodes:
+ # self.mappings or task_gen.mappings map the file extension to a function
+ x = self.get_hook(node.suffix())
+
+ if not x:
+ raise Utils.WafError("Cannot guess how to process %s (got mappings %r in %r) -> try conf.check_tool(..)?" % \
+ (str(node), self.__class__.mappings.keys(), self.__class__))
+ x(self, node)
+feature('*')(apply_core)
+
+def exec_rule(self):
+ """Process the attribute rule, when provided the method apply_core will be disabled
+ """
+ if not getattr(self, 'rule', None):
+ return
+
+ # someone may have removed it already
+ try:
+ self.meths.remove('apply_core')
+ except ValueError:
+ pass
+
+ # get the function and the variables
+ func = self.rule
+
+ vars2 = []
+ if isinstance(func, str):
+ # use the shell by default for user-defined commands
+ (func, vars2) = Task.compile_fun('', self.rule, shell=getattr(self, 'shell', True))
+ func.code = self.rule
+
+ # create the task class
+ name = getattr(self, 'name', None) or self.target or self.rule
+ if not isinstance(name, str):
+ name = str(self.idx)
+ cls = Task.task_type_from_func(name, func, getattr(self, 'vars', vars2))
+ cls.color = getattr(self, 'color', 'BLUE')
+
+ # now create one instance
+ tsk = self.create_task(name)
+
+ dep_vars = getattr(self, 'dep_vars', ['ruledeps'])
+ if dep_vars:
+ tsk.dep_vars = dep_vars
+ if isinstance(self.rule, str):
+ tsk.env.ruledeps = self.rule
+ else:
+ # only works if the function is in a global module such as a waf tool
+ tsk.env.ruledeps = Utils.h_fun(self.rule)
+
+ # we assume that the user knows that without inputs or outputs
+ #if not getattr(self, 'target', None) and not getattr(self, 'source', None):
+ # cls.quiet = True
+
+ if getattr(self, 'target', None):
+ cls.quiet = True
+ tsk.outputs = [self.path.find_or_declare(x) for x in self.to_list(self.target)]
+
+ if getattr(self, 'source', None):
+ cls.quiet = True
+ tsk.inputs = []
+ for x in self.to_list(self.source):
+ y = self.path.find_resource(x)
+ if not y:
+ raise Utils.WafError('input file %r could not be found (%r)' % (x, self.path.abspath()))
+ tsk.inputs.append(y)
+
+ if self.allnodes:
+ tsk.inputs.extend(self.allnodes)
+
+ if getattr(self, 'scan', None):
+ cls.scan = self.scan
+
+ if getattr(self, 'install_path', None):
+ tsk.install_path = self.install_path
+
+ if getattr(self, 'cwd', None):
+ tsk.cwd = self.cwd
+
+ if getattr(self, 'on_results', None):
+ Task.update_outputs(cls)
+
+ if getattr(self, 'always', None):
+ Task.always_run(cls)
+
+ for x in ['after', 'before', 'ext_in', 'ext_out']:
+ setattr(cls, x, getattr(self, x, []))
+feature('*')(exec_rule)
+before('apply_core')(exec_rule)
+
+def sequence_order(self):
+ """
+ add a strict sequential constraint between the tasks generated by task generators
+ it uses the fact that task generators are posted in order
+ it will not post objects which belong to other folders
+ there is also an awesome trick for executing the method in last position
+
+ to use:
+ bld(features='javac seq')
+ bld(features='jar seq')
+
+ to start a new sequence, set the attribute seq_start, for example:
+ obj.seq_start = True
+ """
+ if self.meths and self.meths[-1] != 'sequence_order':
+ self.meths.append('sequence_order')
+ return
+
+ if getattr(self, 'seq_start', None):
+ return
+
+ # all the tasks previously declared must be run before these
+ if getattr(self.bld, 'prev', None):
+ self.bld.prev.post()
+ for x in self.bld.prev.tasks:
+ for y in self.tasks:
+ y.set_run_after(x)
+
+ self.bld.prev = self
+
+feature('seq')(sequence_order)
+
git.samba.org / abartlet / samba-debian.git / blobdiff