From 9fe314b8b86d3e8be442140a338663f926bd3769 Mon Sep 17 00:00:00 2001 From: Holger Freyther Date: Mon, 18 May 2009 19:24:07 +0200 Subject: [parser] Cary a Statement Node through the parsing When parsing we will collect a number of statements that can be evaluated...The plan is to be evaluate things twice (old+new) and then compare the result, it should be the same. --- lib/bb/parse/ast.py | 114 ++++++++++++++++++++++++++++------------------------ 1 file changed, 61 insertions(+), 53 deletions(-) (limited to 'lib/bb/parse/ast.py') diff --git a/lib/bb/parse/ast.py b/lib/bb/parse/ast.py index 032b4961b..8e7ba7fde 100644 --- a/lib/bb/parse/ast.py +++ b/lib/bb/parse/ast.py @@ -21,23 +21,33 @@ # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -import bb, re +import bb, re, string __word__ = re.compile(r"\S+") -__parsed_methods__ = methodpool.get_parsed_dict() +__parsed_methods__ = bb.methodpool.get_parsed_dict() -def handleInclude(m, fn, lineno, data, force): +class StatementGroup: + def __init__(self): + self.statements = [] + + def eval(self, data): + """ + Apply each statement on the data... in order + """ + map(lambda x: x.eval(data), self.statements) + +def handleInclude(statements, m, fn, lineno, data, force): s = bb.data.expand(m.group(1), data) bb.msg.debug(3, bb.msg.domain.Parsing, "CONF %s:%d: including %s" % (fn, lineno, s)) if force: - include(fn, s, data, "include required") + bb.parse.ConfHandler.include(statements, fn, s, data, "include required") else: - include(fn, s, data, False) + bb.parse.ConfHandler.include(statements, fn, s, data, False) -def handleExport(m, data): +def handleExport(statements, m, data): bb.data.setVarFlag(m.group(1), "export", 1, data) -def handleData(groupd, data): +def handleData(statements, groupd, data): key = groupd["var"] if "exp" in groupd and groupd["exp"] != None: bb.data.setVarFlag(key, "export", 1, data) @@ -71,45 +81,43 @@ def getFunc(groupd, key, data): else: return bb.data.getVar(key, data) -def handleMethod(func_name, lineno, fn, body, d): +def handleMethod(statements, func_name, lineno, fn, body, d): if func_name == "__anonymous": funcname = ("__anon_%s_%s" % (lineno, fn.translate(string.maketrans('/.+-', '____')))) - if not funcname in methodpool._parsed_fns: + if not funcname in bb.methodpool._parsed_fns: text = "def %s(d):\n" % (funcname) + '\n'.join(body) - methodpool.insert_method(funcname, text, fn) - anonfuncs = data.getVar('__BBANONFUNCS', d) or [] + bb.methodpool.insert_method(funcname, text, fn) + anonfuncs = bb.data.getVar('__BBANONFUNCS', d) or [] anonfuncs.append(funcname) - data.setVar('__BBANONFUNCS', anonfuncs, d) + bb.data.setVar('__BBANONFUNCS', anonfuncs, d) else: - data.setVarFlag(func_name, "func", 1, d) - data.setVar(func_name, '\n'.join(body), d) - - + bb.data.setVarFlag(func_name, "func", 1, d) + bb.data.setVar(func_name, '\n'.join(body), d) -def handlePythonMethod(root, body, fn): +def handlePythonMethod(statements, root, body, fn): # 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) + bb.methodpool.insert_method(root, text, fn) -def handleMethodFlags(key, m, d): - if data.getVar(key, d): +def handleMethodFlags(statements, key, m, d): + if bb.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) + bb.data.setVarFlag(key, 'python', None, d) + bb.data.setVarFlag(key, 'fakeroot', None, d) if m.group("py") is not None: - data.setVarFlag(key, "python", "1", d) + bb.data.setVarFlag(key, "python", "1", d) else: - data.delVarFlag(key, "python", d) + bb.data.delVarFlag(key, "python", d) if m.group("fr") is not None: - data.setVarFlag(key, "fakeroot", "1", d) + bb.data.setVarFlag(key, "fakeroot", "1", d) else: - data.delVarFlag(key, "fakeroot", d) + bb.data.delVarFlag(key, "fakeroot", d) -def handleExportFuncs(m, d): +def handleExportFuncs(statements, m, classes, d): fns = m.group(1) n = __word__.findall(fns) for f in n: @@ -125,27 +133,27 @@ def handleExportFuncs(m, d): vars.append([allvars[0], allvars[2]]) for (var, calledvar) in vars: - if data.getVar(var, d) and not data.getVarFlag(var, 'export_func', d): + if bb.data.getVar(var, d) and not bb.data.getVarFlag(var, 'export_func', d): continue - if data.getVar(var, d): - data.setVarFlag(var, 'python', None, d) - data.setVarFlag(var, 'func', None, d) + if bb.data.getVar(var, d): + bb.data.setVarFlag(var, 'python', None, d) + bb.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) + if bb.data.getVarFlag(calledvar, flag, d): + bb.data.setVarFlag(var, flag, bb.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 bb.data.getVarFlag(var, flag, d): + bb.data.setVarFlag(calledvar, flag, bb.data.getVarFlag(var, flag, d), d) - if data.getVarFlag(calledvar, "python", d): - data.setVar(var, "\tbb.build.exec_func('" + calledvar + "', d)\n", d) + if bb.data.getVarFlag(calledvar, "python", d): + bb.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) + bb.data.setVar(var, "\t" + calledvar + "\n", d) + bb.data.setVarFlag(var, 'export_func', '1', d) -def handleAddTask(m, d): +def handleAddTask(statements, m, d): func = m.group("func") before = m.group("before") after = m.group("after") @@ -154,38 +162,38 @@ def handleAddTask(m, d): if func[:3] != "do_": var = "do_" + func - data.setVarFlag(var, "task", 1, d) + bb.data.setVarFlag(var, "task", 1, d) - bbtasks = data.getVar('__BBTASKS', d) or [] + bbtasks = bb.data.getVar('__BBTASKS', d) or [] if not var in bbtasks: bbtasks.append(var) - data.setVar('__BBTASKS', bbtasks, d) + bb.data.setVar('__BBTASKS', bbtasks, d) - existing = data.getVarFlag(var, "deps", d) or [] + existing = bb.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) + bb.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 [] + existing = bb.data.getVarFlag(entry, "deps", d) or [] if var not in existing: - data.setVarFlag(entry, "deps", [var] + existing, d) + bb.data.setVarFlag(entry, "deps", [var] + existing, d) -def handleBBHandlers(m, d): +def handleBBHandlers(statements, m, d): fns = m.group(1) hs = __word__.findall(fns) - bbhands = data.getVar('__BBHANDLERS', d) or [] + bbhands = bb.data.getVar('__BBHANDLERS', d) or [] for h in hs: bbhands.append(h) - data.setVarFlag(h, "handler", 1, d) - data.setVar('__BBHANDLERS', bbhands, d) + bb.data.setVarFlag(h, "handler", 1, d) + bb.data.setVar('__BBHANDLERS', bbhands, d) -def handleInherit(m, d): +def handleInherit(statements, m, d): files = m.group(1) n = __word__.findall(files) - inherit(n, d) + bb.parse.BBHandler.inherit(statements, n, d) -- cgit 1.2.3-korg