diff options
Diffstat (limited to 'bitbake/lib/bb/data_smart.py')
| -rw-r--r-- | bitbake/lib/bb/data_smart.py | 158 |
1 files changed, 105 insertions, 53 deletions
diff --git a/bitbake/lib/bb/data_smart.py b/bitbake/lib/bb/data_smart.py index 9067d54bf..01a333024 100644 --- a/bitbake/lib/bb/data_smart.py +++ b/bitbake/lib/bb/data_smart.py @@ -28,22 +28,16 @@ BitBake build tools. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # Based on functions from the base bb module, Copyright 2003 Holger Schurig -import copy, os, re, sys, time, types +import copy, re, sys import bb -from bb import utils, methodpool -from COW import COWDictBase -from new import classobj +from bb import utils +from bb.COW import COWDictBase -__setvar_keyword__ = ["_append","_prepend"] +__setvar_keyword__ = ["_append", "_prepend"] __setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend)(_(?P<add>.*))?') __expand_var_regexp__ = re.compile(r"\${[^{}]+}") __expand_python_regexp__ = re.compile(r"\${@.+?}") -_expand_globals = { - "os": os, - "bb": bb, - "time": time, -} class DataSmart: @@ -55,9 +49,8 @@ class DataSmart: self._seen_overrides = seen self.expand_cache = {} - self.expand_locals = {"d": self} - def expand(self,s, varname): + def expand(self, s, varname): def var_sub(match): key = match.group()[2:-1] if varname and key: @@ -70,13 +63,12 @@ class DataSmart: return match.group() def python_sub(match): - import bb code = match.group()[3:-1] - s = eval(code, _expand_globals, self.expand_locals) - if type(s) == types.IntType: s = str(s) - return s + codeobj = compile(code.strip(), varname or "<expansion>", "eval") + value = utils.better_eval(codeobj, {"d": self}) + return str(value) - if type(s) is not types.StringType: # sanity check + if not isinstance(s, basestring): # sanity check return s if varname and varname in self.expand_cache: @@ -87,9 +79,8 @@ class DataSmart: try: s = __expand_var_regexp__.sub(var_sub, s) s = __expand_python_regexp__.sub(python_sub, s) - if s == olds: break - if type(s) is not types.StringType: # sanity check - bb.msg.error(bb.msg.domain.Data, 'expansion of %s returned non-string %s' % (olds, s)) + if s == olds: + break except KeyboardInterrupt: raise except: @@ -101,23 +92,86 @@ class DataSmart: return s + def finalize(self): + """Performs final steps upon the datastore, including application of overrides""" + + overrides = (self.getVar("OVERRIDES", True) or "").split(":") or [] + + # + # Well let us see what breaks here. We used to iterate + # over each variable and apply the override and then + # do the line expanding. + # If we have bad luck - which we will have - the keys + # where in some order that is so important for this + # method which we don't have anymore. + # Anyway we will fix that and write test cases this + # time. + + # + # First we apply all overrides + # Then we will handle _append and _prepend + # + + for o in overrides: + # calculate '_'+override + l = len(o) + 1 + + # see if one should even try + if o not in self._seen_overrides: + continue + + vars = self._seen_overrides[o] + for var in vars: + name = var[:-l] + try: + self[name] = self[var] + except Exception: + bb.msg.note(1, bb.msg.domain.Data, "Untracked delVar") + + # now on to the appends and prepends + if "_append" in self._special_values: + appends = self._special_values["_append"] or [] + for append in appends: + for (a, o) in self.getVarFlag(append, "_append") or []: + # maybe the OVERRIDE was not yet added so keep the append + if (o and o in overrides) or not o: + self.delVarFlag(append, "_append") + if o and not o in overrides: + continue + + sval = self.getVar(append, False) or "" + sval += a + self.setVar(append, sval) + + + if "_prepend" in self._special_values: + prepends = self._special_values["_prepend"] or [] + + for prepend in prepends: + for (a, o) in self.getVarFlag(prepend, "_prepend") or []: + # maybe the OVERRIDE was not yet added so keep the prepend + if (o and o in overrides) or not o: + self.delVarFlag(prepend, "_prepend") + if o and not o in overrides: + continue + + sval = a + (self.getVar(prepend, False) or "") + self.setVar(prepend, sval) + def initVar(self, var): self.expand_cache = {} if not var in self.dict: self.dict[var] = {} - def _findVar(self,var): - _dest = self.dict + def _findVar(self, var): + dest = self.dict + while dest: + if var in dest: + return dest[var] - while (_dest and var not in _dest): - if not "_data" in _dest: - _dest = None + if "_data" not in dest: break - _dest = _dest["_data"] - - if _dest and var in _dest: - return _dest[var] - return None + dest = dest["_data"] def _makeShadowCopy(self, var): if var in self.dict: @@ -130,7 +184,7 @@ class DataSmart: else: self.initVar(var) - def setVar(self,var,value): + def setVar(self, var, value): self.expand_cache = {} match = __setvar_regexp__.match(var) if match and match.group("keyword") in __setvar_keyword__: @@ -145,7 +199,7 @@ class DataSmart: # pay the cookie monster try: self._special_values[keyword].add( base ) - except: + except KeyError: self._special_values[keyword] = set() self._special_values[keyword].add( base ) @@ -157,23 +211,23 @@ class DataSmart: # more cookies for the cookie monster if '_' in var: override = var[var.rfind('_')+1:] - if not self._seen_overrides.has_key(override): + if override not in self._seen_overrides: self._seen_overrides[override] = set() self._seen_overrides[override].add( var ) # setting var self.dict[var]["content"] = value - def getVar(self,var,exp): - value = self.getVarFlag(var,"content") + def getVar(self, var, exp): + value = self.getVarFlag(var, "content") if exp and value: - return self.expand(value,var) + return self.expand(value, var) return value def renameVar(self, key, newkey): """ - Rename the variable key to newkey + Rename the variable key to newkey """ val = self.getVar(key, 0) if val is not None: @@ -187,30 +241,30 @@ class DataSmart: dest = self.getVarFlag(newkey, i) or [] dest.extend(src) self.setVarFlag(newkey, i, dest) - - if self._special_values.has_key(i) and key in self._special_values[i]: + + if i in self._special_values and key in self._special_values[i]: self._special_values[i].remove(key) self._special_values[i].add(newkey) self.delVar(key) - def delVar(self,var): + def delVar(self, var): self.expand_cache = {} self.dict[var] = {} - def setVarFlag(self,var,flag,flagvalue): + def setVarFlag(self, var, flag, flagvalue): if not var in self.dict: self._makeShadowCopy(var) self.dict[var][flag] = flagvalue - def getVarFlag(self,var,flag): + def getVarFlag(self, var, flag): local_var = self._findVar(var) if local_var: if flag in local_var: return copy.copy(local_var[flag]) return None - def delVarFlag(self,var,flag): + def delVarFlag(self, var, flag): local_var = self._findVar(var) if not local_var: return @@ -220,7 +274,7 @@ class DataSmart: if var in self.dict and flag in self.dict[var]: del self.dict[var][flag] - def setVarFlags(self,var,flags): + def setVarFlags(self, var, flags): if not var in self.dict: self._makeShadowCopy(var) @@ -229,7 +283,7 @@ class DataSmart: continue self.dict[var][i] = flags[i] - def getVarFlags(self,var): + def getVarFlags(self, var): local_var = self._findVar(var) flags = {} @@ -244,7 +298,7 @@ class DataSmart: return flags - def delVarFlags(self,var): + def delVarFlags(self, var): if not var in self.dict: self._makeShadowCopy(var) @@ -274,21 +328,19 @@ class DataSmart: def keys(self): def _keys(d, mykey): if "_data" in d: - _keys(d["_data"],mykey) + _keys(d["_data"], mykey) for key in d.keys(): if key != "_data": mykey[key] = None keytab = {} - _keys(self.dict,keytab) + _keys(self.dict, keytab) return keytab.keys() - def __getitem__(self,item): + def __getitem__(self, item): #print "Warning deprecated" return self.getVar(item, False) - def __setitem__(self,var,data): + def __setitem__(self, var, data): #print "Warning deprecated" - self.setVar(var,data) - - + self.setVar(var, data) |