mirrors/poky
1
0
Fork 0
mirror of https://git.yoctoproject.org/poky synced 2026-06-03 01:40:07 +00:00
Code Issues Projects Releases Wiki Activity

bitbake: [parser] Cary a Statement Node through the parsing

Browse Source 
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.

Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
This commit is contained in:
Holger Freyther
2009-05-18 19:24:07 +02:00
committed by Richard Purdie
parent 5bac3403d7
commit 4b25b519ae
4 changed files with 92 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bitbake/lib/bb/parse/ast.py
+61 -53
View File
@@ -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)