def add_task(task, deps, d): task_graph = data.getVar('_task_graph', d) if not task_graph: task_graph = bb.digraph() data.setVarFlag(task, 'task', 1, d) task_graph.addnode(task, None) for dep in deps: if not task_graph.hasnode(dep): task_graph.addnode(dep, None) task_graph.addnode(task, dep) # don't assume holding a reference data.setVar('_task_graph', task_graph, d) task_deps = data.getVar('_task_deps', d) if not task_deps: task_deps = {} def getTask(name): deptask = data.getVarFlag(task, name, d) if deptask: if not name in task_deps: task_deps[name] = {} task_deps[name][task] = deptask getTask('deptask') getTask('rdeptask') getTask('recrdeptask') getTask('nostamp') data.setVar('_task_deps', task_deps, d)
def add_task(task, deps, d): task_graph = data.getVar('_task_graph', d) if not task_graph: task_graph = bb.digraph() data.setVar('_task_graph', task_graph, d) data.setVarFlag(task, 'task', 1, d) task_graph.addnode(task, None) for dep in deps: if not task_graph.hasnode(dep): task_graph.addnode(dep, None) task_graph.addnode(task, dep)
def add_tasks(tasklist, d): task_deps = data.getVar('_task_deps', d) if not task_deps: task_deps = {} if not 'tasks' in task_deps: task_deps['tasks'] = [] if not 'parents' in task_deps: task_deps['parents'] = {} for task in tasklist: task = data.expand(task, d) data.setVarFlag(task, 'task', 1, d) if not task in task_deps['tasks']: task_deps['tasks'].append(task) flags = data.getVarFlags(task, d) def getTask(name): if not name in task_deps: task_deps[name] = {} if name in flags: deptask = data.expand(flags[name], d) task_deps[name][task] = deptask getTask('depends') getTask('rdepends') getTask('deptask') getTask('rdeptask') getTask('recrdeptask') getTask('nostamp') getTask('fakeroot') getTask('noexec') getTask('umask') task_deps['parents'][task] = [] for dep in flags['deps']: dep = data.expand(dep, d) task_deps['parents'][task].append(dep) # don't assume holding a reference data.setVar('_task_deps', task_deps, d)
def add_tasks(tasklist, d): task_graph = data.getVar('_task_graph', d) task_deps = data.getVar('_task_deps', d) if not task_graph: task_graph = bb.digraph() if not task_deps: task_deps = {} for task in tasklist: deps = tasklist[task] task = data.expand(task, d) data.setVarFlag(task, 'task', 1, d) task_graph.addnode(task, None) for dep in deps: dep = data.expand(dep, d) if not task_graph.hasnode(dep): task_graph.addnode(dep, None) task_graph.addnode(task, dep) flags = data.getVarFlags(task, d) def getTask(name): if name in flags: deptask = data.expand(flags[name], d) if not name in task_deps: task_deps[name] = {} task_deps[name][task] = deptask getTask('depends') getTask('deptask') getTask('rdeptask') getTask('recrdeptask') getTask('nostamp') # don't assume holding a reference data.setVar('_task_graph', task_graph, d) data.setVar('_task_deps', task_deps, d)
def testVarFlag(self): # import the data modules from bb import data from bb import data_smart d = data_smart.DataSmart() data.setVarFlag('TEST', 'testflag', 1, d) self.assertEquals(data.getVarFlag('TEST', 'testflag', d), 1) data.delVarFlag('TEST', 'testflag', d) self.assertEquals(data.getVarFlag('TEST', 'testflag', d), None) # test that changing a variable is working as well data.setVarFlag('TEST', 'testflag', 1, d) self.assertEquals(data.getVarFlag('TEST', 'testflag', d), 1) data.setVarFlag('TEST', 'testflag', 2, d) self.assertEquals(data.getVarFlag('TEST', 'testflag', d), 2)
def handle(fn, d, include = 0): global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __infunc__, __body__, __bbpath_found__, __residue__ __body__ = [] __bbpath_found__ = 0 __infunc__ = "" __classname__ = "" __residue__ = [] if include == 0: debug(2, "BB " + fn + ": handle(data)") else: debug(2, "BB " + fn + ": handle(data, include)") (root, ext) = os.path.splitext(os.path.basename(fn)) init(d) if ext == ".bbclass": __classname__ = root classes.append(__classname__) if include != 0: oldfile = data.getVar('FILE', d) else: oldfile = None fn = obtain(fn, d) bbpath = (data.getVar('BBPATH', d, 1) or '').split(':') if not os.path.isabs(fn): f = None for p in bbpath: p = data.expand(p, d) j = os.path.join(p, fn) if os.access(j, os.R_OK): abs_fn = j f = open(j, 'r') break if f is None: raise IOError("file not found") else: f = open(fn,'r') abs_fn = fn if ext != ".bbclass": bbpath.insert(0, os.path.dirname(abs_fn)) data.setVar('BBPATH', ":".join(bbpath), d) if include: bb.parse.mark_dependency(d, abs_fn) if ext != ".bbclass": data.setVar('FILE', fn, d) i = (data.getVar("INHERIT", d, 1) or "").split() if not "base" in i and __classname__ != "base": i[0:0] = ["base"] inherit(i, d) lineno = 0 while 1: lineno = lineno + 1 s = f.readline() if not s: break s = s.rstrip() feeder(lineno, s, fn, d) if __inpython__: # add a blank line to close out any python definition feeder(lineno + 1, "", fn, d) if ext == ".bbclass": classes.remove(__classname__) else: if include == 0: data.expandKeys(d) data.update_data(d) anonqueue = data.getVar("__anonqueue", d, 1) or [] for anon in anonqueue: data.setVar("__anonfunc", anon["content"], d) data.setVarFlags("__anonfunc", anon["flags"], d) from bb import build try: t = data.getVar('T', d) data.setVar('T', '${TMPDIR}/', d) build.exec_func("__anonfunc", d) data.delVar('T', d) if t: data.setVar('T', t, d) except Exception, e: bb.debug(1, "executing anonymous function: %s" % e) raise data.delVar("__anonqueue", d) data.delVar("__anonfunc", d) set_additional_vars(fn, d, include) data.update_data(d) for var in data.keys(d): if data.getVarFlag(var, 'handler', d): bb.event.register(data.getVar(var, d)) continue if not data.getVarFlag(var, 'task', d): continue deps = data.getVarFlag(var, 'deps', d) or [] postdeps = data.getVarFlag(var, 'postdeps', d) or [] bb.build.add_task(var, deps, d) for p in postdeps: pdeps = data.getVarFlag(p, 'deps', d) or [] pdeps.append(var) data.setVarFlag(p, 'deps', pdeps, d) bb.build.add_task(p, pdeps, d) bbpath.pop(0)
def feeder(lineno, s, fn, d): global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__,__infunc__, __body__, __bbpath_found__, classes, bb, __residue__ if __infunc__: if s == '}': __body__.append('') data.setVar(__infunc__, '\n'.join(__body__), d) data.setVarFlag(__infunc__, "func", 1, d) if __infunc__ == "__anonymous": anonqueue = bb.data.getVar("__anonqueue", d) or [] anonitem = {} anonitem["content"] = bb.data.getVar("__anonymous", d) anonitem["flags"] = bb.data.getVarFlags("__anonymous", d) anonqueue.append(anonitem) bb.data.setVar("__anonqueue", anonqueue, d) bb.data.delVarFlags("__anonymous", d) bb.data.delVar("__anonymous", d) __infunc__ = "" __body__ = [] else: __body__.append(s) return if __inpython__: m = __python_func_regexp__.match(s) if m: __body__.append(s) return else: text = '\n'.join(__body__) comp = compile(text, "<bb>", "exec") exec comp in __builtins__ __body__ = [] __inpython__ = False funcs = data.getVar('__functions__', d) or "" data.setVar('__functions__', "%s\n%s" % (funcs, text), d) # fall through if s == '' or s[0] == '#': return # skip comments and empty lines if s[-1] == '\\': __residue__.append(s[:-1]) return s = "".join(__residue__) + s __residue__ = [] m = __func_start_regexp__.match(s) if m: __infunc__ = m.group("func") or "__anonymous" key = __infunc__ if data.getVar(key, d): # clean up old version of this piece of metadata, as its # flags could cause problems data.setVarFlag(key, 'python', None, d) data.setVarFlag(key, 'fakeroot', None, d) if m.group("py") is not None: data.setVarFlag(key, "python", "1", d) else: data.delVarFlag(key, "python", d) if m.group("fr") is not None: data.setVarFlag(key, "fakeroot", "1", d) else: data.delVarFlag(key, "fakeroot", d) return m = __def_regexp__.match(s) if m: __body__.append(s) __inpython__ = True return m = __export_func_regexp__.match(s) if m: fns = m.group(1) n = __word__.findall(fns) for f in n: allvars = [] allvars.append(f) allvars.append(classes[-1] + "_" + f) vars = [[ allvars[0], allvars[1] ]] if len(classes) > 1 and classes[-2] is not None: allvars.append(classes[-2] + "_" + f) vars = [] vars.append([allvars[2], allvars[1]]) vars.append([allvars[0], allvars[2]]) for (var, calledvar) in vars: if data.getVar(var, d) and not data.getVarFlag(var, 'export_func', d): continue if data.getVar(var, d): data.setVarFlag(var, 'python', None, d) data.setVarFlag(var, 'func', None, d) for flag in [ "func", "python" ]: if data.getVarFlag(calledvar, flag, d): data.setVarFlag(var, flag, data.getVarFlag(calledvar, flag, d), d) for flag in [ "dirs" ]: if data.getVarFlag(var, flag, d): data.setVarFlag(calledvar, flag, data.getVarFlag(var, flag, d), d) if data.getVarFlag(calledvar, "python", d): data.setVar(var, "\tbb.build.exec_func('" + calledvar + "', d)\n", d) else: data.setVar(var, "\t" + calledvar + "\n", d) data.setVarFlag(var, 'export_func', '1', d) return m = __addtask_regexp__.match(s) if m: func = m.group("func") before = m.group("before") after = m.group("after") if func is None: return var = "do_" + func data.setVarFlag(var, "task", 1, d) if after is not None: # set up deps for function data.setVarFlag(var, "deps", after.split(), d) if before is not None: # set up things that depend on this func data.setVarFlag(var, "postdeps", before.split(), d) return m = __addhandler_regexp__.match(s) if m: fns = m.group(1) hs = __word__.findall(fns) for h in hs: data.setVarFlag(h, "handler", 1, d) return m = __inherit_regexp__.match(s) if m: files = m.group(1) n = __word__.findall(files) inherit(n, d) return from bb.parse import ConfHandler return ConfHandler.feeder(lineno, s, fn, d)
def feeder(lineno, s, fn, root, d): global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__, __infunc__, __body__, classes, bb, __residue__ if __infunc__: if s == '}': __body__.append('') data.setVar(__infunc__, '\n'.join(__body__), d) data.setVarFlag(__infunc__, "func", 1, d) if __infunc__ == "__anonymous": anonqueue = bb.data.getVar("__anonqueue", d) or [] anonitem = {} anonitem["content"] = bb.data.getVar("__anonymous", d) anonitem["flags"] = bb.data.getVarFlags("__anonymous", d) anonqueue.append(anonitem) bb.data.setVar("__anonqueue", anonqueue, d) bb.data.delVarFlags("__anonymous", d) bb.data.delVar("__anonymous", d) __infunc__ = "" __body__ = [] else: __body__.append(s) return if __inpython__: m = __python_func_regexp__.match(s) if m and lineno != IN_PYTHON_EOF: __body__.append(s) return else: # Note we will add root to parsedmethods after having parse # 'this' file. This means we will not parse methods from # bb classes twice if not root in __parsed_methods__: text = '\n'.join(__body__) methodpool.insert_method(root, text, fn) funcs = data.getVar('__functions__', d) or {} if not funcs.has_key(root): funcs[root] = text else: funcs[root] = "%s\n%s" % (funcs[root], text) data.setVar('__functions__', funcs, d) __body__ = [] __inpython__ = False if lineno == IN_PYTHON_EOF: return # fall through if s == '' or s[0] == '#': return # skip comments and empty lines if s[-1] == '\\': __residue__.append(s[:-1]) return s = "".join(__residue__) + s __residue__ = [] m = __func_start_regexp__.match(s) if m: __infunc__ = m.group("func") or "__anonymous" key = __infunc__ if data.getVar(key, d): # clean up old version of this piece of metadata, as its # flags could cause problems data.setVarFlag(key, 'python', None, d) data.setVarFlag(key, 'fakeroot', None, d) if m.group("py") is not None: data.setVarFlag(key, "python", "1", d) else: data.delVarFlag(key, "python", d) if m.group("fr") is not None: data.setVarFlag(key, "fakeroot", "1", d) else: data.delVarFlag(key, "fakeroot", d) return m = __def_regexp__.match(s) if m: __body__.append(s) __inpython__ = True return m = __export_func_regexp__.match(s) if m: fns = m.group(1) n = __word__.findall(fns) for f in n: allvars = [] allvars.append(f) allvars.append(classes[-1] + "_" + f) vars = [[allvars[0], allvars[1]]] if len(classes) > 1 and classes[-2] is not None: allvars.append(classes[-2] + "_" + f) vars = [] vars.append([allvars[2], allvars[1]]) vars.append([allvars[0], allvars[2]]) for (var, calledvar) in vars: if data.getVar( var, d) and not data.getVarFlag(var, 'export_func', d): continue if data.getVar(var, d): data.setVarFlag(var, 'python', None, d) data.setVarFlag(var, 'func', None, d) for flag in ["func", "python"]: if data.getVarFlag(calledvar, flag, d): data.setVarFlag(var, flag, data.getVarFlag(calledvar, flag, d), d) for flag in ["dirs"]: if data.getVarFlag(var, flag, d): data.setVarFlag(calledvar, flag, data.getVarFlag(var, flag, d), d) if data.getVarFlag(calledvar, "python", d): data.setVar( var, "\tbb.build.exec_func('" + calledvar + "', d)\n", d) else: data.setVar(var, "\t" + calledvar + "\n", d) data.setVarFlag(var, 'export_func', '1', d) return m = __addtask_regexp__.match(s) if m: func = m.group("func") before = m.group("before") after = m.group("after") if func is None: return var = "do_" + func data.setVarFlag(var, "task", 1, d) bbtasks = data.getVar('__BBTASKS', d) or [] if not var in bbtasks: bbtasks.append(var) data.setVar('__BBTASKS', bbtasks, d) existing = data.getVarFlag(var, "deps", d) or [] if after is not None: # set up deps for function for entry in after.split(): if entry not in existing: existing.append(entry) data.setVarFlag(var, "deps", existing, d) if before is not None: # set up things that depend on this func for entry in before.split(): existing = data.getVarFlag(entry, "deps", d) or [] if var not in existing: data.setVarFlag(entry, "deps", [var] + existing, d) return m = __addhandler_regexp__.match(s) if m: fns = m.group(1) hs = __word__.findall(fns) bbhands = data.getVar('__BBHANDLERS', d) or [] for h in hs: bbhands.append(h) data.setVarFlag(h, "handler", 1, d) data.setVar('__BBHANDLERS', bbhands, d) return m = __inherit_regexp__.match(s) if m: files = m.group(1) n = __word__.findall(files) inherit(n, d) return from bb.parse import ConfHandler return ConfHandler.feeder(lineno, s, fn, d)
def handle(fn, d, include = 0): global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __infunc__, __body__, __residue__ __body__ = [] __infunc__ = "" __classname__ = "" __residue__ = [] if include == 0: bb.msg.debug(2, bb.msg.domain.Parsing, "BB " + fn + ": handle(data)") else: bb.msg.debug(2, bb.msg.domain.Parsing, "BB " + fn + ": handle(data, include)") (root, ext) = os.path.splitext(os.path.basename(fn)) base_name = "%s%s" % (root,ext) init(d) if ext == ".bbclass": __classname__ = root classes.append(__classname__) if include != 0: oldfile = data.getVar('FILE', d) else: oldfile = None fn = obtain(fn, d) bbpath = (data.getVar('BBPATH', d, 1) or '').split(':') if not os.path.isabs(fn): f = None for p in bbpath: j = os.path.join(p, fn) if os.access(j, os.R_OK): abs_fn = j f = open(j, 'r') break if f is None: raise IOError("file not found") else: f = open(fn,'r') abs_fn = fn if ext != ".bbclass": bbpath.insert(0, os.path.dirname(abs_fn)) data.setVar('BBPATH', ":".join(bbpath), d) if include: bb.parse.mark_dependency(d, abs_fn) if ext != ".bbclass": data.setVar('FILE', fn, d) i = (data.getVar("INHERIT", d, 1) or "").split() if not "base" in i and __classname__ != "base": i[0:0] = ["base"] inherit(i, d) lineno = 0 while 1: lineno = lineno + 1 s = f.readline() if not s: break s = s.rstrip() feeder(lineno, s, fn, base_name, d) if __inpython__: # add a blank line to close out any python definition feeder(IN_PYTHON_EOF, "", fn, base_name, d) if ext == ".bbclass": classes.remove(__classname__) else: if include == 0: data.expandKeys(d) data.update_data(d) anonqueue = data.getVar("__anonqueue", d, 1) or [] body = [x['content'] for x in anonqueue] flag = { 'python' : 1, 'func' : 1 } data.setVar("__anonfunc", "\n".join(body), d) data.setVarFlags("__anonfunc", flag, d) from bb import build try: t = data.getVar('T', d) data.setVar('T', '${TMPDIR}/', d) build.exec_func("__anonfunc", d) data.delVar('T', d) if t: data.setVar('T', t, d) except Exception, e: bb.msg.debug(1, bb.msg.domain.Parsing, "executing anonymous function: %s" % e) raise data.delVar("__anonqueue", d) data.delVar("__anonfunc", d) set_additional_vars(fn, d, include) data.update_data(d) all_handlers = {} for var in data.getVar('__BBHANDLERS', d) or []: # try to add the handler # if we added it remember the choiche handler = data.getVar(var,d) if bb.event.register(var,handler) == bb.event.Registered: all_handlers[var] = handler for var in data.getVar('__BBTASKS', d) or []: deps = data.getVarFlag(var, 'deps', d) or [] postdeps = data.getVarFlag(var, 'postdeps', d) or [] bb.build.add_task(var, deps, d) for p in postdeps: pdeps = data.getVarFlag(p, 'deps', d) or [] pdeps.append(var) data.setVarFlag(p, 'deps', pdeps, d) bb.build.add_task(p, pdeps, d) # now add the handlers if not len(all_handlers) == 0: data.setVar('__all_handlers__', all_handlers, d) bbpath.pop(0)
def feeder(lineno, s, fn, root, d): global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__,__infunc__, __body__, classes, bb, __residue__ if __infunc__: if s == '}': __body__.append('') data.setVar(__infunc__, '\n'.join(__body__), d) data.setVarFlag(__infunc__, "func", 1, d) if __infunc__ == "__anonymous": anonqueue = bb.data.getVar("__anonqueue", d) or [] anonitem = {} anonitem["content"] = bb.data.getVar("__anonymous", d) anonitem["flags"] = bb.data.getVarFlags("__anonymous", d) anonqueue.append(anonitem) bb.data.setVar("__anonqueue", anonqueue, d) bb.data.delVarFlags("__anonymous", d) bb.data.delVar("__anonymous", d) __infunc__ = "" __body__ = [] else: __body__.append(s) return if __inpython__: m = __python_func_regexp__.match(s) if m and lineno != IN_PYTHON_EOF: __body__.append(s) return else: # Note we will add root to parsedmethods after having parse # 'this' file. This means we will not parse methods from # bb classes twice if not root in __parsed_methods__: text = '\n'.join(__body__) methodpool.insert_method( root, text, fn ) funcs = data.getVar('__functions__', d) or {} if not funcs.has_key( root ): funcs[root] = text else: funcs[root] = "%s\n%s" % (funcs[root], text) data.setVar('__functions__', funcs, d) __body__ = [] __inpython__ = False if lineno == IN_PYTHON_EOF: return # fall through if s == '' or s[0] == '#': return # skip comments and empty lines if s[-1] == '\\': __residue__.append(s[:-1]) return s = "".join(__residue__) + s __residue__ = [] m = __func_start_regexp__.match(s) if m: __infunc__ = m.group("func") or "__anonymous" key = __infunc__ if data.getVar(key, d): # clean up old version of this piece of metadata, as its # flags could cause problems data.setVarFlag(key, 'python', None, d) data.setVarFlag(key, 'fakeroot', None, d) if m.group("py") is not None: data.setVarFlag(key, "python", "1", d) else: data.delVarFlag(key, "python", d) if m.group("fr") is not None: data.setVarFlag(key, "fakeroot", "1", d) else: data.delVarFlag(key, "fakeroot", d) return m = __def_regexp__.match(s) if m: __body__.append(s) __inpython__ = True return m = __export_func_regexp__.match(s) if m: fns = m.group(1) n = __word__.findall(fns) for f in n: allvars = [] allvars.append(f) allvars.append(classes[-1] + "_" + f) vars = [[ allvars[0], allvars[1] ]] if len(classes) > 1 and classes[-2] is not None: allvars.append(classes[-2] + "_" + f) vars = [] vars.append([allvars[2], allvars[1]]) vars.append([allvars[0], allvars[2]]) for (var, calledvar) in vars: if data.getVar(var, d) and not data.getVarFlag(var, 'export_func', d): continue if data.getVar(var, d): data.setVarFlag(var, 'python', None, d) data.setVarFlag(var, 'func', None, d) for flag in [ "func", "python" ]: if data.getVarFlag(calledvar, flag, d): data.setVarFlag(var, flag, data.getVarFlag(calledvar, flag, d), d) for flag in [ "dirs" ]: if data.getVarFlag(var, flag, d): data.setVarFlag(calledvar, flag, data.getVarFlag(var, flag, d), d) if data.getVarFlag(calledvar, "python", d): data.setVar(var, "\tbb.build.exec_func('" + calledvar + "', d)\n", d) else: data.setVar(var, "\t" + calledvar + "\n", d) data.setVarFlag(var, 'export_func', '1', d) return m = __addtask_regexp__.match(s) if m: func = m.group("func") before = m.group("before") after = m.group("after") if func is None: return var = "do_" + func data.setVarFlag(var, "task", 1, d) bbtasks = data.getVar('__BBTASKS', d) or [] bbtasks.append(var) data.setVar('__BBTASKS', bbtasks, d) if after is not None: # set up deps for function data.setVarFlag(var, "deps", after.split(), d) if before is not None: # set up things that depend on this func data.setVarFlag(var, "postdeps", before.split(), d) return m = __addhandler_regexp__.match(s) if m: fns = m.group(1) hs = __word__.findall(fns) bbhands = data.getVar('__BBHANDLERS', d) or [] for h in hs: bbhands.append(h) data.setVarFlag(h, "handler", 1, d) data.setVar('__BBHANDLERS', bbhands, d) return m = __inherit_regexp__.match(s) if m: files = m.group(1) n = __word__.findall(files) inherit(n, d) return from bb.parse import ConfHandler return ConfHandler.feeder(lineno, s, fn, d)
def add_tasks(tasklist, d): task_deps = data.getVar('_task_deps', d) if not task_deps: task_deps = {} if not 'tasks' in task_deps: task_deps['tasks'] = [] if not 'parents' in task_deps: task_deps['parents'] = {} for task in tasklist: task = data.expand(task, d) data.setVarFlag(task, 'task', 1, d) if not task in task_deps['tasks']: task_deps['tasks'].append(task) flags = data.getVarFlags(task, d) def getTask(name): if not name in task_deps: task_deps[name] = {} if name in flags: deptask = data.expand(flags[name], d) task_deps[name][task] = deptask getTask('depends') getTask('deptask') getTask('rdeptask') getTask('recrdeptask') getTask('nostamp') task_deps['parents'][task] = [] for dep in flags['deps']: dep = data.expand(dep, d) task_deps['parents'][task].append(dep) # don't assume holding a reference data.setVar('_task_deps', task_deps, d)
def add_tasks(tasklist, d): task_deps = data.getVar("_task_deps", d) if not task_deps: task_deps = {} if not "tasks" in task_deps: task_deps["tasks"] = [] if not "parents" in task_deps: task_deps["parents"] = {} for task in tasklist: task = data.expand(task, d) data.setVarFlag(task, "task", 1, d) if not task in task_deps["tasks"]: task_deps["tasks"].append(task) flags = data.getVarFlags(task, d) def getTask(name): if not name in task_deps: task_deps[name] = {} if name in flags: deptask = data.expand(flags[name], d) task_deps[name][task] = deptask getTask("depends") getTask("deptask") getTask("rdeptask") getTask("recrdeptask") getTask("nostamp") getTask("fakeroot") getTask("noexec") getTask("umask") task_deps["parents"][task] = [] for dep in flags["deps"]: dep = data.expand(dep, d) task_deps["parents"][task].append(dep) # don't assume holding a reference data.setVar("_task_deps", task_deps, d)