diff options
Diffstat (limited to 'bitbake/lib/bb/parse/ast.py')
-rw-r--r-- | bitbake/lib/bb/parse/ast.py | 482 |
1 files changed, 482 insertions, 0 deletions
diff --git a/bitbake/lib/bb/parse/ast.py b/bitbake/lib/bb/parse/ast.py new file mode 100644 index 0000000000..d4b8b09543 --- /dev/null +++ b/bitbake/lib/bb/parse/ast.py | |||
@@ -0,0 +1,482 @@ | |||
1 | # ex:ts=4:sw=4:sts=4:et | ||
2 | # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- | ||
3 | """ | ||
4 | AbstractSyntaxTree classes for the Bitbake language | ||
5 | """ | ||
6 | |||
7 | # Copyright (C) 2003, 2004 Chris Larson | ||
8 | # Copyright (C) 2003, 2004 Phil Blundell | ||
9 | # Copyright (C) 2009 Holger Hans Peter Freyther | ||
10 | # | ||
11 | # This program is free software; you can redistribute it and/or modify | ||
12 | # it under the terms of the GNU General Public License version 2 as | ||
13 | # published by the Free Software Foundation. | ||
14 | # | ||
15 | # This program is distributed in the hope that it will be useful, | ||
16 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | # GNU General Public License for more details. | ||
19 | # | ||
20 | # You should have received a copy of the GNU General Public License along | ||
21 | # with this program; if not, write to the Free Software Foundation, Inc., | ||
22 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
23 | |||
24 | from __future__ import absolute_import | ||
25 | from future_builtins import filter | ||
26 | import re | ||
27 | import string | ||
28 | import logging | ||
29 | import bb | ||
30 | import itertools | ||
31 | from bb import methodpool | ||
32 | from bb.parse import logger | ||
33 | |||
34 | _bbversions_re = re.compile(r"\[(?P<from>[0-9]+)-(?P<to>[0-9]+)\]") | ||
35 | |||
36 | class StatementGroup(list): | ||
37 | def eval(self, data): | ||
38 | for statement in self: | ||
39 | statement.eval(data) | ||
40 | |||
41 | class AstNode(object): | ||
42 | def __init__(self, filename, lineno): | ||
43 | self.filename = filename | ||
44 | self.lineno = lineno | ||
45 | |||
46 | class IncludeNode(AstNode): | ||
47 | def __init__(self, filename, lineno, what_file, force): | ||
48 | AstNode.__init__(self, filename, lineno) | ||
49 | self.what_file = what_file | ||
50 | self.force = force | ||
51 | |||
52 | def eval(self, data): | ||
53 | """ | ||
54 | Include the file and evaluate the statements | ||
55 | """ | ||
56 | s = data.expand(self.what_file) | ||
57 | logger.debug(2, "CONF %s:%s: including %s", self.filename, self.lineno, s) | ||
58 | |||
59 | # TODO: Cache those includes... maybe not here though | ||
60 | if self.force: | ||
61 | bb.parse.ConfHandler.include(self.filename, s, self.lineno, data, "include required") | ||
62 | else: | ||
63 | bb.parse.ConfHandler.include(self.filename, s, self.lineno, data, False) | ||
64 | |||
65 | class ExportNode(AstNode): | ||
66 | def __init__(self, filename, lineno, var): | ||
67 | AstNode.__init__(self, filename, lineno) | ||
68 | self.var = var | ||
69 | |||
70 | def eval(self, data): | ||
71 | data.setVarFlag(self.var, "export", 1, op = 'exported') | ||
72 | |||
73 | class DataNode(AstNode): | ||
74 | """ | ||
75 | Various data related updates. For the sake of sanity | ||
76 | we have one class doing all this. This means that all | ||
77 | this need to be re-evaluated... we might be able to do | ||
78 | that faster with multiple classes. | ||
79 | """ | ||
80 | def __init__(self, filename, lineno, groupd): | ||
81 | AstNode.__init__(self, filename, lineno) | ||
82 | self.groupd = groupd | ||
83 | |||
84 | def getFunc(self, key, data): | ||
85 | if 'flag' in self.groupd and self.groupd['flag'] != None: | ||
86 | return data.getVarFlag(key, self.groupd['flag'], noweakdefault=True) | ||
87 | else: | ||
88 | return data.getVar(key, noweakdefault=True) | ||
89 | |||
90 | def eval(self, data): | ||
91 | groupd = self.groupd | ||
92 | key = groupd["var"] | ||
93 | loginfo = { | ||
94 | 'variable': key, | ||
95 | 'file': self.filename, | ||
96 | 'line': self.lineno, | ||
97 | } | ||
98 | if "exp" in groupd and groupd["exp"] != None: | ||
99 | data.setVarFlag(key, "export", 1, op = 'exported', **loginfo) | ||
100 | |||
101 | op = "set" | ||
102 | if "ques" in groupd and groupd["ques"] != None: | ||
103 | val = self.getFunc(key, data) | ||
104 | op = "set?" | ||
105 | if val == None: | ||
106 | val = groupd["value"] | ||
107 | elif "colon" in groupd and groupd["colon"] != None: | ||
108 | e = data.createCopy() | ||
109 | bb.data.update_data(e) | ||
110 | op = "immediate" | ||
111 | val = e.expand(groupd["value"], key + "[:=]") | ||
112 | elif "append" in groupd and groupd["append"] != None: | ||
113 | op = "append" | ||
114 | val = "%s %s" % ((self.getFunc(key, data) or ""), groupd["value"]) | ||
115 | elif "prepend" in groupd and groupd["prepend"] != None: | ||
116 | op = "prepend" | ||
117 | val = "%s %s" % (groupd["value"], (self.getFunc(key, data) or "")) | ||
118 | elif "postdot" in groupd and groupd["postdot"] != None: | ||
119 | op = "postdot" | ||
120 | val = "%s%s" % ((self.getFunc(key, data) or ""), groupd["value"]) | ||
121 | elif "predot" in groupd and groupd["predot"] != None: | ||
122 | op = "predot" | ||
123 | val = "%s%s" % (groupd["value"], (self.getFunc(key, data) or "")) | ||
124 | else: | ||
125 | val = groupd["value"] | ||
126 | |||
127 | flag = None | ||
128 | if 'flag' in groupd and groupd['flag'] != None: | ||
129 | flag = groupd['flag'] | ||
130 | elif groupd["lazyques"]: | ||
131 | flag = "defaultval" | ||
132 | |||
133 | loginfo['op'] = op | ||
134 | loginfo['detail'] = groupd["value"] | ||
135 | |||
136 | if flag: | ||
137 | data.setVarFlag(key, flag, val, **loginfo) | ||
138 | else: | ||
139 | data.setVar(key, val, **loginfo) | ||
140 | |||
141 | class MethodNode(AstNode): | ||
142 | def __init__(self, filename, lineno, func_name, body): | ||
143 | AstNode.__init__(self, filename, lineno) | ||
144 | self.func_name = func_name | ||
145 | self.body = body | ||
146 | |||
147 | def eval(self, data): | ||
148 | text = '\n'.join(self.body) | ||
149 | if self.func_name == "__anonymous": | ||
150 | funcname = ("__anon_%s_%s" % (self.lineno, self.filename.translate(string.maketrans('/.+-@', '_____')))) | ||
151 | text = "def %s(d):\n" % (funcname) + text | ||
152 | bb.methodpool.insert_method(funcname, text, self.filename) | ||
153 | anonfuncs = data.getVar('__BBANONFUNCS') or [] | ||
154 | anonfuncs.append(funcname) | ||
155 | data.setVar('__BBANONFUNCS', anonfuncs) | ||
156 | data.setVar(funcname, text) | ||
157 | else: | ||
158 | data.setVarFlag(self.func_name, "func", 1) | ||
159 | data.setVar(self.func_name, text) | ||
160 | |||
161 | class PythonMethodNode(AstNode): | ||
162 | def __init__(self, filename, lineno, function, modulename, body): | ||
163 | AstNode.__init__(self, filename, lineno) | ||
164 | self.function = function | ||
165 | self.modulename = modulename | ||
166 | self.body = body | ||
167 | |||
168 | def eval(self, data): | ||
169 | # Note we will add root to parsedmethods after having parse | ||
170 | # 'this' file. This means we will not parse methods from | ||
171 | # bb classes twice | ||
172 | text = '\n'.join(self.body) | ||
173 | bb.methodpool.insert_method(self.modulename, text, self.filename) | ||
174 | data.setVarFlag(self.function, "func", 1) | ||
175 | data.setVarFlag(self.function, "python", 1) | ||
176 | data.setVar(self.function, text) | ||
177 | |||
178 | class MethodFlagsNode(AstNode): | ||
179 | def __init__(self, filename, lineno, key, m): | ||
180 | AstNode.__init__(self, filename, lineno) | ||
181 | self.key = key | ||
182 | self.m = m | ||
183 | |||
184 | def eval(self, data): | ||
185 | if data.getVar(self.key): | ||
186 | # clean up old version of this piece of metadata, as its | ||
187 | # flags could cause problems | ||
188 | data.setVarFlag(self.key, 'python', None) | ||
189 | data.setVarFlag(self.key, 'fakeroot', None) | ||
190 | if self.m.group("py") is not None: | ||
191 | data.setVarFlag(self.key, "python", "1") | ||
192 | else: | ||
193 | data.delVarFlag(self.key, "python") | ||
194 | if self.m.group("fr") is not None: | ||
195 | data.setVarFlag(self.key, "fakeroot", "1") | ||
196 | else: | ||
197 | data.delVarFlag(self.key, "fakeroot") | ||
198 | |||
199 | class ExportFuncsNode(AstNode): | ||
200 | def __init__(self, filename, lineno, fns, classname): | ||
201 | AstNode.__init__(self, filename, lineno) | ||
202 | self.n = fns.split() | ||
203 | self.classname = classname | ||
204 | |||
205 | def eval(self, data): | ||
206 | |||
207 | for func in self.n: | ||
208 | calledfunc = self.classname + "_" + func | ||
209 | |||
210 | if data.getVar(func) and not data.getVarFlag(func, 'export_func'): | ||
211 | continue | ||
212 | |||
213 | if data.getVar(func): | ||
214 | data.setVarFlag(func, 'python', None) | ||
215 | data.setVarFlag(func, 'func', None) | ||
216 | |||
217 | for flag in [ "func", "python" ]: | ||
218 | if data.getVarFlag(calledfunc, flag): | ||
219 | data.setVarFlag(func, flag, data.getVarFlag(calledfunc, flag)) | ||
220 | for flag in [ "dirs" ]: | ||
221 | if data.getVarFlag(func, flag): | ||
222 | data.setVarFlag(calledfunc, flag, data.getVarFlag(func, flag)) | ||
223 | |||
224 | if data.getVarFlag(calledfunc, "python"): | ||
225 | data.setVar(func, " bb.build.exec_func('" + calledfunc + "', d)\n") | ||
226 | else: | ||
227 | data.setVar(func, " " + calledfunc + "\n") | ||
228 | data.setVarFlag(func, 'export_func', '1') | ||
229 | |||
230 | class AddTaskNode(AstNode): | ||
231 | def __init__(self, filename, lineno, func, before, after): | ||
232 | AstNode.__init__(self, filename, lineno) | ||
233 | self.func = func | ||
234 | self.before = before | ||
235 | self.after = after | ||
236 | |||
237 | def eval(self, data): | ||
238 | var = self.func | ||
239 | if self.func[:3] != "do_": | ||
240 | var = "do_" + self.func | ||
241 | |||
242 | data.setVarFlag(var, "task", 1) | ||
243 | bbtasks = data.getVar('__BBTASKS') or [] | ||
244 | if not var in bbtasks: | ||
245 | bbtasks.append(var) | ||
246 | data.setVar('__BBTASKS', bbtasks) | ||
247 | |||
248 | existing = data.getVarFlag(var, "deps") or [] | ||
249 | if self.after is not None: | ||
250 | # set up deps for function | ||
251 | for entry in self.after.split(): | ||
252 | if entry not in existing: | ||
253 | existing.append(entry) | ||
254 | data.setVarFlag(var, "deps", existing) | ||
255 | if self.before is not None: | ||
256 | # set up things that depend on this func | ||
257 | for entry in self.before.split(): | ||
258 | existing = data.getVarFlag(entry, "deps") or [] | ||
259 | if var not in existing: | ||
260 | data.setVarFlag(entry, "deps", [var] + existing) | ||
261 | |||
262 | class BBHandlerNode(AstNode): | ||
263 | def __init__(self, filename, lineno, fns): | ||
264 | AstNode.__init__(self, filename, lineno) | ||
265 | self.hs = fns.split() | ||
266 | |||
267 | def eval(self, data): | ||
268 | bbhands = data.getVar('__BBHANDLERS') or [] | ||
269 | for h in self.hs: | ||
270 | bbhands.append(h) | ||
271 | data.setVarFlag(h, "handler", 1) | ||
272 | data.setVar('__BBHANDLERS', bbhands) | ||
273 | |||
274 | class InheritNode(AstNode): | ||
275 | def __init__(self, filename, lineno, classes): | ||
276 | AstNode.__init__(self, filename, lineno) | ||
277 | self.classes = classes | ||
278 | |||
279 | def eval(self, data): | ||
280 | bb.parse.BBHandler.inherit(self.classes, self.filename, self.lineno, data) | ||
281 | |||
282 | def handleInclude(statements, filename, lineno, m, force): | ||
283 | statements.append(IncludeNode(filename, lineno, m.group(1), force)) | ||
284 | |||
285 | def handleExport(statements, filename, lineno, m): | ||
286 | statements.append(ExportNode(filename, lineno, m.group(1))) | ||
287 | |||
288 | def handleData(statements, filename, lineno, groupd): | ||
289 | statements.append(DataNode(filename, lineno, groupd)) | ||
290 | |||
291 | def handleMethod(statements, filename, lineno, func_name, body): | ||
292 | statements.append(MethodNode(filename, lineno, func_name, body)) | ||
293 | |||
294 | def handlePythonMethod(statements, filename, lineno, funcname, modulename, body): | ||
295 | statements.append(PythonMethodNode(filename, lineno, funcname, modulename, body)) | ||
296 | |||
297 | def handleMethodFlags(statements, filename, lineno, key, m): | ||
298 | statements.append(MethodFlagsNode(filename, lineno, key, m)) | ||
299 | |||
300 | def handleExportFuncs(statements, filename, lineno, m, classname): | ||
301 | statements.append(ExportFuncsNode(filename, lineno, m.group(1), classname)) | ||
302 | |||
303 | def handleAddTask(statements, filename, lineno, m): | ||
304 | func = m.group("func") | ||
305 | before = m.group("before") | ||
306 | after = m.group("after") | ||
307 | if func is None: | ||
308 | return | ||
309 | |||
310 | statements.append(AddTaskNode(filename, lineno, func, before, after)) | ||
311 | |||
312 | def handleBBHandlers(statements, filename, lineno, m): | ||
313 | statements.append(BBHandlerNode(filename, lineno, m.group(1))) | ||
314 | |||
315 | def handleInherit(statements, filename, lineno, m): | ||
316 | classes = m.group(1) | ||
317 | statements.append(InheritNode(filename, lineno, classes)) | ||
318 | |||
319 | def finalize(fn, d, variant = None): | ||
320 | all_handlers = {} | ||
321 | for var in d.getVar('__BBHANDLERS') or []: | ||
322 | # try to add the handler | ||
323 | bb.event.register(var, d.getVar(var), (d.getVarFlag(var, "eventmask", True) or "").split()) | ||
324 | |||
325 | bb.event.fire(bb.event.RecipePreFinalise(fn), d) | ||
326 | |||
327 | bb.data.expandKeys(d) | ||
328 | bb.data.update_data(d) | ||
329 | code = [] | ||
330 | for funcname in d.getVar("__BBANONFUNCS") or []: | ||
331 | code.append("%s(d)" % funcname) | ||
332 | bb.utils.better_exec("\n".join(code), {"d": d}) | ||
333 | bb.data.update_data(d) | ||
334 | |||
335 | tasklist = d.getVar('__BBTASKS') or [] | ||
336 | bb.build.add_tasks(tasklist, d) | ||
337 | |||
338 | bb.parse.siggen.finalise(fn, d, variant) | ||
339 | |||
340 | d.setVar('BBINCLUDED', bb.parse.get_file_depends(d)) | ||
341 | |||
342 | bb.event.fire(bb.event.RecipeParsed(fn), d) | ||
343 | |||
344 | def _create_variants(datastores, names, function): | ||
345 | def create_variant(name, orig_d, arg = None): | ||
346 | new_d = bb.data.createCopy(orig_d) | ||
347 | function(arg or name, new_d) | ||
348 | datastores[name] = new_d | ||
349 | |||
350 | for variant, variant_d in datastores.items(): | ||
351 | for name in names: | ||
352 | if not variant: | ||
353 | # Based on main recipe | ||
354 | create_variant(name, variant_d) | ||
355 | else: | ||
356 | create_variant("%s-%s" % (variant, name), variant_d, name) | ||
357 | |||
358 | def _expand_versions(versions): | ||
359 | def expand_one(version, start, end): | ||
360 | for i in xrange(start, end + 1): | ||
361 | ver = _bbversions_re.sub(str(i), version, 1) | ||
362 | yield ver | ||
363 | |||
364 | versions = iter(versions) | ||
365 | while True: | ||
366 | try: | ||
367 | version = next(versions) | ||
368 | except StopIteration: | ||
369 | break | ||
370 | |||
371 | range_ver = _bbversions_re.search(version) | ||
372 | if not range_ver: | ||
373 | yield version | ||
374 | else: | ||
375 | newversions = expand_one(version, int(range_ver.group("from")), | ||
376 | int(range_ver.group("to"))) | ||
377 | versions = itertools.chain(newversions, versions) | ||
378 | |||
379 | def multi_finalize(fn, d): | ||
380 | appends = (d.getVar("__BBAPPEND", True) or "").split() | ||
381 | for append in appends: | ||
382 | logger.debug(2, "Appending .bbappend file %s to %s", append, fn) | ||
383 | bb.parse.BBHandler.handle(append, d, True) | ||
384 | |||
385 | onlyfinalise = d.getVar("__ONLYFINALISE", False) | ||
386 | |||
387 | safe_d = d | ||
388 | d = bb.data.createCopy(safe_d) | ||
389 | try: | ||
390 | finalize(fn, d) | ||
391 | except bb.parse.SkipPackage as e: | ||
392 | d.setVar("__SKIPPED", e.args[0]) | ||
393 | datastores = {"": safe_d} | ||
394 | |||
395 | versions = (d.getVar("BBVERSIONS", True) or "").split() | ||
396 | if versions: | ||
397 | pv = orig_pv = d.getVar("PV", True) | ||
398 | baseversions = {} | ||
399 | |||
400 | def verfunc(ver, d, pv_d = None): | ||
401 | if pv_d is None: | ||
402 | pv_d = d | ||
403 | |||
404 | overrides = d.getVar("OVERRIDES", True).split(":") | ||
405 | pv_d.setVar("PV", ver) | ||
406 | overrides.append(ver) | ||
407 | bpv = baseversions.get(ver) or orig_pv | ||
408 | pv_d.setVar("BPV", bpv) | ||
409 | overrides.append(bpv) | ||
410 | d.setVar("OVERRIDES", ":".join(overrides)) | ||
411 | |||
412 | versions = list(_expand_versions(versions)) | ||
413 | for pos, version in enumerate(list(versions)): | ||
414 | try: | ||
415 | pv, bpv = version.split(":", 2) | ||
416 | except ValueError: | ||
417 | pass | ||
418 | else: | ||
419 | versions[pos] = pv | ||
420 | baseversions[pv] = bpv | ||
421 | |||
422 | if pv in versions and not baseversions.get(pv): | ||
423 | versions.remove(pv) | ||
424 | else: | ||
425 | pv = versions.pop() | ||
426 | |||
427 | # This is necessary because our existing main datastore | ||
428 | # has already been finalized with the old PV, we need one | ||
429 | # that's been finalized with the new PV. | ||
430 | d = bb.data.createCopy(safe_d) | ||
431 | verfunc(pv, d, safe_d) | ||
432 | try: | ||
433 | finalize(fn, d) | ||
434 | except bb.parse.SkipPackage as e: | ||
435 | d.setVar("__SKIPPED", e.args[0]) | ||
436 | |||
437 | _create_variants(datastores, versions, verfunc) | ||
438 | |||
439 | extended = d.getVar("BBCLASSEXTEND", True) or "" | ||
440 | if extended: | ||
441 | # the following is to support bbextends with arguments, for e.g. multilib | ||
442 | # an example is as follows: | ||
443 | # BBCLASSEXTEND = "multilib:lib32" | ||
444 | # it will create foo-lib32, inheriting multilib.bbclass and set | ||
445 | # BBEXTENDCURR to "multilib" and BBEXTENDVARIANT to "lib32" | ||
446 | extendedmap = {} | ||
447 | variantmap = {} | ||
448 | |||
449 | for ext in extended.split(): | ||
450 | eext = ext.split(':', 2) | ||
451 | if len(eext) > 1: | ||
452 | extendedmap[ext] = eext[0] | ||
453 | variantmap[ext] = eext[1] | ||
454 | else: | ||
455 | extendedmap[ext] = ext | ||
456 | |||
457 | pn = d.getVar("PN", True) | ||
458 | def extendfunc(name, d): | ||
459 | if name != extendedmap[name]: | ||
460 | d.setVar("BBEXTENDCURR", extendedmap[name]) | ||
461 | d.setVar("BBEXTENDVARIANT", variantmap[name]) | ||
462 | else: | ||
463 | d.setVar("PN", "%s-%s" % (pn, name)) | ||
464 | bb.parse.BBHandler.inherit(extendedmap[name], fn, 0, d) | ||
465 | |||
466 | safe_d.setVar("BBCLASSEXTEND", extended) | ||
467 | _create_variants(datastores, extendedmap.keys(), extendfunc) | ||
468 | |||
469 | for variant, variant_d in datastores.iteritems(): | ||
470 | if variant: | ||
471 | try: | ||
472 | if not onlyfinalise or variant in onlyfinalise: | ||
473 | finalize(fn, variant_d, variant) | ||
474 | except bb.parse.SkipPackage as e: | ||
475 | variant_d.setVar("__SKIPPED", e.args[0]) | ||
476 | |||
477 | if len(datastores) > 1: | ||
478 | variants = filter(None, datastores.iterkeys()) | ||
479 | safe_d.setVar("__VARIANTS", " ".join(variants)) | ||
480 | |||
481 | datastores[""] = d | ||
482 | return datastores | ||