diff options
Diffstat (limited to 'bitbake/lib')
22 files changed, 2277 insertions, 1528 deletions
diff --git a/bitbake/lib/bb/__init__.py b/bitbake/lib/bb/__init__.py index c6c0beb792..c3e7a16658 100644 --- a/bitbake/lib/bb/__init__.py +++ b/bitbake/lib/bb/__init__.py @@ -23,7 +23,7 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. """ -__version__ = "1.3.3.4" +__version__ = "1.4.3" __all__ = [ @@ -60,7 +60,9 @@ __all__ = [ "event", "build", "fetch", - "manifest" + "manifest", + "methodpool", + "cache", ] whitespace = '\t\n\x0b\x0c\r ' diff --git a/bitbake/lib/bb/cache.py b/bitbake/lib/bb/cache.py new file mode 100644 index 0000000000..921a9f7589 --- /dev/null +++ b/bitbake/lib/bb/cache.py @@ -0,0 +1,306 @@ +#!/usr/bin/env python +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +""" +BitBake 'Event' implementation + +Caching of bitbake variables before task execution + +# Copyright (C) 2006 Richard Purdie + +# but small sections based on code from bin/bitbake: +# Copyright (C) 2003, 2004 Chris Larson +# Copyright (C) 2003, 2004 Phil Blundell +# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer +# Copyright (C) 2005 Holger Hans Peter Freyther +# Copyright (C) 2005 ROAD GmbH + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; either version 2 of the License, or (at your option) any later +version. + +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA. + +""" + +import os, re +import bb.data +import bb.utils + +try: + import cPickle as pickle +except ImportError: + import pickle + print "NOTE: Importing cPickle failed. Falling back to a very slow implementation." + +# __cache_version__ = "123" +__cache_version__ = "124" # changes the __depends structure + +class Cache: + """ + BitBake Cache implementation + """ + def __init__(self, cooker): + + + self.cachedir = bb.data.getVar("CACHE", cooker.configuration.data, True) + self.clean = {} + self.depends_cache = {} + self.data = None + self.data_fn = None + + if self.cachedir in [None, '']: + self.has_cache = False + if cooker.cb is not None: + print "NOTE: Not using a cache. Set CACHE = <directory> to enable." + else: + self.has_cache = True + self.cachefile = os.path.join(self.cachedir,"bb_cache.dat") + + if cooker.cb is not None: + print "NOTE: Using cache in '%s'" % self.cachedir + try: + os.stat( self.cachedir ) + except OSError: + bb.mkdirhier( self.cachedir ) + + if self.has_cache and (self.mtime(self.cachefile)): + try: + p = pickle.Unpickler( file(self.cachefile,"rb")) + self.depends_cache, version_data = p.load() + if version_data['CACHE_VER'] != __cache_version__: + raise ValueError, 'Cache Version Mismatch' + if version_data['BITBAKE_VER'] != bb.__version__: + raise ValueError, 'Bitbake Version Mismatch' + except (ValueError, KeyError): + bb.note("Invalid cache found, rebuilding...") + self.depends_cache = {} + + if self.depends_cache: + for fn in self.depends_cache.keys(): + self.clean[fn] = "" + self.cacheValidUpdate(fn) + + def getVar(self, var, fn, exp = 0): + """ + Gets the value of a variable + (similar to getVar in the data class) + + There are two scenarios: + 1. We have cached data - serve from depends_cache[fn] + 2. We're learning what data to cache - serve from data + backend but add a copy of the data to the cache. + """ + + if fn in self.clean: + return self.depends_cache[fn][var] + + if not fn in self.depends_cache: + self.depends_cache[fn] = {} + + if fn != self.data_fn: + # We're trying to access data in the cache which doesn't exist + # yet setData hasn't been called to setup the right access. Very bad. + bb.error("Parsing error data_fn %s and fn %s don't match" % (self.data_fn, fn)) + + result = bb.data.getVar(var, self.data, exp) + self.depends_cache[fn][var] = result + return result + + def setData(self, fn, data): + """ + Called to prime bb_cache ready to learn which variables to cache. + Will be followed by calls to self.getVar which aren't cached + but can be fulfilled from self.data. + """ + self.data_fn = fn + self.data = data + + # Make sure __depends makes the depends_cache + self.getVar("__depends", fn, True) + self.depends_cache[fn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn) + + def loadDataFull(self, fn, cooker): + """ + Return a complete set of data for fn. + To do this, we need to parse the file. + """ + bb_data, skipped = self.load_bbfile(fn, cooker) + return bb_data + + def loadData(self, fn, cooker): + """ + Load a subset of data for fn. + If the cached data is valid we do nothing, + To do this, we need to parse the file and set the system + to record the variables accessed. + Return the cache status and whether the file was skipped when parsed + """ + if self.cacheValid(fn): + if "SKIPPED" in self.depends_cache[fn]: + return True, True + return True, False + + bb_data, skipped = self.load_bbfile(fn, cooker) + self.setData(fn, bb_data) + return False, skipped + + def cacheValid(self, fn): + """ + Is the cache valid for fn? + Fast version, no timestamps checked. + """ + # Is cache enabled? + if not self.has_cache: + return False + if fn in self.clean: + return True + return False + + def cacheValidUpdate(self, fn): + """ + Is the cache valid for fn? + Make thorough (slower) checks including timestamps. + """ + # Is cache enabled? + if not self.has_cache: + return False + + # Check file still exists + if self.mtime(fn) == 0: + bb.debug(2, "Cache: %s not longer exists" % fn) + self.remove(fn) + return False + + # File isn't in depends_cache + if not fn in self.depends_cache: + bb.debug(2, "Cache: %s is not cached" % fn) + self.remove(fn) + return False + + # Check the file's timestamp + if bb.parse.cached_mtime(fn) > self.getVar("CACHETIMESTAMP", fn, True): + bb.debug(2, "Cache: %s changed" % fn) + self.remove(fn) + return False + + # Check dependencies are still valid + depends = self.getVar("__depends", fn, True) + for f,old_mtime in depends: + new_mtime = bb.parse.cached_mtime(f) + if (new_mtime > old_mtime): + bb.debug(2, "Cache: %s's dependency %s changed" % (fn, f)) + self.remove(fn) + return False + + bb.debug(2, "Depends Cache: %s is clean" % fn) + if not fn in self.clean: + self.clean[fn] = "" + + return True + + def skip(self, fn): + """ + Mark a fn as skipped + Called from the parser + """ + if not fn in self.depends_cache: + self.depends_cache[fn] = {} + self.depends_cache[fn]["SKIPPED"] = "1" + + def remove(self, fn): + """ + Remove a fn from the cache + Called from the parser in error cases + """ + bb.debug(1, "Removing %s from cache" % fn) + if fn in self.depends_cache: + del self.depends_cache[fn] + if fn in self.clean: + del self.clean[fn] + + def sync(self): + """ + Save the cache + Called from the parser when complete (or exitting) + """ + + if not self.has_cache: + return + + version_data = {} + version_data['CACHE_VER'] = __cache_version__ + version_data['BITBAKE_VER'] = bb.__version__ + + p = pickle.Pickler(file(self.cachefile, "wb" ), -1 ) + p.dump([self.depends_cache, version_data]) + + def mtime(self, cachefile): + try: + return os.stat(cachefile)[8] + except OSError: + return 0 + + def load_bbfile( self, bbfile , cooker): + """ + Load and parse one .bb build file + Return the data and whether parsing resulted in the file being skipped + """ + + import bb + from bb import utils, data, parse, debug, event, fatal + + topdir = data.getVar('TOPDIR', cooker.configuration.data) + if not topdir: + topdir = os.path.abspath(os.getcwd()) + # set topdir to here + data.setVar('TOPDIR', topdir, cooker.configuration) + bbfile = os.path.abspath(bbfile) + bbfile_loc = os.path.abspath(os.path.dirname(bbfile)) + # expand tmpdir to include this topdir + data.setVar('TMPDIR', data.getVar('TMPDIR', cooker.configuration.data, 1) or "", cooker.configuration.data) + # set topdir to location of .bb file + topdir = bbfile_loc + #data.setVar('TOPDIR', topdir, cfg) + # go there + oldpath = os.path.abspath(os.getcwd()) + if self.mtime(topdir): + os.chdir(topdir) + bb_data = data.init_db(cooker.configuration.data) + try: + parse.handle(bbfile, bb_data) # read .bb data + os.chdir(oldpath) + return bb_data, False + except bb.parse.SkipPackage: + os.chdir(oldpath) + return bb_data, True + except: + os.chdir(oldpath) + raise + +def init(cooker): + """ + The Objective: Cache the minimum amount of data possible yet get to the + stage of building packages (i.e. tryBuild) without reparsing any .bb files. + + To do this, we intercept getVar calls and only cache the variables we see + being accessed. We rely on the cache getVar calls being made for all + variables bitbake might need to use to reach this stage. For each cached + file we need to track: + + * Its mtime + * The mtimes of all its dependencies + * Whether it caused a parse.SkipPackage exception + + Files causing parsing errors are evicted from the cache. + + """ + return Cache(cooker) + diff --git a/bitbake/lib/bb/data.py b/bitbake/lib/bb/data.py index 56ee977f66..55d1cc9053 100644 --- a/bitbake/lib/bb/data.py +++ b/bitbake/lib/bb/data.py @@ -7,6 +7,18 @@ BitBake 'Data' implementations Functions for interacting with the data structure used by the BitBake build tools. +The expandData and update_data are the most expensive +operations. At night the cookie monster came by and +suggested 'give me cookies on setting the variables and +things will work out'. Taking this suggestion into account +applying the skills from the not yet passed 'Entwurf und +Analyse von Algorithmen' lecture and the cookie +monster seems to be right. We will track setVar more carefully +to have faster update_data and expandKeys operations. + +This is a treade-off between speed and memory again but +the speed is more critical here. + Copyright (C) 2003, 2004 Chris Larson Copyright (C) 2005 Holger Hans Peter Freyther @@ -36,88 +48,15 @@ sys.path.insert(0,path) from bb import note, debug, data_smart _dict_type = data_smart.DataSmart -_dict_p_type = data_smart.DataSmartPackage - -class DataDictFull(dict): - """ - This implements our Package Data Storage Interface. - setDirty is a no op as all items are held in memory - """ - def setDirty(self, bbfile, data): - """ - No-Op we assume data was manipulated as some sort of - reference - """ - if not bbfile in self: - raise Exception("File %s was not in dictionary before" % bbfile) - - self[bbfile] = data - -class DataDictCache: - """ - Databacked Dictionary implementation - """ - def __init__(self, cache_dir, config): - self.cache_dir = cache_dir - self.files = [] - self.dirty = {} - self.config = config - - def has_key(self,key): - return key in self.files - - def keys(self): - return self.files - - def __setitem__(self, key, data): - """ - Add the key to the list of known files and - place the data in the cache? - """ - if key in self.files: - return - - self.files.append(key) - - def __getitem__(self, key): - if not key in self.files: - return None - - # if it was dirty we will - if key in self.dirty: - return self.dirty[key] - - # not cached yet - return _dict_p_type(self.cache_dir, key,False,self.config) - - def setDirty(self, bbfile, data): - """ - Only already added items can be declared dirty!!! - """ - - if not bbfile in self.files: - raise Exception("File %s was not in dictionary before" % bbfile) - - self.dirty[bbfile] = data - - def init(): return _dict_type() -def init_db(cache,name,clean,parent = None): - return _dict_p_type(cache,name,clean,parent) - -def init_db_mtime(cache,cache_bbfile): - return _dict_p_type.mtime(cache,cache_bbfile) - -def pkgdata(use_cache, cache, config = None): - """ - Return some sort of dictionary to lookup parsed dictionaires - """ - if use_cache: - return DataDictCache(cache, config) - return DataDictFull() +def init_db(parent = None): + if parent: + return parent.createCopy() + else: + return _dict_type() def createCopy(source): """Link the source set to the destination @@ -273,6 +212,27 @@ def setData(newData, d): """Sets the data object to the supplied value""" d = newData + +## +## Cookie Monsters' query functions +## +def _get_override_vars(d, override): + """ + Internal!!! + + Get the Names of Variables that have a specific + override. This function returns a iterable + Set or an empty list + """ + return [] + +def _get_var_flags_triple(d): + """ + Internal!!! + + """ + return [] + __expand_var_regexp__ = re.compile(r"\${[^{}]+}") __expand_python_regexp__ = re.compile(r"\${@.+?}") @@ -303,43 +263,7 @@ def expand(s, d, varname = None): >>> print expand('${SRC_URI}', d) http://somebug.${TARGET_MOO} """ - def var_sub(match): - key = match.group()[2:-1] - if varname and key: - if varname == key: - raise Exception("variable %s references itself!" % varname) - var = getVar(key, d, 1) - if var is not None: - return var - else: - return match.group() - - def python_sub(match): - import bb - code = match.group()[3:-1] - locals()['d'] = d - s = eval(code) - if type(s) == types.IntType: s = str(s) - return s - - if type(s) is not types.StringType: # sanity check - return s - - while s.find('$') != -1: - olds = s - 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 - import bb - bb.error('expansion of %s returned non-string %s' % (olds, s)) - except KeyboardInterrupt: - raise - except: - note("%s:%s while evaluating:\n%s" % (sys.exc_info()[0], sys.exc_info()[1], s)) - raise - return s + return d.expand(s, varname) def expandKeys(alterdata, readdata = None): if readdata == None: @@ -356,7 +280,7 @@ def expandKeys(alterdata, readdata = None): # setVarFlags(ekey, copy.copy(getVarFlags(key, readdata)), alterdata) setVar(ekey, val, alterdata) - for i in ('_append', '_prepend', '_delete'): + for i in ('_append', '_prepend'): dest = getVarFlag(ekey, i, alterdata) or [] src = getVarFlag(key, i, readdata) or [] dest.extend(src) @@ -507,67 +431,76 @@ def update_data(d): >>> print getVar('TEST', d) local """ - debug(2, "update_data()") -# can't do delete env[...] while iterating over the dictionary, so remember them - dodel = [] + # now ask the cookie monster for help + #print "Cookie Monster" + #print "Append/Prepend %s" % d._special_values + #print "Overrides %s" % d._seen_overrides + overrides = (getVar('OVERRIDES', d, 1) or "").split(':') or [] - def applyOverrides(var, d): - if not overrides: - debug(1, "OVERRIDES not defined, nothing to do") - return - val = getVar(var, d) - for o in overrides: - if var.endswith("_" + o): - l = len(o)+1 - name = var[:-l] - d[name] = d[var] + # + # 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 not o in d._seen_overrides: + continue - for s in keys(d): - applyOverrides(s, d) - sval = getVar(s, d) or "" - -# Handle line appends: - for (a, o) in getVarFlag(s, '_append', d) or []: - # maybe the OVERRIDE was not yet added so keep the append - if (o and o in overrides) or not o: - delVarFlag(s, '_append', d) - if o: - if not o in overrides: + vars = d._seen_overrides[o] + for var in vars: + name = var[:-l] + try: + d[name] = d[var] + except: + note ("Untracked delVar") + + # now on to the appends and prepends + if '_append' in d._special_values: + appends = d._special_values['_append'] or [] + for append in appends: + for (a, o) in getVarFlag(append, '_append', d) or []: + # maybe the OVERRIDE was not yet added so keep the append + if (o and o in overrides) or not o: + delVarFlag(append, '_append', d) + if o and not o in overrides: continue - sval+=a - setVar(s, sval, d) - -# Handle line prepends - for (a, o) in getVarFlag(s, '_prepend', d) or []: - # maybe the OVERRIDE was not yet added so keep the append - if (o and o in overrides) or not o: - delVarFlag(s, '_prepend', d) - if o: - if not o in overrides: + + sval = getVar(append,d) or "" + sval+=a + setVar(append, sval, d) + + + if '_prepend' in d._special_values: + prepends = d._special_values['_prepend'] or [] + + for prepend in prepends: + for (a, o) in getVarFlag(prepend, '_prepend', d) or []: + # maybe the OVERRIDE was not yet added so keep the prepend + if (o and o in overrides) or not o: + delVarFlag(prepend, '_prepend', d) + if o and not o in overrides: continue - sval=a+sval - setVar(s, sval, d) - -# Handle line deletions - name = s + "_delete" - nameval = getVar(name, d) - if nameval: - sval = getVar(s, d) - if sval: - new = '' - pattern = nameval.replace('\n','').strip() - for line in sval.split('\n'): - if line.find(pattern) == -1: - new = new + '\n' + line - setVar(s, new, d) - dodel.append(name) - -# delete all environment vars no longer needed - for s in dodel: - delVar(s, d) + + sval = a + (getVar(prepend,d) or "") + setVar(prepend, sval, d) + def inherits_class(klass, d): val = getVar('__inherit_cache', d) or "" diff --git a/bitbake/lib/bb/data_smart.py b/bitbake/lib/bb/data_smart.py index 52f391dec1..fbd4167fe4 100644 --- a/bitbake/lib/bb/data_smart.py +++ b/bitbake/lib/bb/data_smart.py @@ -8,7 +8,7 @@ BitBake build tools. Copyright (C) 2003, 2004 Chris Larson Copyright (C) 2004, 2005 Seb Frankengul -Copyright (C) 2005 Holger Hans Peter Freyther +Copyright (C) 2005, 2006 Holger Hans Peter Freyther Copyright (C) 2005 Uli Luckas Copyright (C) 2005 ROAD GmbH @@ -29,7 +29,8 @@ Based on functions from the base bb module, Copyright 2003 Holger Schurig """ import copy, os, re, sys, time, types -from bb import note, debug, fatal, utils +from bb import note, debug, error, fatal, utils, methodpool +from sets import Set try: import cPickle as pickle @@ -37,9 +38,8 @@ except ImportError: import pickle print "NOTE: Importing cPickle failed. Falling back to a very slow implementation." - -__setvar_keyword__ = ["_append","_prepend","_delete"] -__setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend|_delete)(_(?P<add>.*))?') +__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"\${@.+?}") @@ -48,6 +48,10 @@ class DataSmart: def __init__(self): self.dict = {} + # cookie monster tribute + self._special_values = {} + self._seen_overrides = {} + def expand(self,s, varname): def var_sub(match): key = match.group()[2:-1] @@ -78,8 +82,7 @@ class DataSmart: s = __expand_python_regexp__.sub(python_sub, s) if s == olds: break if type(s) is not types.StringType: # sanity check - import bb - bb.error('expansion of %s returned non-string %s' % (olds, s)) + error('expansion of %s returned non-string %s' % (olds, s)) except KeyboardInterrupt: raise except: @@ -91,18 +94,6 @@ class DataSmart: if not var in self.dict: self.dict[var] = {} - def pickle_prep(self, cfg): - if "_data" in self.dict: - if self.dict["_data"] == cfg: - self.dict["_data"] = "cfg"; - else: # this is an unknown array for the moment - pass - - def unpickle_prep(self, cfg): - if "_data" in self.dict: - if self.dict["_data"] == "cfg": - self.dict["_data"] = cfg; - def _findVar(self,var): _dest = self.dict @@ -116,14 +107,6 @@ class DataSmart: return _dest[var] return None - def _copyVar(self,var,name): - local_var = self._findVar(var) - if local_var: - self.dict[name] = copy.copy(local_var) - else: - debug(1,"Warning, _copyVar %s to %s, %s does not exists" % (var,name,var)) - - def _makeShadowCopy(self, var): if var in self.dict: return @@ -142,11 +125,20 @@ class DataSmart: keyword = match.group("keyword") override = match.group('add') l = self.getVarFlag(base, keyword) or [] - if override == 'delete': - if l.count([value, None]): - del l[l.index([value, None])] l.append([value, override]) - self.setVarFlag(base, match.group("keyword"), l) + self.setVarFlag(base, keyword, l) + + # pay the cookie monster + try: + self._special_values[keyword].add( base ) + except: + self._special_values[keyword] = Set() + self._special_values[keyword].add( base ) + + # SRC_URI_append_simpad is both a flag and a override + #if not override in self._seen_overrides: + # self._seen_overrides[override] = Set() + #self._seen_overrides[override].add( base ) return if not var in self.dict: @@ -155,6 +147,13 @@ class DataSmart: self.delVarFlag(var, 'matchesenv') self.setVarFlag(var, 'export', 1) + # more cookies for the cookie monster + if '_' in var: + override = var[var.rfind('_')+1:] + if not override in self._seen_overrides: + self._seen_overrides[override] = Set() + self._seen_overrides[override].add( var ) + # setting var self.dict[var]["content"] = value @@ -237,6 +236,8 @@ class DataSmart: # we really want this to be a DataSmart... data = DataSmart() data.dict["_data"] = self.dict + data._seen_overrides = copy.deepcopy(self._seen_overrides) + data._special_values = copy.deepcopy(self._special_values) return data @@ -254,98 +255,11 @@ class DataSmart: return keytab.keys() def __getitem__(self,item): - start = self.dict - while start: - if item in start: - return start[item] - elif "_data" in start: - start = start["_data"] - else: - start = None - return None + #print "Warning deprecated" + return self.getVar(item, False) def __setitem__(self,var,data): - self._makeShadowCopy(var) - self.dict[var] = data - - -class DataSmartPackage(DataSmart): - """ - Persistent Data Storage - """ - def sanitize_filename(bbfile): - return bbfile.replace( '/', '_' ) - sanitize_filename = staticmethod(sanitize_filename) + #print "Warning deprecated" + self.setVar(var,data) - def unpickle(self): - """ - Restore the dict from memory - """ - cache_bbfile = self.sanitize_filename(self.bbfile) - p = pickle.Unpickler( file("%s/%s"%(self.cache,cache_bbfile),"rb")) - self.dict = p.load() - self.unpickle_prep() - funcstr = self.getVar('__functions__', 0) - if funcstr: - comp = utils.better_compile(funcstr, "<pickled>", self.bbfile) - utils.better_exec(comp, __builtins__, funcstr, self.bbfile) - - def linkDataSet(self): - if not self.parent == None: - # assume parent is a DataSmartInstance - self.dict["_data"] = self.parent.dict - - - def __init__(self,cache,name,clean,parent): - """ - Construct a persistent data instance - """ - #Initialize the dictionary - DataSmart.__init__(self) - - self.cache = cache - self.bbfile = os.path.abspath( name ) - self.parent = parent - - # Either unpickle the data or do copy on write - if clean: - self.linkDataSet() - else: - self.unpickle() - - def commit(self, mtime): - """ - Save the package to a permanent storage - """ - self.pickle_prep() - - cache_bbfile = self.sanitize_filename(self.bbfile) - p = pickle.Pickler(file("%s/%s" %(self.cache,cache_bbfile), "wb" ), -1 ) - p.dump( self.dict ) - - self.unpickle_prep() - def mtime(cache,bbfile): - cache_bbfile = DataSmartPackage.sanitize_filename(bbfile) - try: - return os.stat( "%s/%s" % (cache,cache_bbfile) )[8] - except OSError: - return 0 - mtime = staticmethod(mtime) - - def pickle_prep(self): - """ - If self.dict contains a _data key and it is a configuration - we will remember we had a configuration instance attached - """ - if "_data" in self.dict: - if self.dict["_data"] == self.parent: - dest["_data"] = "cfg" - - def unpickle_prep(self): - """ - If we had a configuration instance attached, we will reattach it - """ - if "_data" in self.dict: - if self.dict["_data"] == "cfg": - self.dict["_data"] = self.parent diff --git a/bitbake/lib/bb/event.py b/bitbake/lib/bb/event.py index cbe6d2a11a..b1d12177c4 100644 --- a/bitbake/lib/bb/event.py +++ b/bitbake/lib/bb/event.py @@ -44,7 +44,13 @@ class Event: NotHandled = 0 Handled = 1 -handlers = [] + +Registered = 10 +AlreadyRegistered = 14 + +# Internal +_handlers = [] +_handlers_dict = {} def tmpHandler(event): """Default handler for code events""" @@ -57,7 +63,7 @@ def defaultTmpHandler(): def fire(event): """Fire off an Event""" - for h in handlers: + for h in _handlers: if type(h).__name__ == "code": exec(h) if tmpHandler(event) == Handled: @@ -67,15 +73,22 @@ def fire(event): return Handled return NotHandled -def register(handler): +def register(name, handler): """Register an Event handler""" + + # already registered + if name in _handlers_dict: + return AlreadyRegistered + if handler is not None: # handle string containing python code if type(handler).__name__ == "str": - return _registerCode(handler) -# prevent duplicate registration - if not handler in handlers: - handlers.append(handler) + _registerCode(handler) + else: + _handlers.append(handler) + + _handlers_dict[name] = 1 + return Registered def _registerCode(handlerStr): """Register a 'code' Event. @@ -88,24 +101,23 @@ def _registerCode(handlerStr): tmp = "def tmpHandler(e):\n%s" % handlerStr comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._registerCode") # prevent duplicate registration - if not comp in handlers: - handlers.append(comp) + _handlers.append(comp) -def remove(handler): +def remove(name, handler): """Remove an Event handler""" - for h in handlers: - if type(handler).__name__ == "str": - return _removeCode(handler) - if handler is h: - handlers.remove(handler) + _handlers_dict.pop(name) + if type(handler).__name__ == "str": + return _removeCode(handler) + else: + _handlers.remove(handler) def _removeCode(handlerStr): """Remove a 'code' Event handler Deprecated interface; call remove instead.""" tmp = "def tmpHandler(e):\n%s" % handlerStr comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._removeCode") - handlers.remove(comp) + _handlers.remove(comp) def getName(e): """Returns the name of a class or class instance""" diff --git a/bitbake/lib/bb/fetch/__init__.py b/bitbake/lib/bb/fetch/__init__.py index 0515f2a5e9..ac698a0d1c 100644 --- a/bitbake/lib/bb/fetch/__init__.py +++ b/bitbake/lib/bb/fetch/__init__.py @@ -168,10 +168,6 @@ class Fetch(object): d Is a bb.data instance tarfn is the name of the tarball """ - tarpath = os.path.join(data.getVar("DL_DIR", d, 1), tarfn) - if os.access(tarpath, os.R_OK): - return True - pn = data.getVar('PN', d, True) src_tarball_stash = None if pn: diff --git a/bitbake/lib/bb/fetch/git.py b/bitbake/lib/bb/fetch/git.py index f30ae2360a..49235c141e 100644 --- a/bitbake/lib/bb/fetch/git.py +++ b/bitbake/lib/bb/fetch/git.py @@ -129,7 +129,7 @@ class Git(Fetch): os.chdir(repodir) rungitcmd("tar -xzf %s" % (repofile),d) else: - rungitcmd("git clone %s://%s%s %s" % (proto, host, path, repodir),d) + rungitcmd("git clone -n %s://%s%s %s" % (proto, host, path, repodir),d) os.chdir(repodir) rungitcmd("git pull %s://%s%s" % (proto, host, path),d) diff --git a/bitbake/lib/bb/methodpool.py b/bitbake/lib/bb/methodpool.py new file mode 100644 index 0000000000..d7434ed33e --- /dev/null +++ b/bitbake/lib/bb/methodpool.py @@ -0,0 +1,101 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# +# Copyright (C) 2006 Holger Hans Peter Freyther +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# Neither the name Holger Hans Peter Freyther nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + + +""" + What is a method pool? + + BitBake has a global method scope where .bb, .inc and .bbclass + files can install methods. These methods are parsed from strings. + To avoid recompiling and executing these string we introduce + a method pool to do this task. + + This pool will be used to compile and execute the functions. It + will be smart enough to +""" + +from bb.utils import better_compile, better_exec +from bb import error + +# A dict of modules we have handled +# it is the number of .bbclasses + x in size +_parsed_methods = { } +_parsed_fns = { } + +def insert_method(modulename, code, fn): + """ + Add code of a module should be added. The methods + will be simply added, no checking will be done + """ + comp = better_compile(code, "<bb>", fn ) + better_exec(comp, __builtins__, code, fn) + + # hack hack hack XXX + return + + # now some instrumentation + code = comp.co_names + for name in code: + if name in ['None', 'False']: + continue + elif name in _parsed_fns and not _parsed_fns[name] == modulename: + error( "Error Method already seen: %s in' %s' now in '%s'" % (name, _parsed_fns[name], modulename)) + else: + _parsed_fns[name] = modulename + +def check_insert_method(modulename, code, fn): + """ + Add the code if it wasnt added before. The module + name will be used for that + + Variables: + @modulename a short name e.g. base.bbclass + @code The actual python code + @fn The filename from the outer file + """ + if not modulename in _parsed_methods: + return insert_method(modulename, code, fn) + +def parsed_module(modulename): + """ + Inform me file xyz was parsed + """ + return modulename in _parsed_methods + + +def get_parsed_dict(): + """ + shortcut + """ + return _parsed_methods diff --git a/bitbake/lib/bb/parse/__init__.py b/bitbake/lib/bb/parse/__init__.py index cb27416061..58e17d154a 100644 --- a/bitbake/lib/bb/parse/__init__.py +++ b/bitbake/lib/bb/parse/__init__.py @@ -46,9 +46,9 @@ def update_mtime(f): def mark_dependency(d, f): if f.startswith('./'): f = "%s/%s" % (os.getcwd(), f[2:]) - deps = (bb.data.getVar('__depends', d) or "").split() - deps.append("%s@%s" % (f, cached_mtime(f))) - bb.data.setVar('__depends', " ".join(deps), d) + deps = bb.data.getVar('__depends', d) or [] + deps.append( (f, cached_mtime(f)) ) + bb.data.setVar('__depends', deps, d) def supports(fn, data): """Returns true if we have a handler for this file, false otherwise""" diff --git a/bitbake/lib/bb/parse/parse_c/BBHandler.py b/bitbake/lib/bb/parse/parse_c/BBHandler.py index 300871d9e3..d9f48db17b 100644 --- a/bitbake/lib/bb/parse/parse_c/BBHandler.py +++ b/bitbake/lib/bb/parse/parse_c/BBHandler.py @@ -1,29 +1,42 @@ # ex:ts=4:sw=4:sts=4:et # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (C) 2006 Holger Hans Peter Freyther -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -# SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, -# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR -# THE USE OR OTHER DEALINGS IN THE SOFTWARE. -# +"""class for handling .bb files (using a C++ parser) + + Reads a .bb file and obtains its metadata (using a C++ parser) + + Copyright (C) 2006 Tim Robert Ansell + Copyright (C) 2006 Holger Hans Peter Freyther + + This program is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free Software + Foundation; either version 2 of the License, or (at your option) any later + version. -from bb import data -from bb.parse import ParseError + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT + SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + THE USE OR OTHER DEALINGS IN THE SOFTWARE. +""" + +import os + +# The Module we will use here +import bb + +from bitbakec import parsefile # # This is the Python Part of the Native Parser Implementation. @@ -34,29 +47,64 @@ from bb.parse import ParseError # # The rest of the methods are internal implementation details. - - -# -# internal -# - +def _init(fn, d): + """ + Initialize the data implementation with values of + the environment and data from the file. + """ + pass # # public # def supports(fn, data): - return fn[-3:] == ".bb" or fn[-8:] == ".bbclass" or fn[-4:] == ".inc" + return fn[-3:] == ".bb" or fn[-8:] == ".bbclass" or fn[-4:] == ".inc" or fn[-5:] == ".conf" def init(fn, data): - print "Init" + if not data.getVar('TOPDIR'): + bb.error('TOPDIR is not set') + if not data.getVar('BBPATH'): + bb.error('BBPATH is not set') + -def handle(fn, data, include): +def handle(fn, d, include): print "" print "fn: %s" % fn - print "data: %s" % data + print "data: %s" % d + print dir(d) + print d.getVar.__doc__ print "include: %s" % include - pass + # check if we include or are the beginning + if include: + oldfile = d.getVar('FILE') + else: + #d.inheritFromOS() + oldfile = None + + # find the file + if not os.path.isabs(fn): + bb.error("No Absolute FILE name") + abs_fn = bb.which(d.getVar('BBPATH'), fn) + else: + abs_fn = fn + + # check if the file exists + if not os.path.exists(abs_fn): + raise IOError("file '%(fn)' not found" % locals() ) + + # now we know the file is around mark it as dep + if include: + parse.mark_dependency(d, abs_fn) + + # now parse this file - by defering it to C++ + parsefile(fn, d) + + # restore the original FILE + if oldfile: + d.setVar('FILE', oldfile) + + return d # Inform bitbake that we are a parser # We need to define all three diff --git a/bitbake/lib/bb/parse/parse_c/Makefile b/bitbake/lib/bb/parse/parse_c/Makefile new file mode 100644 index 0000000000..9eb7ce9d08 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/Makefile @@ -0,0 +1,36 @@ + +test: bitbakec.so + python test.py + +bitbakescanner.cc: bitbakescanner.l + flex -t bitbakescanner.l > bitbakescanner.cc + +bitbakeparser.cc: bitbakeparser.y python_output.h + lemon bitbakeparser.y + mv bitbakeparser.c bitbakeparser.cc + +bitbakec.c: bitbakec.pyx + pyrexc bitbakec.pyx + +bitbakec-processed.c: bitbakec.c + cat bitbakec.c | sed -e"s/__pyx_f_8bitbakec_//" > bitbakec-processed.c + +bitbakec.o: bitbakec-processed.c + gcc -c bitbakec-processed.c -o bitbakec.o -fPIC -I/usr/include/python2.4 + +bitbakeparser.o: bitbakeparser.cc + g++ -c bitbakeparser.cc -fPIC -I/usr/include/python2.4 + +bitbakescanner.o: bitbakescanner.cc + g++ -c bitbakescanner.cc -fPIC -I/usr/include/python2.4 + +bitbakec.so: bitbakec.o bitbakeparser.o bitbakescanner.o + g++ -shared -fPIC bitbakeparser.o bitbakescanner.o bitbakec.o -o bitbakec.so + +clean: + rm *.out + rm *.cc + rm bitbakec.c + rm bitbakec-processed.c + rm *.o + rm *.so diff --git a/bitbake/lib/bb/parse/parse_c/bitbakec.pyx b/bitbake/lib/bb/parse/parse_c/bitbakec.pyx new file mode 100644 index 0000000000..362cc2021e --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/bitbakec.pyx @@ -0,0 +1,180 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- + +cdef extern from "stdio.h": + ctypedef int FILE + FILE *fopen(char*, char*) + int fclose(FILE *fp) + + +cdef extern from "lexerc.h": + ctypedef struct lex_t: + void* parser + void* scanner + FILE* file + void* data + + int lineError + int errorParse + + cdef extern void parse(FILE*, object) + +def parsefile(object file, object data): + print "parsefile: 1", file, data + + # Open the file + cdef FILE* f + + f = fopen(file, "r") + print "parsefile: 2 opening file" + if (f == NULL): + raise IOError("No such file %s." % file) + + print "parsefile: 3 parse" + parse(f, data) + + # Close the file + print "parsefile: 4 closing" + fclose(f) + + +cdef public void e_assign(lex_t* container, char* key, char* what): + print "e_assign", key, what + d = <object>container.data + d.setVar(key, what) + +cdef public void e_export(lex_t* c, char* what): + print "e_export", what + #exp: + # bb.data.setVarFlag(key, "export", 1, data) + d = <object>container.data + d.setVarFlag(key, "export", 1) + +cdef public void e_immediate(lex_t* c, char* key, char* what): + print "e_immediate", key, what + #colon: + # val = bb.data.expand(groupd["value"], data) + d = <object>c.data + d.setVar(key, d.expand(what)) + +cdef public void e_cond(lex_t* c, char* key, char* what): + print "e_cond", key, what + #ques: + # val = bb.data.getVar(key, data) + # if val == None: + # val = groupd["value"] + d = <object>c.data + d.setVar(key, (d.getVar(key) or what)) + +cdef public void e_prepend(lex_t* c, char* key, char* what): + print "e_prepend", key, what + #prepend: + # val = "%s %s" % (groupd["value"], (bb.data.getVar(key, data) or "")) + d = <object>c.data + d.setVar(key, what + " " + (d.getVar(key) or "")) + +cdef public void e_append(lex_t* c, char* key, char* what): + print "e_append", key, what + #append: + # val = "%s %s" % ((bb.data.getVar(key, data) or ""), groupd["value"]) + d = <object>c.data + d.setVar(key, (d.getVar(key) or "") + " " + what) + +cdef public void e_precat(lex_t* c, char* key, char* what): + print "e_precat", key, what + #predot: + # val = "%s%s" % (groupd["value"], (bb.data.getVar(key, data) or "")) + d = <object>c.data + d.setVar(key, what + (d.getVar(key) or "")) + +cdef public void e_postcat(lex_t* c, char* key, char* what): + print "e_postcat", key, what + #postdot: + # val = "%s%s" % ((bb.data.getVar(key, data) or ""), groupd["value"]) + d = <object>c.data + d.setVar(key, (d.getVar(key) or "") + what) + +cdef public void e_addtask(lex_t* c, char* name, char* before, char* after): + print "e_addtask", name, before, after + # 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 + + do = "do_%s" % name + d = <object>c.data + d.setVarFlag(do, "task", 1) + + if strlen(before) > 0: + d.setVarFlag(do, "deps", ("%s" % after).split()) + if strlen(after) > 0: + d.setVarFlag(do, "deps", ("%s" % before).split()) + + +cdef public void e_addhandler(lex_t* c, char* h): + print "e_addhandler", h + # data.setVarFlag(h, "handler", 1, d) + d = <object>c.data + d.setVarFlag(h, "handler", 1) + +cdef public void e_export_func(lex_t* c, char* function): + print "e_export_func", function + pass + +cdef public void e_inherit(lex_t* c, char* file): + print "e_inherit", file + pass + +cdef public void e_include(lex_t* c, char* file): + print "e_include", file + d = <object>c.data + d.expand(file) + + try: + parsefile(file, d) + except IOError: + print "Could not include required file %s" % file + + +cdef public void e_require(lex_t* c, char* file): + print "e_require", file + d = <object>c.data + d.expand(file) + + try: + parsefile(file, d) + except IOError: + raise CParseError("Could not include required file %s" % file) + +cdef public void e_proc(lex_t* c, char* key, char* what): + print "e_proc", key, what + pass + +cdef public void e_proc_python(lex_t* c, char* key, char* what): + print "e_proc_python", key, what + pass + +cdef public void e_proc_fakeroot(lex_t* c, char* key, char* what): + print "e_fakeroot", key, what + pass + +cdef public void e_def(lex_t* c, char* a, char* b, char* d): + print "e_def", key, what + pass + +cdef public void e_parse_error(lex_t* c): + print "e_parse_error", "line:", lineError, "parse:", errorParse + raise CParseError("There was an parse error, sorry unable to give more information at the current time.") + diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc b/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc index 3a3c53dd46..ee9a901b70 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc @@ -59,22 +59,22 @@ ** defined, then do no error processing. */ #define YYCODETYPE unsigned char -#define YYNOCODE 42 +#define YYNOCODE 44 #define YYACTIONTYPE unsigned char #define bbparseTOKENTYPE token_t typedef union { bbparseTOKENTYPE yy0; - int yy83; + int yy87; } YYMINORTYPE; #define YYSTACKDEPTH 100 #define bbparseARG_SDECL lex_t* lex; #define bbparseARG_PDECL ,lex_t* lex #define bbparseARG_FETCH lex_t* lex = yypParser->lex #define bbparseARG_STORE yypParser->lex = lex -#define YYNSTATE 74 -#define YYNRULE 41 -#define YYERRORSYMBOL 28 -#define YYERRSYMDT yy83 +#define YYNSTATE 82 +#define YYNRULE 45 +#define YYERRORSYMBOL 30 +#define YYERRSYMDT yy87 #define YY_NO_ACTION (YYNSTATE+YYNRULE+2) #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) #define YY_ERROR_ACTION (YYNSTATE+YYNRULE) @@ -127,53 +127,63 @@ typedef union { ** yy_default[] Default action for each state. */ static const YYACTIONTYPE yy_action[] = { - /* 0 */ 28, 47, 5, 57, 33, 58, 30, 25, 24, 37, - /* 10 */ 45, 14, 2, 29, 41, 3, 16, 4, 23, 39, - /* 20 */ 69, 8, 11, 17, 26, 48, 47, 32, 21, 42, - /* 30 */ 31, 57, 57, 73, 44, 10, 66, 7, 34, 38, - /* 40 */ 57, 51, 72, 116, 1, 62, 6, 49, 52, 35, - /* 50 */ 36, 59, 54, 9, 20, 64, 43, 22, 40, 50, - /* 60 */ 46, 71, 67, 60, 15, 65, 61, 70, 53, 56, - /* 70 */ 27, 12, 68, 63, 84, 55, 18, 84, 13, 84, - /* 80 */ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, - /* 90 */ 84, 19, + /* 0 */ 82, 3, 7, 8, 38, 22, 39, 24, 26, 32, + /* 10 */ 34, 28, 30, 128, 1, 40, 53, 70, 55, 5, + /* 20 */ 60, 65, 67, 2, 21, 36, 69, 77, 9, 7, + /* 30 */ 11, 6, 13, 15, 17, 19, 12, 52, 50, 4, + /* 40 */ 74, 42, 46, 59, 57, 10, 64, 62, 38, 14, + /* 50 */ 73, 16, 38, 38, 76, 81, 18, 20, 23, 25, + /* 60 */ 27, 29, 31, 33, 35, 37, 56, 51, 90, 54, + /* 70 */ 58, 71, 41, 43, 63, 45, 44, 47, 72, 48, + /* 80 */ 75, 78, 80, 61, 90, 49, 66, 90, 90, 68, + /* 90 */ 90, 90, 90, 90, 90, 79, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 1, 2, 3, 21, 4, 23, 6, 7, 8, 9, - /* 10 */ 31, 32, 13, 14, 1, 16, 39, 18, 19, 20, - /* 20 */ 37, 38, 22, 24, 25, 1, 2, 4, 10, 6, - /* 30 */ 7, 21, 21, 23, 23, 22, 35, 36, 11, 12, - /* 40 */ 21, 5, 23, 29, 30, 33, 34, 5, 5, 10, - /* 50 */ 12, 10, 5, 22, 39, 15, 40, 11, 10, 5, - /* 60 */ 26, 17, 17, 10, 32, 35, 33, 17, 5, 5, - /* 70 */ 1, 22, 37, 1, 41, 5, 39, 41, 27, 41, - /* 80 */ 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, - /* 90 */ 41, 39, + /* 0 */ 0, 1, 2, 3, 23, 4, 25, 6, 7, 8, + /* 10 */ 9, 10, 11, 31, 32, 15, 16, 1, 18, 42, + /* 20 */ 20, 21, 22, 33, 34, 24, 26, 27, 1, 2, + /* 30 */ 4, 28, 6, 7, 8, 9, 5, 35, 36, 29, + /* 40 */ 24, 13, 14, 37, 38, 34, 39, 40, 23, 5, + /* 50 */ 25, 5, 23, 23, 25, 25, 5, 5, 5, 5, + /* 60 */ 5, 5, 5, 5, 5, 41, 17, 35, 43, 1, + /* 70 */ 37, 24, 12, 12, 39, 12, 14, 12, 41, 13, + /* 80 */ 41, 1, 41, 19, 43, 12, 19, 43, 43, 19, + /* 90 */ 43, 43, 43, 43, 43, 24, }; -#define YY_SHIFT_USE_DFLT (-19) -#define YY_SHIFT_MAX 43 +#define YY_SHIFT_USE_DFLT (-20) static const signed char yy_shift_ofst[] = { - /* 0 */ -19, -1, 18, 40, 45, 24, 18, 40, 45, -19, - /* 10 */ -19, -19, -19, -19, 0, 23, -18, 13, 19, 10, - /* 20 */ 11, 27, 53, 50, 63, 64, 69, 49, 51, 72, - /* 30 */ 70, 36, 42, 43, 39, 38, 41, 47, 48, 44, - /* 40 */ 46, 31, 54, 34, + /* 0 */ -20, 0, -20, 10, -20, 3, -20, -20, 27, -20, + /* 10 */ 26, 31, -20, 44, -20, 46, -20, 51, -20, 52, + /* 20 */ -20, 1, 53, -20, 54, -20, 55, -20, 56, -20, + /* 30 */ 57, -20, 58, -20, 59, -20, -20, -19, -20, -20, + /* 40 */ 60, 28, 61, 62, 63, -20, 65, 66, 73, -20, + /* 50 */ 60, -20, -20, 68, -20, 49, -20, 49, -20, -20, + /* 60 */ 64, -20, 64, -20, -20, 67, -20, 70, -20, 16, + /* 70 */ 47, -20, 25, -20, -20, 29, -20, 80, 71, -20, + /* 80 */ 30, -20, }; #define YY_REDUCE_USE_DFLT (-24) -#define YY_REDUCE_MAX 13 static const signed char yy_reduce_ofst[] = { - /* 0 */ 14, -21, 12, 1, -17, 32, 33, 30, 35, 37, - /* 10 */ 52, -23, 15, 16, + /* 0 */ -18, -10, -24, -24, -23, -24, -24, -24, 11, -24, + /* 10 */ -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + /* 20 */ -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + /* 30 */ -24, -24, -24, -24, -24, -24, 24, -24, -24, -24, + /* 40 */ 2, -24, -24, -24, -24, -24, -24, -24, -24, -24, + /* 50 */ 32, -24, -24, -24, -24, 6, -24, 33, -24, -24, + /* 60 */ 7, -24, 35, -24, -24, -24, -24, -24, -24, -24, + /* 70 */ -24, 37, -24, -24, 39, -24, -24, -24, -24, 41, + /* 80 */ -24, -24, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 76, 74, 115, 115, 115, 115, 94, 99, 103, 107, - /* 10 */ 107, 107, 107, 113, 115, 115, 115, 115, 115, 115, - /* 20 */ 115, 89, 115, 115, 115, 115, 115, 115, 77, 115, - /* 30 */ 115, 115, 115, 115, 115, 90, 115, 115, 115, 115, - /* 40 */ 91, 115, 115, 114, 111, 75, 112, 78, 77, 79, - /* 50 */ 80, 81, 82, 83, 84, 85, 86, 106, 108, 87, - /* 60 */ 88, 92, 93, 95, 96, 97, 98, 100, 101, 102, - /* 70 */ 104, 105, 109, 110, + /* 0 */ 84, 127, 83, 85, 125, 126, 124, 86, 127, 85, + /* 10 */ 127, 127, 87, 127, 88, 127, 89, 127, 90, 127, + /* 20 */ 91, 127, 127, 92, 127, 93, 127, 94, 127, 95, + /* 30 */ 127, 96, 127, 97, 127, 98, 119, 127, 118, 120, + /* 40 */ 127, 101, 127, 102, 127, 99, 127, 103, 127, 100, + /* 50 */ 106, 104, 105, 127, 107, 127, 108, 111, 109, 110, + /* 60 */ 127, 112, 115, 113, 114, 127, 116, 127, 117, 127, + /* 70 */ 127, 119, 127, 121, 119, 127, 122, 127, 127, 119, + /* 80 */ 127, 123, }; #define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0])) @@ -260,16 +270,16 @@ void bbparseTrace(FILE *TraceFILE, char *zTracePrompt){ ** are required. The following table supplies these names */ static const char *const yyTokenName[] = { "$", "SYMBOL", "VARIABLE", "EXPORT", - "OP_ASSIGN", "STRING", "OP_IMMEDIATE", "OP_COND", - "OP_PREPEND", "OP_APPEND", "TSYMBOL", "BEFORE", - "AFTER", "ADDTASK", "ADDHANDLER", "FSYMBOL", - "EXPORT_FUNC", "ISYMBOL", "INHERIT", "INCLUDE", - "REQUIRE", "PROC_BODY", "PROC_OPEN", "PROC_CLOSE", - "PYTHON", "FAKEROOT", "DEF_BODY", "DEF_ARGS", - "error", "program", "statements", "statement", - "variable", "task", "tasks", "func", - "funcs", "inherit", "inherits", "proc_body", - "def_body", + "OP_ASSIGN", "STRING", "OP_PREDOT", "OP_POSTDOT", + "OP_IMMEDIATE", "OP_COND", "OP_PREPEND", "OP_APPEND", + "TSYMBOL", "BEFORE", "AFTER", "ADDTASK", + "ADDHANDLER", "FSYMBOL", "EXPORT_FUNC", "ISYMBOL", + "INHERIT", "INCLUDE", "REQUIRE", "PROC_BODY", + "PROC_OPEN", "PROC_CLOSE", "PYTHON", "FAKEROOT", + "DEF_BODY", "DEF_ARGS", "error", "program", + "statements", "statement", "variable", "task", + "tasks", "func", "funcs", "inherit", + "inherits", "proc_body", "def_body", }; #endif /* NDEBUG */ @@ -283,41 +293,45 @@ static const char *const yyRuleName[] = { /* 3 */ "variable ::= SYMBOL", /* 4 */ "variable ::= VARIABLE", /* 5 */ "statement ::= EXPORT variable OP_ASSIGN STRING", - /* 6 */ "statement ::= EXPORT variable OP_IMMEDIATE STRING", - /* 7 */ "statement ::= EXPORT variable OP_COND STRING", - /* 8 */ "statement ::= variable OP_ASSIGN STRING", - /* 9 */ "statement ::= variable OP_PREPEND STRING", - /* 10 */ "statement ::= variable OP_APPEND STRING", - /* 11 */ "statement ::= variable OP_IMMEDIATE STRING", - /* 12 */ "statement ::= variable OP_COND STRING", - /* 13 */ "task ::= TSYMBOL BEFORE TSYMBOL AFTER TSYMBOL", - /* 14 */ "task ::= TSYMBOL AFTER TSYMBOL BEFORE TSYMBOL", - /* 15 */ "task ::= TSYMBOL", - /* 16 */ "task ::= TSYMBOL BEFORE TSYMBOL", - /* 17 */ "task ::= TSYMBOL AFTER TSYMBOL", - /* 18 */ "tasks ::= tasks task", - /* 19 */ "tasks ::= task", - /* 20 */ "statement ::= ADDTASK tasks", - /* 21 */ "statement ::= ADDHANDLER SYMBOL", - /* 22 */ "func ::= FSYMBOL", - /* 23 */ "funcs ::= funcs func", - /* 24 */ "funcs ::= func", - /* 25 */ "statement ::= EXPORT_FUNC funcs", - /* 26 */ "inherit ::= ISYMBOL", - /* 27 */ "inherits ::= inherits inherit", - /* 28 */ "inherits ::= inherit", - /* 29 */ "statement ::= INHERIT inherits", - /* 30 */ "statement ::= INCLUDE ISYMBOL", - /* 31 */ "statement ::= REQUIRE ISYMBOL", - /* 32 */ "proc_body ::= proc_body PROC_BODY", - /* 33 */ "proc_body ::=", - /* 34 */ "statement ::= variable PROC_OPEN proc_body PROC_CLOSE", - /* 35 */ "statement ::= PYTHON SYMBOL PROC_OPEN proc_body PROC_CLOSE", - /* 36 */ "statement ::= PYTHON PROC_OPEN proc_body PROC_CLOSE", - /* 37 */ "statement ::= FAKEROOT SYMBOL PROC_OPEN proc_body PROC_CLOSE", - /* 38 */ "def_body ::= def_body DEF_BODY", - /* 39 */ "def_body ::=", - /* 40 */ "statement ::= SYMBOL DEF_ARGS def_body", + /* 6 */ "statement ::= EXPORT variable OP_PREDOT STRING", + /* 7 */ "statement ::= EXPORT variable OP_POSTDOT STRING", + /* 8 */ "statement ::= EXPORT variable OP_IMMEDIATE STRING", + /* 9 */ "statement ::= EXPORT variable OP_COND STRING", + /* 10 */ "statement ::= variable OP_ASSIGN STRING", + /* 11 */ "statement ::= variable OP_PREDOT STRING", + /* 12 */ "statement ::= variable OP_POSTDOT STRING", + /* 13 */ "statement ::= variable OP_PREPEND STRING", + /* 14 */ "statement ::= variable OP_APPEND STRING", + /* 15 */ "statement ::= variable OP_IMMEDIATE STRING", + /* 16 */ "statement ::= variable OP_COND STRING", + /* 17 */ "task ::= TSYMBOL BEFORE TSYMBOL AFTER TSYMBOL", + /* 18 */ "task ::= TSYMBOL AFTER TSYMBOL BEFORE TSYMBOL", + /* 19 */ "task ::= TSYMBOL", + /* 20 */ "task ::= TSYMBOL BEFORE TSYMBOL", + /* 21 */ "task ::= TSYMBOL AFTER TSYMBOL", + /* 22 */ "tasks ::= tasks task", + /* 23 */ "tasks ::= task", + /* 24 */ "statement ::= ADDTASK tasks", + /* 25 */ "statement ::= ADDHANDLER SYMBOL", + /* 26 */ "func ::= FSYMBOL", + /* 27 */ "funcs ::= funcs func", + /* 28 */ "funcs ::= func", + /* 29 */ "statement ::= EXPORT_FUNC funcs", + /* 30 */ "inherit ::= ISYMBOL", + /* 31 */ "inherits ::= inherits inherit", + /* 32 */ "inherits ::= inherit", + /* 33 */ "statement ::= INHERIT inherits", + /* 34 */ "statement ::= INCLUDE ISYMBOL", + /* 35 */ "statement ::= REQUIRE ISYMBOL", + /* 36 */ "proc_body ::= proc_body PROC_BODY", + /* 37 */ "proc_body ::=", + /* 38 */ "statement ::= variable PROC_OPEN proc_body PROC_CLOSE", + /* 39 */ "statement ::= PYTHON SYMBOL PROC_OPEN proc_body PROC_CLOSE", + /* 40 */ "statement ::= PYTHON PROC_OPEN proc_body PROC_CLOSE", + /* 41 */ "statement ::= FAKEROOT SYMBOL PROC_OPEN proc_body PROC_CLOSE", + /* 42 */ "def_body ::= def_body DEF_BODY", + /* 43 */ "def_body ::=", + /* 44 */ "statement ::= SYMBOL DEF_ARGS def_body", }; #endif /* NDEBUG */ @@ -402,9 +416,11 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ case 25: case 26: case 27: + case 28: + case 29: #line 50 "bitbakeparser.y" { (yypminor->yy0).release_this (); } -#line 409 "bitbakeparser.c" +#line 425 "bitbakeparser.c" break; default: break; /* If no destructor action specified: do nothing */ } @@ -473,7 +489,9 @@ static int yy_find_shift_action( int i; int stateno = pParser->yystack[pParser->yyidx].stateno; - if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ + /* if( pParser->yyidx<0 ) return YY_NO_ACTION; */ + i = yy_shift_ofst[stateno]; + if( i==YY_SHIFT_USE_DFLT ){ return yy_default[stateno]; } if( iLookAhead==YYNOCODE ){ @@ -515,8 +533,8 @@ static int yy_find_reduce_action( int i; /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ - if( stateno>YY_REDUCE_MAX || - (i = yy_reduce_ofst[stateno])==YY_REDUCE_USE_DFLT ){ + i = yy_reduce_ofst[stateno]; + if( i==YY_REDUCE_USE_DFLT ){ return yy_default[stateno]; } if( iLookAhead==YYNOCODE ){ @@ -578,47 +596,51 @@ static const struct { YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ unsigned char nrhs; /* Number of right-hand side symbols in the rule */ } yyRuleInfo[] = { - { 29, 1 }, - { 30, 2 }, - { 30, 0 }, - { 32, 1 }, - { 32, 1 }, - { 31, 4 }, - { 31, 4 }, - { 31, 4 }, - { 31, 3 }, - { 31, 3 }, - { 31, 3 }, - { 31, 3 }, - { 31, 3 }, - { 33, 5 }, - { 33, 5 }, - { 33, 1 }, + { 31, 1 }, + { 32, 2 }, + { 32, 0 }, + { 34, 1 }, + { 34, 1 }, + { 33, 4 }, + { 33, 4 }, + { 33, 4 }, + { 33, 4 }, + { 33, 4 }, { 33, 3 }, { 33, 3 }, - { 34, 2 }, - { 34, 1 }, - { 31, 2 }, - { 31, 2 }, + { 33, 3 }, + { 33, 3 }, + { 33, 3 }, + { 33, 3 }, + { 33, 3 }, + { 35, 5 }, + { 35, 5 }, { 35, 1 }, + { 35, 3 }, + { 35, 3 }, { 36, 2 }, { 36, 1 }, - { 31, 2 }, + { 33, 2 }, + { 33, 2 }, { 37, 1 }, { 38, 2 }, { 38, 1 }, - { 31, 2 }, - { 31, 2 }, - { 31, 2 }, - { 39, 2 }, - { 39, 0 }, - { 31, 4 }, - { 31, 5 }, - { 31, 4 }, - { 31, 5 }, + { 33, 2 }, + { 39, 1 }, { 40, 2 }, - { 40, 0 }, - { 31, 3 }, + { 40, 1 }, + { 33, 2 }, + { 33, 2 }, + { 33, 2 }, + { 41, 2 }, + { 41, 0 }, + { 33, 4 }, + { 33, 5 }, + { 33, 4 }, + { 33, 5 }, + { 42, 2 }, + { 42, 0 }, + { 33, 3 }, }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -672,7 +694,7 @@ static void yy_reduce( { yygotominor.yy0.assignString( (char*)yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.assignString( 0 ); yymsp[0].minor.yy0.release_this(); } -#line 677 "bitbakeparser.c" +#line 699 "bitbakeparser.c" break; case 4: #line 64 "bitbakeparser.y" @@ -680,7 +702,7 @@ static void yy_reduce( yygotominor.yy0.assignString( (char*)yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.assignString( 0 ); yymsp[0].minor.yy0.release_this(); } -#line 685 "bitbakeparser.c" +#line 707 "bitbakeparser.c" break; case 5: #line 70 "bitbakeparser.y" @@ -689,191 +711,223 @@ static void yy_reduce( yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(3,&yymsp[-3].minor); yy_destructor(4,&yymsp[-1].minor); } -#line 694 "bitbakeparser.c" +#line 716 "bitbakeparser.c" break; case 6: #line 74 "bitbakeparser.y" -{ e_immediate ( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); +{ e_precat( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); e_export( lex, yymsp[-2].minor.yy0.string() ); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(3,&yymsp[-3].minor); yy_destructor(6,&yymsp[-1].minor); } -#line 703 "bitbakeparser.c" +#line 725 "bitbakeparser.c" break; case 7: #line 78 "bitbakeparser.y" -{ e_cond( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); +{ e_postcat( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + e_export( lex, yymsp[-2].minor.yy0.string() ); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(3,&yymsp[-3].minor); yy_destructor(7,&yymsp[-1].minor); } -#line 711 "bitbakeparser.c" +#line 734 "bitbakeparser.c" break; case 8: #line 82 "bitbakeparser.y" -{ e_assign( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); - yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(4,&yymsp[-1].minor); +{ e_immediate ( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + e_export( lex, yymsp[-2].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(3,&yymsp[-3].minor); + yy_destructor(8,&yymsp[-1].minor); } -#line 718 "bitbakeparser.c" +#line 743 "bitbakeparser.c" break; case 9: -#line 85 "bitbakeparser.y" -{ e_prepend( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); - yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(8,&yymsp[-1].minor); +#line 86 "bitbakeparser.y" +{ e_cond( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(3,&yymsp[-3].minor); + yy_destructor(9,&yymsp[-1].minor); } -#line 725 "bitbakeparser.c" +#line 751 "bitbakeparser.c" break; case 10: -#line 88 "bitbakeparser.y" -{ e_append( lex, yymsp[-2].minor.yy0.string() , yymsp[0].minor.yy0.string() ); - yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(9,&yymsp[-1].minor); +#line 90 "bitbakeparser.y" +{ e_assign( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(4,&yymsp[-1].minor); } -#line 732 "bitbakeparser.c" +#line 758 "bitbakeparser.c" break; case 11: -#line 91 "bitbakeparser.y" -{ e_immediate( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); +#line 93 "bitbakeparser.y" +{ e_precat( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(6,&yymsp[-1].minor); } -#line 739 "bitbakeparser.c" +#line 765 "bitbakeparser.c" break; case 12: -#line 94 "bitbakeparser.y" -{ e_cond( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); +#line 96 "bitbakeparser.y" +{ e_postcat( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(7,&yymsp[-1].minor); } -#line 746 "bitbakeparser.c" +#line 772 "bitbakeparser.c" break; case 13: -#line 98 "bitbakeparser.y" -{ e_addtask( lex, yymsp[-4].minor.yy0.string(), yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); - yymsp[-4].minor.yy0.release_this(); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(11,&yymsp[-3].minor); - yy_destructor(12,&yymsp[-1].minor); +#line 99 "bitbakeparser.y" +{ e_prepend( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(10,&yymsp[-1].minor); } -#line 754 "bitbakeparser.c" +#line 779 "bitbakeparser.c" break; case 14: -#line 101 "bitbakeparser.y" -{ e_addtask( lex, yymsp[-4].minor.yy0.string(), yymsp[0].minor.yy0.string(), yymsp[-2].minor.yy0.string()); - yymsp[-4].minor.yy0.release_this(); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(12,&yymsp[-3].minor); - yy_destructor(11,&yymsp[-1].minor); +#line 102 "bitbakeparser.y" +{ e_append( lex, yymsp[-2].minor.yy0.string() , yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(11,&yymsp[-1].minor); } -#line 762 "bitbakeparser.c" +#line 786 "bitbakeparser.c" break; case 15: -#line 104 "bitbakeparser.y" +#line 105 "bitbakeparser.y" +{ e_immediate( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(8,&yymsp[-1].minor); +} +#line 793 "bitbakeparser.c" + break; + case 16: +#line 108 "bitbakeparser.y" +{ e_cond( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(9,&yymsp[-1].minor); +} +#line 800 "bitbakeparser.c" + break; + case 17: +#line 112 "bitbakeparser.y" +{ e_addtask( lex, yymsp[-4].minor.yy0.string(), yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string() ); + yymsp[-4].minor.yy0.release_this(); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(13,&yymsp[-3].minor); + yy_destructor(14,&yymsp[-1].minor); +} +#line 808 "bitbakeparser.c" + break; + case 18: +#line 115 "bitbakeparser.y" +{ e_addtask( lex, yymsp[-4].minor.yy0.string(), yymsp[0].minor.yy0.string(), yymsp[-2].minor.yy0.string()); + yymsp[-4].minor.yy0.release_this(); yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(14,&yymsp[-3].minor); + yy_destructor(13,&yymsp[-1].minor); +} +#line 816 "bitbakeparser.c" + break; + case 19: +#line 118 "bitbakeparser.y" { e_addtask( lex, yymsp[0].minor.yy0.string(), NULL, NULL); yymsp[0].minor.yy0.release_this();} -#line 768 "bitbakeparser.c" +#line 822 "bitbakeparser.c" break; - case 16: -#line 107 "bitbakeparser.y" + case 20: +#line 121 "bitbakeparser.y" { e_addtask( lex, yymsp[-2].minor.yy0.string(), yymsp[0].minor.yy0.string(), NULL); - yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(11,&yymsp[-1].minor); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(13,&yymsp[-1].minor); } -#line 775 "bitbakeparser.c" +#line 829 "bitbakeparser.c" break; - case 17: -#line 110 "bitbakeparser.y" + case 21: +#line 124 "bitbakeparser.y" { e_addtask( lex, yymsp[-2].minor.yy0.string(), NULL, yymsp[0].minor.yy0.string()); - yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(12,&yymsp[-1].minor); + yymsp[-2].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); yy_destructor(14,&yymsp[-1].minor); } -#line 782 "bitbakeparser.c" +#line 836 "bitbakeparser.c" break; - case 21: -#line 117 "bitbakeparser.y" -{ e_addhandler( lex, yymsp[0].minor.yy0.string()); yymsp[0].minor.yy0.release_this (); yy_destructor(14,&yymsp[-1].minor); + case 25: +#line 131 "bitbakeparser.y" +{ e_addhandler( lex, yymsp[0].minor.yy0.string()); yymsp[0].minor.yy0.release_this (); yy_destructor(16,&yymsp[-1].minor); } -#line 788 "bitbakeparser.c" +#line 842 "bitbakeparser.c" break; - case 22: -#line 119 "bitbakeparser.y" + case 26: +#line 133 "bitbakeparser.y" { e_export_func( lex, yymsp[0].minor.yy0.string()); yymsp[0].minor.yy0.release_this(); } -#line 793 "bitbakeparser.c" +#line 847 "bitbakeparser.c" break; - case 26: -#line 124 "bitbakeparser.y" + case 30: +#line 138 "bitbakeparser.y" { e_inherit( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this (); } -#line 798 "bitbakeparser.c" +#line 852 "bitbakeparser.c" break; - case 30: -#line 130 "bitbakeparser.y" -{ e_include( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this(); yy_destructor(19,&yymsp[-1].minor); + case 34: +#line 144 "bitbakeparser.y" +{ e_include( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this(); yy_destructor(21,&yymsp[-1].minor); } -#line 804 "bitbakeparser.c" +#line 858 "bitbakeparser.c" break; - case 31: -#line 133 "bitbakeparser.y" -{ e_require( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this(); yy_destructor(20,&yymsp[-1].minor); + case 35: +#line 147 "bitbakeparser.y" +{ e_require( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this(); yy_destructor(22,&yymsp[-1].minor); } -#line 810 "bitbakeparser.c" +#line 864 "bitbakeparser.c" break; - case 32: -#line 136 "bitbakeparser.y" + case 36: +#line 150 "bitbakeparser.y" { /* concatenate body lines */ yygotominor.yy0.assignString( token_t::concatString(yymsp[-1].minor.yy0.string(), yymsp[0].minor.yy0.string()) ); yymsp[-1].minor.yy0.release_this (); yymsp[0].minor.yy0.release_this (); } -#line 819 "bitbakeparser.c" +#line 873 "bitbakeparser.c" break; - case 33: -#line 141 "bitbakeparser.y" + case 37: +#line 155 "bitbakeparser.y" { yygotominor.yy0.assignString(0); } -#line 824 "bitbakeparser.c" +#line 878 "bitbakeparser.c" break; - case 34: -#line 143 "bitbakeparser.y" + case 38: +#line 157 "bitbakeparser.y" { e_proc( lex, yymsp[-3].minor.yy0.string(), yymsp[-1].minor.yy0.string() ); - yymsp[-3].minor.yy0.release_this(); yymsp[-1].minor.yy0.release_this(); yy_destructor(22,&yymsp[-2].minor); - yy_destructor(23,&yymsp[0].minor); + yymsp[-3].minor.yy0.release_this(); yymsp[-1].minor.yy0.release_this(); yy_destructor(24,&yymsp[-2].minor); + yy_destructor(25,&yymsp[0].minor); } -#line 832 "bitbakeparser.c" +#line 886 "bitbakeparser.c" break; - case 35: -#line 146 "bitbakeparser.y" + case 39: +#line 160 "bitbakeparser.y" { e_proc_python ( lex, yymsp[-3].minor.yy0.string(), yymsp[-1].minor.yy0.string() ); - yymsp[-3].minor.yy0.release_this(); yymsp[-1].minor.yy0.release_this(); yy_destructor(24,&yymsp[-4].minor); - yy_destructor(22,&yymsp[-2].minor); - yy_destructor(23,&yymsp[0].minor); + yymsp[-3].minor.yy0.release_this(); yymsp[-1].minor.yy0.release_this(); yy_destructor(26,&yymsp[-4].minor); + yy_destructor(24,&yymsp[-2].minor); + yy_destructor(25,&yymsp[0].minor); } -#line 841 "bitbakeparser.c" +#line 895 "bitbakeparser.c" break; - case 36: -#line 149 "bitbakeparser.y" + case 40: +#line 163 "bitbakeparser.y" { e_proc_python( lex, NULL, yymsp[-1].minor.yy0.string()); - yymsp[-1].minor.yy0.release_this (); yy_destructor(24,&yymsp[-3].minor); - yy_destructor(22,&yymsp[-2].minor); - yy_destructor(23,&yymsp[0].minor); + yymsp[-1].minor.yy0.release_this (); yy_destructor(26,&yymsp[-3].minor); + yy_destructor(24,&yymsp[-2].minor); + yy_destructor(25,&yymsp[0].minor); } -#line 850 "bitbakeparser.c" +#line 904 "bitbakeparser.c" break; - case 37: -#line 153 "bitbakeparser.y" + case 41: +#line 167 "bitbakeparser.y" { e_proc_fakeroot( lex, yymsp[-3].minor.yy0.string(), yymsp[-1].minor.yy0.string() ); - yymsp[-3].minor.yy0.release_this (); yymsp[-1].minor.yy0.release_this (); yy_destructor(25,&yymsp[-4].minor); - yy_destructor(22,&yymsp[-2].minor); - yy_destructor(23,&yymsp[0].minor); + yymsp[-3].minor.yy0.release_this (); yymsp[-1].minor.yy0.release_this (); yy_destructor(27,&yymsp[-4].minor); + yy_destructor(24,&yymsp[-2].minor); + yy_destructor(25,&yymsp[0].minor); } -#line 859 "bitbakeparser.c" +#line 913 "bitbakeparser.c" break; - case 38: -#line 157 "bitbakeparser.y" + case 42: +#line 171 "bitbakeparser.y" { /* concatenate body lines */ yygotominor.yy0.assignString( token_t::concatString(yymsp[-1].minor.yy0.string(), yymsp[0].minor.yy0.string()) ); yymsp[-1].minor.yy0.release_this (); yymsp[0].minor.yy0.release_this (); } -#line 867 "bitbakeparser.c" +#line 921 "bitbakeparser.c" break; - case 39: -#line 161 "bitbakeparser.y" + case 43: +#line 175 "bitbakeparser.y" { yygotominor.yy0.assignString( 0 ); } -#line 872 "bitbakeparser.c" +#line 926 "bitbakeparser.c" break; - case 40: -#line 163 "bitbakeparser.y" + case 44: +#line 177 "bitbakeparser.y" { e_def( lex, yymsp[-2].minor.yy0.string(), yymsp[-1].minor.yy0.string(), yymsp[0].minor.yy0.string()); yymsp[-2].minor.yy0.release_this(); yymsp[-1].minor.yy0.release_this(); yymsp[0].minor.yy0.release_this(); } -#line 878 "bitbakeparser.c" +#line 932 "bitbakeparser.c" break; }; yygoto = yyRuleInfo[yyruleno].lhs; @@ -932,7 +986,7 @@ static void yy_syntax_error( #define TOKEN (yyminor.yy0) #line 52 "bitbakeparser.y" e_parse_error( lex ); -#line 938 "bitbakeparser.c" +#line 992 "bitbakeparser.c" bbparseARG_STORE; /* Suppress warning about unused %extra_argument variable */ } diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.h b/bitbake/lib/bb/parse/parse_c/bitbakeparser.h index 2e51702be8..a2c9aa367d 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.h +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.h @@ -3,25 +3,27 @@ #define T_EXPORT 3 #define T_OP_ASSIGN 4 #define T_STRING 5 -#define T_OP_IMMEDIATE 6 -#define T_OP_COND 7 -#define T_OP_PREPEND 8 -#define T_OP_APPEND 9 -#define T_TSYMBOL 10 -#define T_BEFORE 11 -#define T_AFTER 12 -#define T_ADDTASK 13 -#define T_ADDHANDLER 14 -#define T_FSYMBOL 15 -#define T_EXPORT_FUNC 16 -#define T_ISYMBOL 17 -#define T_INHERIT 18 -#define T_INCLUDE 19 -#define T_REQUIRE 20 -#define T_PROC_BODY 21 -#define T_PROC_OPEN 22 -#define T_PROC_CLOSE 23 -#define T_PYTHON 24 -#define T_FAKEROOT 25 -#define T_DEF_BODY 26 -#define T_DEF_ARGS 27 +#define T_OP_PREDOT 6 +#define T_OP_POSTDOT 7 +#define T_OP_IMMEDIATE 8 +#define T_OP_COND 9 +#define T_OP_PREPEND 10 +#define T_OP_APPEND 11 +#define T_TSYMBOL 12 +#define T_BEFORE 13 +#define T_AFTER 14 +#define T_ADDTASK 15 +#define T_ADDHANDLER 16 +#define T_FSYMBOL 17 +#define T_EXPORT_FUNC 18 +#define T_ISYMBOL 19 +#define T_INHERIT 20 +#define T_INCLUDE 21 +#define T_REQUIRE 22 +#define T_PROC_BODY 23 +#define T_PROC_OPEN 24 +#define T_PROC_CLOSE 25 +#define T_PYTHON 26 +#define T_FAKEROOT 27 +#define T_DEF_BODY 28 +#define T_DEF_ARGS 29 diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y index 252d87792f..c18e53543b 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y @@ -70,6 +70,14 @@ statement ::= EXPORT variable(s) OP_ASSIGN STRING(v). { e_assign( lex, s.string(), v.string() ); e_export( lex, s.string() ); s.release_this(); v.release_this(); } +statement ::= EXPORT variable(s) OP_PREDOT STRING(v). + { e_precat( lex, s.string(), v.string() ); + e_export( lex, s.string() ); + s.release_this(); v.release_this(); } +statement ::= EXPORT variable(s) OP_POSTDOT STRING(v). + { e_postcat( lex, s.string(), v.string() ); + e_export( lex, s.string() ); + s.release_this(); v.release_this(); } statement ::= EXPORT variable(s) OP_IMMEDIATE STRING(v). { e_immediate ( lex, s.string(), v.string() ); e_export( lex, s.string() ); @@ -81,6 +89,12 @@ statement ::= EXPORT variable(s) OP_COND STRING(v). statement ::= variable(s) OP_ASSIGN STRING(v). { e_assign( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } +statement ::= variable(s) OP_PREDOT STRING(v). + { e_precat( lex, s.string(), v.string() ); + s.release_this(); v.release_this(); } +statement ::= variable(s) OP_POSTDOT STRING(v). + { e_postcat( lex, s.string(), v.string() ); + s.release_this(); v.release_this(); } statement ::= variable(s) OP_PREPEND STRING(v). { e_prepend( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } diff --git a/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc b/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc index 8e95fd97c8..43dad12d39 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc +++ b/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc @@ -355,8 +355,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 45 -#define YY_END_OF_BUFFER 46 +#define YY_NUM_RULES 47 +#define YY_END_OF_BUFFER 48 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -364,96 +364,98 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[798] = +static yyconst flex_int16_t yy_accept[813] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 24, 24, 0, 0, - 0, 0, 46, 44, 43, 43, 44, 44, 44, 44, - 44, 4, 44, 33, 33, 33, 33, 33, 33, 33, - 33, 33, 26, 26, 26, 26, 26, 26, 44, 43, - 28, 43, 44, 44, 44, 27, 4, 44, 44, 44, - 44, 44, 44, 31, 31, 30, 31, 31, 31, 31, - 31, 4, 31, 31, 31, 31, 31, 31, 41, 36, - 36, 36, 36, 36, 36, 44, 38, 38, 38, 38, - 38, 38, 42, 37, 37, 37, 37, 37, 37, 44, - - 39, 39, 39, 39, 39, 39, 24, 24, 24, 24, - 24, 24, 24, 4, 24, 24, 24, 24, 24, 24, - 23, 9, 43, 10, 9, 44, 9, 44, 9, 9, - 9, 4, 9, 9, 9, 9, 9, 9, 9, 40, - 35, 35, 35, 35, 35, 35, 35, 0, 32, 34, - 0, 0, 1, 3, 2, 5, 0, 33, 0, 33, - 33, 33, 33, 33, 33, 33, 33, 26, 26, 26, - 26, 26, 26, 0, 27, 0, 28, 0, 27, 0, - 0, 1, 2, 5, 0, 0, 0, 0, 0, 0, - 0, 29, 0, 0, 0, 0, 0, 36, 36, 36, - - 36, 36, 36, 0, 0, 38, 38, 38, 38, 38, - 38, 37, 37, 37, 37, 37, 37, 0, 0, 39, - 39, 39, 39, 39, 39, 24, 24, 24, 24, 24, - 24, 1, 3, 2, 5, 24, 24, 24, 24, 24, - 23, 23, 9, 0, 9, 0, 10, 0, 7, 0, - 9, 0, 9, 0, 8, 0, 0, 9, 1, 3, - 2, 5, 9, 6, 9, 9, 9, 9, 35, 35, - 35, 35, 35, 35, 35, 35, 34, 0, 22, 0, - 0, 34, 33, 33, 25, 33, 33, 33, 33, 33, - 33, 26, 26, 25, 26, 26, 26, 0, 22, 0, - - 0, 25, 0, 0, 0, 0, 0, 25, 0, 0, - 0, 36, 36, 25, 36, 36, 36, 0, 0, 38, - 38, 25, 38, 38, 38, 37, 37, 25, 37, 37, - 37, 0, 0, 39, 39, 25, 39, 39, 39, 24, - 22, 24, 24, 24, 24, 24, 24, 32, 0, 9, - 9, 6, 9, 9, 9, 9, 9, 35, 35, 35, - 35, 25, 35, 35, 35, 22, 22, 0, 33, 33, - 33, 33, 33, 33, 33, 33, 33, 26, 26, 26, - 26, 26, 26, 22, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 36, 36, 36, 36, - - 36, 36, 0, 38, 0, 38, 38, 38, 38, 38, - 38, 37, 37, 37, 37, 37, 37, 0, 39, 0, - 39, 39, 39, 39, 39, 39, 22, 22, 24, 24, - 24, 24, 24, 24, 22, 9, 9, 9, 9, 9, - 9, 35, 35, 35, 35, 35, 35, 35, 35, 0, - 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, - 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 36, 36, - 36, 36, 36, 36, 0, 38, 38, 38, 38, 38, - 38, 38, 37, 37, 37, 37, 37, 37, 0, 39, - - 39, 39, 39, 39, 39, 39, 24, 24, 24, 24, - 24, 24, 9, 9, 9, 9, 9, 9, 35, 35, - 35, 18, 35, 35, 35, 35, 33, 33, 33, 19, - 33, 33, 33, 21, 33, 26, 26, 26, 26, 26, - 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 36, 36, 36, 36, 36, 38, - 38, 38, 38, 38, 38, 37, 37, 37, 37, 37, - 37, 39, 39, 39, 39, 39, 39, 24, 24, 24, - 24, 24, 24, 9, 9, 9, 9, 9, 9, 35, - 35, 35, 17, 35, 35, 35, 33, 33, 14, 33, - - 11, 13, 12, 26, 26, 14, 11, 13, 12, 0, - 0, 14, 11, 13, 12, 0, 0, 14, 11, 13, - 12, 36, 36, 14, 11, 13, 12, 38, 38, 14, - 11, 13, 12, 37, 37, 14, 11, 13, 12, 39, - 39, 14, 11, 13, 12, 24, 24, 14, 11, 13, - 12, 9, 9, 9, 9, 9, 9, 35, 35, 14, - 11, 13, 12, 33, 33, 20, 26, 26, 0, 0, - 0, 0, 36, 36, 38, 38, 37, 37, 39, 39, - 24, 24, 9, 9, 35, 35, 33, 33, 26, 26, - 0, 0, 0, 0, 36, 36, 38, 38, 37, 37, - - 39, 39, 24, 24, 9, 9, 35, 35, 33, 15, - 26, 15, 0, 15, 0, 15, 36, 15, 38, 15, - 37, 15, 39, 15, 24, 15, 9, 9, 35, 15, - 33, 26, 0, 0, 36, 38, 37, 39, 24, 9, - 35, 33, 26, 0, 0, 36, 38, 37, 39, 24, - 9, 35, 33, 26, 0, 0, 36, 38, 37, 39, - 24, 9, 35, 33, 26, 0, 0, 36, 38, 37, - 39, 24, 9, 35, 33, 26, 0, 0, 36, 38, - 37, 39, 24, 9, 35, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 9, 16, 0 + 0, 0, 0, 0, 0, 0, 26, 26, 0, 0, + 0, 0, 48, 46, 45, 45, 46, 46, 46, 46, + 46, 46, 4, 46, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 28, 28, 28, 28, 28, 28, 46, + 45, 30, 45, 46, 46, 46, 46, 29, 4, 46, + 46, 46, 46, 46, 46, 33, 33, 32, 33, 33, + 33, 33, 33, 33, 4, 33, 33, 33, 33, 33, + 33, 43, 38, 38, 38, 38, 38, 38, 46, 40, + 40, 40, 40, 40, 40, 40, 44, 39, 39, 39, + + 39, 39, 39, 46, 41, 41, 41, 41, 41, 41, + 41, 26, 26, 26, 26, 26, 26, 26, 26, 4, + 26, 26, 26, 26, 26, 26, 25, 11, 45, 12, + 11, 46, 11, 46, 11, 11, 11, 11, 4, 11, + 11, 11, 11, 11, 11, 11, 42, 37, 37, 37, + 37, 37, 37, 37, 0, 34, 36, 0, 0, 1, + 5, 3, 2, 6, 7, 0, 35, 0, 35, 35, + 35, 35, 35, 35, 35, 35, 28, 28, 28, 28, + 28, 28, 0, 29, 0, 30, 0, 29, 0, 0, + 1, 5, 2, 6, 7, 0, 0, 0, 0, 0, + + 0, 0, 31, 0, 0, 0, 0, 0, 38, 38, + 38, 38, 38, 38, 0, 0, 40, 40, 40, 40, + 40, 40, 39, 39, 39, 39, 39, 39, 0, 0, + 41, 41, 41, 41, 41, 41, 26, 26, 26, 26, + 26, 26, 1, 5, 3, 2, 6, 7, 26, 26, + 26, 26, 26, 25, 25, 11, 0, 11, 0, 12, + 0, 9, 0, 11, 0, 11, 0, 10, 0, 0, + 11, 1, 5, 3, 2, 6, 7, 11, 8, 11, + 11, 11, 11, 37, 37, 37, 37, 37, 37, 37, + 37, 36, 0, 24, 0, 0, 36, 35, 35, 27, + + 35, 35, 35, 35, 35, 35, 28, 28, 27, 28, + 28, 28, 0, 24, 0, 0, 27, 0, 0, 0, + 0, 0, 27, 0, 0, 0, 38, 38, 27, 38, + 38, 38, 0, 0, 40, 40, 27, 40, 40, 40, + 39, 39, 27, 39, 39, 39, 0, 0, 41, 41, + 27, 41, 41, 41, 26, 24, 26, 26, 26, 26, + 26, 26, 34, 0, 11, 11, 8, 11, 11, 11, + 11, 11, 37, 37, 37, 37, 27, 37, 37, 37, + 24, 24, 0, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 28, 28, 28, 28, 28, 28, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 38, 38, 38, 38, 38, 38, 0, 40, 0, + 40, 40, 40, 40, 40, 40, 39, 39, 39, 39, + 39, 39, 0, 41, 0, 41, 41, 41, 41, 41, + 41, 24, 24, 26, 26, 26, 26, 26, 26, 24, + 11, 11, 11, 11, 11, 11, 37, 37, 37, 37, + 37, 37, 37, 37, 0, 36, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 28, 28, 28, 28, 28, + 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 38, 38, 38, 38, 38, 38, 0, + + 40, 40, 40, 40, 40, 40, 40, 39, 39, 39, + 39, 39, 39, 0, 41, 41, 41, 41, 41, 41, + 41, 26, 26, 26, 26, 26, 26, 11, 11, 11, + 11, 11, 11, 37, 37, 37, 20, 37, 37, 37, + 37, 35, 35, 35, 21, 35, 35, 35, 23, 35, + 28, 28, 28, 28, 28, 28, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 38, 38, + 38, 38, 38, 38, 40, 40, 40, 40, 40, 40, + 39, 39, 39, 39, 39, 39, 41, 41, 41, 41, + 41, 41, 26, 26, 26, 26, 26, 26, 11, 11, + + 11, 11, 11, 11, 37, 37, 37, 19, 37, 37, + 37, 35, 35, 16, 35, 13, 15, 14, 28, 28, + 16, 13, 15, 14, 0, 0, 16, 13, 15, 14, + 0, 0, 16, 13, 15, 14, 38, 38, 16, 13, + 15, 14, 40, 40, 16, 13, 15, 14, 39, 39, + 16, 13, 15, 14, 41, 41, 16, 13, 15, 14, + 26, 26, 16, 13, 15, 14, 11, 11, 11, 11, + 11, 11, 37, 37, 16, 13, 15, 14, 35, 35, + 22, 28, 28, 0, 0, 0, 0, 38, 38, 40, + 40, 39, 39, 41, 41, 26, 26, 11, 11, 37, + + 37, 35, 35, 28, 28, 0, 0, 0, 0, 38, + 38, 40, 40, 39, 39, 41, 41, 26, 26, 11, + 11, 37, 37, 35, 17, 28, 17, 0, 17, 0, + 17, 38, 17, 40, 17, 39, 17, 41, 17, 26, + 17, 11, 11, 37, 17, 35, 28, 0, 0, 38, + 40, 39, 41, 26, 11, 37, 35, 28, 0, 0, + 38, 40, 39, 41, 26, 11, 37, 35, 28, 0, + 0, 38, 40, 39, 41, 26, 11, 37, 35, 28, + 0, 0, 38, 40, 39, 41, 26, 11, 37, 35, + 28, 0, 0, 38, 40, 39, 41, 26, 11, 37, + + 18, 18, 18, 18, 18, 18, 18, 18, 18, 11, + 18, 0 } ; static yyconst flex_int32_t yy_ec[256] = @@ -491,454 +493,472 @@ static yyconst flex_int32_t yy_ec[256] = static yyconst flex_int32_t yy_meta[59] = { 0, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, - 5, 6, 5, 5, 7, 8, 1, 1, 1, 9, + 5, 6, 5, 5, 7, 8, 1, 7, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 1, 11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1, 12 } ; -static yyconst flex_int16_t yy_base[832] = +static yyconst flex_int16_t yy_base[847] = { 0, 0, 0, 58, 0, 115, 165, 215, 265, 316, 0, 374, 0, 432, 0, 490, 0, 547, 604, 661, 711, - 762, 0, 2156, 2157, 2157, 2157, 2152, 0, 118, 2136, - 2135, 2141, 2133, 115, 118, 116, 120, 124, 140, 131, - 129, 139, 0, 2118, 2109, 2107, 2100, 2105, 2128, 127, - 2157, 2127, 137, 179, 124, 2125, 128, 173, 126, 146, - 153, 118, 158, 2157, 190, 2157, 2157, 2139, 193, 2123, - 2122, 2128, 2120, 2105, 2096, 2094, 2087, 2092, 2157, 0, - 2100, 2091, 2089, 2082, 2087, 2070, 2119, 181, 190, 194, - 153, 197, 2157, 0, 2093, 2084, 2082, 2075, 2080, 2063, - - 2112, 191, 199, 200, 201, 203, 2115, 2114, 2113, 2112, - 212, 209, 222, 217, 228, 226, 233, 208, 239, 240, - 248, 255, 251, 2111, 270, 251, 552, 254, 565, 575, - 577, 622, 627, 626, 634, 612, 669, 684, 691, 2157, - 0, 2081, 205, 2071, 2070, 2063, 2068, 2105, 2157, 257, - 289, 559, 2157, 2157, 2157, 2157, 2050, 263, 2071, 270, - 273, 555, 545, 556, 642, 585, 569, 0, 2078, 2064, - 2061, 222, 2052, 2084, 2157, 290, 2157, 291, 2097, 674, - 680, 2082, 2081, 2080, 283, 564, 554, 608, 262, 2093, - 312, 2157, 2068, 2054, 2051, 529, 2042, 0, 2064, 2050, - - 2047, 611, 2038, 0, 2030, 2079, 646, 650, 652, 695, - 593, 0, 2058, 2044, 2041, 661, 2032, 0, 2024, 2073, - 680, 681, 699, 701, 702, 2076, 2075, 2074, 2073, 733, - 819, 2072, 2071, 2070, 2069, 720, 600, 708, 820, 821, - 724, 2068, 823, 824, 831, 751, 2067, 822, 830, 835, - 839, 843, 847, 845, 846, 858, 880, 870, 881, 889, - 891, 898, 903, 2067, 905, 914, 916, 926, 0, 2041, - 2027, 2013, 2023, 2022, 703, 2013, 902, 841, 754, 0, - 2027, 2157, 910, 919, 905, 913, 933, 934, 937, 940, - 935, 2035, 258, 0, 2014, 2018, 2004, 947, 979, 732, - - 934, 2040, 912, 843, 707, 2030, 910, 2157, 2009, 2013, - 1999, 2026, 922, 0, 2005, 2009, 1995, 1990, 0, 861, - 926, 2040, 855, 947, 964, 2020, 941, 0, 1999, 2003, - 1989, 1984, 0, 979, 950, 2034, 978, 984, 983, 995, - 757, 989, 992, 2037, 996, 571, 997, 1004, 1005, 1014, - 1006, 2037, 1021, 1025, 1026, 1039, 1041, 2012, 1010, 1996, - 1988, 0, 1989, 1993, 1979, 999, 2029, 1973, 1043, 1049, - 1050, 1051, 1058, 1059, 1060, 1070, 1061, 2002, 1992, 1991, - 1973, 1975, 1981, 1087, 1053, 1061, 1062, 813, 1003, 1044, - 1996, 1986, 1985, 1967, 1969, 1975, 1990, 1980, 1979, 1961, - - 1963, 1969, 1954, 2004, 1952, 867, 1078, 1089, 1062, 1090, - 1093, 1981, 1971, 1970, 1952, 1954, 1960, 1945, 1995, 1943, - 1094, 1099, 1101, 1100, 1105, 1103, 1117, 1997, 1111, 1114, - 1118, 1120, 1121, 1122, 1125, 1141, 1127, 1155, 1160, 1165, - 1174, 1971, 1961, 1960, 1945, 1944, 1940, 1942, 1948, 1933, - 1138, 1151, 1170, 1145, 1173, 1176, 1179, 1178, 1180, 1188, - 1960, 1942, 1936, 1947, 1942, 1934, 1114, 1173, 1136, 1183, - 1181, 1179, 1954, 1936, 1930, 1941, 1936, 1928, 1948, 1930, - 1924, 1935, 1930, 1922, 1914, 1964, 1198, 1184, 1141, 830, - 1194, 1195, 1940, 1922, 1916, 1927, 1922, 1914, 1906, 1956, - - 1203, 1197, 1200, 1208, 1222, 1225, 1231, 1232, 1233, 1234, - 1237, 1238, 1248, 1249, 1257, 1265, 1267, 1282, 1932, 1914, - 1908, 0, 1918, 1918, 1913, 1905, 1235, 1253, 1270, 1273, - 1281, 1285, 1287, 1288, 1290, 1919, 1914, 1908, 1911, 1898, - 1909, 1228, 1285, 1283, 1281, 1290, 1291, 1913, 1908, 1902, - 1905, 1892, 1903, 1907, 1902, 1896, 1899, 1886, 1897, 1303, - 1297, 1305, 1306, 1310, 1312, 1901, 1896, 1890, 1893, 1880, - 1891, 1320, 1317, 1323, 1328, 1327, 1329, 1335, 1338, 1339, - 1341, 1342, 1345, 1347, 1356, 1357, 1371, 1392, 1396, 1895, - 1890, 1884, 0, 1887, 1874, 1885, 1344, 1339, 1359, 1380, - - 1381, 1382, 1386, 1902, 1878, 0, 0, 0, 0, 1117, - 1357, 1906, 1905, 1904, 1903, 1896, 1872, 2157, 2157, 2157, - 2157, 1894, 1870, 0, 0, 0, 0, 1240, 1353, 1908, - 1907, 1906, 1905, 1888, 1864, 0, 0, 0, 0, 1399, - 1400, 1902, 1901, 1900, 1899, 1405, 1372, 1902, 1901, 1900, - 1899, 1415, 1419, 1427, 1434, 1439, 1446, 1878, 1854, 0, - 0, 0, 0, 1424, 1433, 1427, 1867, 1856, 1394, 1426, - 1863, 1849, 1858, 1845, 1445, 1409, 1851, 1840, 1451, 1449, - 1456, 1459, 1467, 1476, 1847, 1833, 1463, 1456, 1848, 1819, - 1125, 1454, 1841, 1814, 1837, 1807, 1470, 1457, 1827, 1795, - - 1472, 1476, 1488, 1482, 1501, 1510, 1809, 1782, 1495, 1486, - 1789, 0, 1503, 1792, 1776, 2157, 1747, 0, 1504, 1756, - 1736, 0, 1515, 1745, 1483, 1712, 1529, 1537, 1690, 0, - 1516, 1675, 1513, 1610, 1609, 1522, 1608, 1525, 1491, 1546, - 1607, 1533, 1612, 1475, 1611, 1609, 1534, 1608, 1540, 1535, - 1560, 1607, 1546, 1604, 1232, 1602, 1601, 1549, 1599, 1560, - 1557, 1580, 1597, 1562, 1596, 1553, 1595, 1593, 1566, 1592, - 1567, 1574, 1588, 1591, 1574, 1581, 1226, 1575, 1572, 1582, - 1485, 1590, 1595, 1600, 1381, 1593, 0, 1392, 2157, 0, - 1347, 0, 1029, 1018, 1607, 0, 2157, 1641, 1653, 1665, - - 1677, 1689, 893, 1698, 1704, 1713, 1725, 1737, 1745, 1751, - 1756, 1762, 1771, 1783, 1795, 1807, 1819, 1831, 1839, 1845, - 1848, 730, 581, 550, 1855, 289, 1863, 286, 1871, 1879, - 1887 + 762, 0, 2308, 2309, 2309, 2309, 2304, 0, 118, 2288, + 2287, 2286, 111, 2285, 116, 124, 120, 129, 131, 128, + 144, 139, 140, 0, 2270, 2261, 2259, 2252, 2257, 2280, + 137, 2309, 2279, 127, 183, 124, 171, 2277, 187, 179, + 126, 163, 158, 131, 173, 2309, 204, 2309, 2309, 2291, + 210, 2275, 2274, 2273, 197, 2272, 2257, 2248, 2246, 2239, + 2244, 2309, 0, 2252, 2243, 2241, 2234, 2239, 2222, 218, + 220, 221, 223, 224, 228, 236, 2309, 0, 2246, 2237, + + 2235, 2228, 2233, 2216, 233, 238, 240, 255, 263, 242, + 273, 2269, 2268, 2267, 2266, 283, 285, 289, 293, 287, + 294, 160, 210, 207, 147, 220, 297, 552, 560, 2265, + 565, 210, 569, 544, 580, 622, 627, 634, 623, 669, + 689, 819, 684, 702, 821, 823, 2309, 0, 2235, 266, + 2225, 2224, 2217, 2222, 2259, 2309, 548, 566, 581, 2309, + 2309, 2309, 2309, 2309, 2309, 2204, 568, 2225, 626, 610, + 640, 651, 699, 823, 678, 702, 0, 2232, 2218, 2215, + 550, 2206, 2238, 2309, 577, 2309, 261, 2251, 594, 830, + 2236, 2235, 2234, 2233, 2232, 575, 580, 634, 710, 599, + + 2245, 735, 2309, 2220, 2206, 2203, 703, 2194, 0, 2216, + 2202, 2199, 711, 2190, 0, 2182, 681, 827, 830, 831, + 826, 828, 0, 2211, 2197, 2194, 717, 2185, 0, 2177, + 740, 832, 834, 833, 853, 854, 2230, 2229, 2228, 2227, + 874, 840, 2226, 2225, 2224, 2223, 2222, 2221, 592, 254, + 651, 855, 833, 737, 2220, 877, 897, 898, 878, 2219, + 881, 883, 886, 905, 916, 920, 700, 859, 906, 925, + 936, 940, 941, 950, 955, 960, 964, 974, 2219, 975, + 983, 994, 995, 0, 2193, 2179, 2165, 2175, 2174, 718, + 2165, 883, 910, 934, 0, 2179, 2309, 979, 971, 940, + + 974, 954, 985, 999, 983, 1003, 2187, 968, 0, 2166, + 2170, 2156, 1017, 1036, 583, 1003, 2192, 996, 685, 917, + 2182, 998, 2309, 2161, 2165, 2151, 2178, 1001, 0, 2157, + 2161, 2147, 2142, 0, 1040, 1041, 946, 1042, 1045, 1043, + 2173, 1012, 0, 2152, 2156, 2142, 2137, 0, 1055, 1057, + 1060, 1061, 1062, 1064, 1074, 1087, 1067, 1069, 2191, 1080, + 1082, 687, 1090, 1094, 1103, 1112, 2191, 1111, 1125, 1127, + 1134, 1142, 2166, 1048, 2150, 2142, 0, 2143, 2147, 2133, + 1138, 2183, 2127, 1127, 1141, 1146, 1136, 1149, 1151, 1155, + 1156, 1158, 2156, 2146, 2145, 2127, 2129, 2135, 1164, 1087, + + 1006, 1135, 1132, 595, 912, 2150, 2140, 2139, 2121, 2123, + 2129, 2144, 2134, 2133, 2115, 2117, 2123, 2108, 1183, 2107, + 1185, 1190, 1191, 1192, 1200, 1204, 2136, 2126, 2125, 2107, + 2109, 2115, 2100, 1205, 2099, 1207, 1208, 1212, 1213, 1214, + 1222, 1168, 2153, 923, 1084, 1213, 1182, 1106, 1190, 1236, + 1250, 1251, 1252, 1266, 1267, 1271, 2127, 2117, 2116, 2101, + 2100, 2096, 2098, 2104, 2089, 1210, 1257, 1230, 1273, 1274, + 1275, 1276, 1284, 1286, 1288, 2116, 2098, 2092, 2103, 2098, + 2090, 1280, 1177, 1244, 1282, 1285, 1275, 2110, 2092, 2086, + 2097, 2092, 2084, 2104, 2086, 2080, 2091, 2086, 2078, 2070, + + 1296, 1306, 1323, 1324, 1325, 1327, 1328, 2097, 2079, 2073, + 2084, 2079, 2071, 2063, 1330, 1331, 1333, 1337, 1345, 1340, + 1346, 1347, 1309, 1259, 1351, 1354, 1356, 1370, 1385, 1394, + 1401, 1403, 1408, 2090, 2072, 2066, 0, 2076, 2076, 2071, + 2063, 1359, 1361, 1379, 1355, 1407, 1410, 1411, 1415, 1416, + 2077, 2072, 2066, 2069, 2056, 2067, 1398, 1343, 1408, 1404, + 643, 1409, 2071, 2066, 2060, 2063, 2050, 2061, 2065, 2060, + 2054, 2057, 2044, 2055, 1420, 1445, 1413, 1447, 1453, 1454, + 2059, 2054, 2047, 2050, 2035, 2043, 1455, 1459, 1460, 1461, + 1462, 1463, 1471, 1436, 1430, 1192, 1433, 1479, 1482, 1492, + + 1506, 1519, 1520, 1528, 2047, 2040, 2031, 0, 2034, 2019, + 2027, 1486, 1496, 1505, 1506, 1510, 1516, 1524, 2044, 2018, + 0, 0, 0, 0, 1281, 1517, 2043, 2042, 2039, 2035, + 2023, 1994, 2309, 2309, 2309, 2309, 2005, 1981, 0, 0, + 0, 0, 1538, 1528, 1530, 1534, 1537, 1540, 1981, 1957, + 0, 0, 0, 0, 1557, 1558, 1559, 1560, 1561, 1563, + 1568, 1547, 1988, 1959, 1954, 1948, 1580, 1581, 1582, 1590, + 1592, 1594, 1923, 1863, 0, 0, 0, 0, 1598, 1599, + 1600, 1874, 1858, 1350, 1584, 1803, 1792, 1801, 1790, 1603, + 1601, 1799, 1788, 1604, 1602, 1610, 1609, 1643, 1644, 1797, + + 1786, 1611, 1630, 1800, 1773, 1010, 1606, 1798, 1771, 1795, + 1768, 1640, 1646, 1793, 1766, 1648, 1649, 1614, 1379, 1667, + 1674, 1791, 1764, 1647, 1653, 1793, 0, 1352, 1796, 1791, + 2309, 1790, 0, 1677, 1652, 1789, 0, 1681, 1676, 1480, + 1805, 1685, 1702, 1786, 0, 1682, 1775, 1679, 1774, 1769, + 1696, 1768, 1698, 1688, 1715, 1765, 1706, 1765, 1472, 1763, + 1757, 1714, 1753, 1717, 1719, 1729, 1703, 1722, 1685, 1645, + 1604, 1546, 1726, 1466, 1733, 1635, 1752, 1403, 1739, 1349, + 1725, 1269, 1222, 1740, 1217, 1749, 1758, 1768, 1155, 1755, + 1148, 1481, 1096, 1001, 1761, 866, 1762, 1763, 1792, 834, + + 1768, 0, 742, 2309, 0, 1764, 0, 1778, 678, 1801, + 0, 2309, 1835, 1847, 1859, 1871, 1883, 550, 1892, 1898, + 1907, 1919, 1931, 1939, 1945, 1950, 1956, 1965, 1977, 1989, + 2001, 2013, 2025, 2033, 2039, 2042, 306, 304, 301, 2049, + 213, 2057, 136, 2065, 2073, 2081 } ; -static yyconst flex_int16_t yy_def[832] = +static yyconst flex_int16_t yy_def[847] = { 0, - 797, 1, 797, 3, 798, 798, 799, 799, 797, 9, - 797, 11, 797, 13, 797, 15, 800, 800, 801, 801, - 797, 21, 797, 797, 797, 797, 802, 803, 797, 797, - 797, 797, 797, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 805, 805, 805, 805, 805, 805, 806, 806, - 797, 806, 807, 806, 806, 797, 806, 806, 806, 806, - 806, 806, 806, 797, 808, 797, 797, 802, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 809, - 809, 809, 809, 809, 809, 797, 810, 810, 810, 810, - 810, 810, 797, 811, 811, 811, 811, 811, 811, 797, - - 812, 812, 812, 812, 812, 812, 813, 813, 813, 814, - 813, 813, 813, 813, 813, 813, 813, 813, 813, 813, - 797, 815, 797, 797, 815, 816, 817, 818, 815, 815, - 815, 815, 815, 815, 815, 815, 815, 815, 815, 797, - 819, 819, 819, 819, 819, 819, 819, 802, 797, 820, - 797, 797, 797, 797, 797, 797, 797, 804, 821, 804, - 804, 804, 804, 804, 804, 804, 804, 805, 805, 805, - 805, 805, 805, 806, 797, 806, 797, 807, 802, 806, - 806, 806, 806, 806, 806, 806, 806, 806, 806, 808, - 808, 797, 797, 797, 797, 797, 797, 809, 809, 809, - - 809, 809, 809, 822, 797, 810, 810, 810, 810, 810, - 810, 811, 811, 811, 811, 811, 811, 823, 797, 812, - 812, 812, 812, 812, 812, 813, 797, 814, 797, 813, - 813, 813, 813, 813, 813, 813, 813, 813, 813, 813, - 797, 797, 815, 815, 815, 797, 797, 816, 816, 816, - 817, 817, 817, 818, 818, 818, 815, 815, 815, 815, - 815, 815, 815, 797, 815, 815, 815, 815, 819, 819, - 819, 819, 819, 819, 819, 819, 820, 797, 797, 824, - 821, 797, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 805, 805, 805, 805, 805, 805, 806, 806, 806, - - 806, 806, 806, 806, 806, 797, 797, 797, 797, 797, - 797, 809, 809, 809, 809, 809, 809, 825, 826, 810, - 810, 810, 810, 810, 810, 811, 811, 811, 811, 811, - 811, 827, 828, 812, 812, 812, 812, 812, 812, 813, - 813, 813, 813, 813, 813, 813, 813, 815, 815, 815, - 815, 797, 815, 815, 815, 815, 815, 819, 819, 819, - 819, 819, 819, 819, 819, 797, 797, 829, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 805, 805, 805, - 805, 805, 805, 806, 806, 806, 806, 806, 806, 806, - 797, 797, 797, 797, 797, 797, 809, 809, 809, 809, - - 809, 809, 825, 810, 830, 810, 810, 810, 810, 810, - 810, 811, 811, 811, 811, 811, 811, 827, 812, 831, - 812, 812, 812, 812, 812, 812, 813, 797, 813, 813, - 813, 813, 813, 813, 815, 815, 815, 815, 815, 815, - 815, 819, 819, 819, 819, 819, 819, 819, 819, 829, - 820, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 805, 805, 805, 805, 805, 805, 806, 806, 806, 806, - 806, 806, 797, 797, 797, 797, 797, 797, 809, 809, - 809, 809, 809, 809, 830, 810, 810, 810, 810, 810, - 810, 810, 811, 811, 811, 811, 811, 811, 831, 812, - - 812, 812, 812, 812, 812, 812, 813, 813, 813, 813, - 813, 813, 815, 815, 815, 815, 815, 815, 819, 819, - 819, 819, 819, 819, 819, 819, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 805, 805, 805, 805, 805, - 805, 806, 806, 806, 806, 806, 806, 797, 797, 797, - 797, 797, 797, 809, 809, 809, 809, 809, 809, 810, - 810, 810, 810, 810, 810, 811, 811, 811, 811, 811, - 811, 812, 812, 812, 812, 812, 812, 813, 813, 813, - 813, 813, 813, 815, 815, 815, 815, 815, 815, 819, - 819, 819, 819, 819, 819, 819, 804, 804, 804, 804, - - 804, 804, 804, 805, 805, 805, 805, 805, 805, 806, - 806, 806, 806, 806, 806, 797, 797, 797, 797, 797, - 797, 809, 809, 809, 809, 809, 809, 810, 810, 810, - 810, 810, 810, 811, 811, 811, 811, 811, 811, 812, - 812, 812, 812, 812, 812, 813, 813, 813, 813, 813, - 813, 815, 815, 815, 815, 815, 815, 819, 819, 819, - 819, 819, 819, 804, 804, 804, 805, 805, 806, 806, - 797, 797, 809, 809, 810, 810, 811, 811, 812, 812, - 813, 813, 815, 815, 819, 819, 804, 804, 805, 805, - 806, 806, 797, 797, 809, 809, 810, 810, 811, 811, - - 812, 812, 813, 813, 815, 815, 819, 819, 804, 804, - 805, 805, 806, 806, 797, 797, 809, 809, 810, 810, - 811, 811, 812, 812, 813, 813, 815, 815, 819, 819, - 804, 805, 806, 797, 809, 810, 811, 812, 813, 815, - 819, 804, 805, 806, 797, 809, 810, 811, 812, 813, - 815, 819, 804, 805, 806, 797, 809, 810, 811, 812, - 813, 815, 819, 804, 805, 806, 797, 809, 810, 811, - 812, 813, 815, 819, 804, 805, 806, 797, 809, 810, - 811, 812, 813, 815, 819, 804, 805, 806, 797, 809, - 810, 811, 812, 813, 815, 819, 0, 797, 797, 797, - - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797 + 812, 1, 812, 3, 813, 813, 814, 814, 812, 9, + 812, 11, 812, 13, 812, 15, 815, 815, 816, 816, + 812, 21, 812, 812, 812, 812, 817, 818, 812, 812, + 812, 812, 812, 812, 819, 819, 819, 819, 819, 819, + 819, 819, 819, 820, 820, 820, 820, 820, 820, 821, + 821, 812, 821, 822, 821, 821, 821, 812, 821, 821, + 821, 821, 821, 821, 821, 812, 823, 812, 812, 817, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 824, 824, 824, 824, 824, 824, 812, 825, + 825, 825, 825, 825, 825, 825, 812, 826, 826, 826, + + 826, 826, 826, 812, 827, 827, 827, 827, 827, 827, + 827, 828, 828, 828, 829, 828, 828, 828, 828, 828, + 828, 828, 828, 828, 828, 828, 812, 830, 812, 812, + 830, 831, 832, 833, 830, 830, 830, 830, 830, 830, + 830, 830, 830, 830, 830, 830, 812, 834, 834, 834, + 834, 834, 834, 834, 817, 812, 835, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 819, 836, 819, 819, + 819, 819, 819, 819, 819, 819, 820, 820, 820, 820, + 820, 820, 821, 812, 821, 812, 822, 817, 821, 821, + 821, 821, 821, 821, 821, 821, 821, 821, 821, 821, + + 823, 823, 812, 812, 812, 812, 812, 812, 824, 824, + 824, 824, 824, 824, 837, 812, 825, 825, 825, 825, + 825, 825, 826, 826, 826, 826, 826, 826, 838, 812, + 827, 827, 827, 827, 827, 827, 828, 812, 829, 812, + 828, 828, 828, 828, 828, 828, 828, 828, 828, 828, + 828, 828, 828, 812, 812, 830, 830, 830, 812, 812, + 831, 831, 831, 832, 832, 832, 833, 833, 833, 830, + 830, 830, 830, 830, 830, 830, 830, 830, 812, 830, + 830, 830, 830, 834, 834, 834, 834, 834, 834, 834, + 834, 835, 812, 812, 839, 836, 812, 819, 819, 819, + + 819, 819, 819, 819, 819, 819, 820, 820, 820, 820, + 820, 820, 821, 821, 821, 821, 821, 821, 821, 821, + 812, 812, 812, 812, 812, 812, 824, 824, 824, 824, + 824, 824, 840, 841, 825, 825, 825, 825, 825, 825, + 826, 826, 826, 826, 826, 826, 842, 843, 827, 827, + 827, 827, 827, 827, 828, 828, 828, 828, 828, 828, + 828, 828, 830, 830, 830, 830, 812, 830, 830, 830, + 830, 830, 834, 834, 834, 834, 834, 834, 834, 834, + 812, 812, 844, 819, 819, 819, 819, 819, 819, 819, + 819, 819, 820, 820, 820, 820, 820, 820, 821, 821, + + 821, 821, 821, 821, 821, 812, 812, 812, 812, 812, + 812, 824, 824, 824, 824, 824, 824, 840, 825, 845, + 825, 825, 825, 825, 825, 825, 826, 826, 826, 826, + 826, 826, 842, 827, 846, 827, 827, 827, 827, 827, + 827, 828, 812, 828, 828, 828, 828, 828, 828, 830, + 830, 830, 830, 830, 830, 830, 834, 834, 834, 834, + 834, 834, 834, 834, 844, 835, 819, 819, 819, 819, + 819, 819, 819, 819, 819, 820, 820, 820, 820, 820, + 820, 821, 821, 821, 821, 821, 821, 812, 812, 812, + 812, 812, 812, 824, 824, 824, 824, 824, 824, 845, + + 825, 825, 825, 825, 825, 825, 825, 826, 826, 826, + 826, 826, 826, 846, 827, 827, 827, 827, 827, 827, + 827, 828, 828, 828, 828, 828, 828, 830, 830, 830, + 830, 830, 830, 834, 834, 834, 834, 834, 834, 834, + 834, 819, 819, 819, 819, 819, 819, 819, 819, 819, + 820, 820, 820, 820, 820, 820, 821, 821, 821, 821, + 821, 821, 812, 812, 812, 812, 812, 812, 824, 824, + 824, 824, 824, 824, 825, 825, 825, 825, 825, 825, + 826, 826, 826, 826, 826, 826, 827, 827, 827, 827, + 827, 827, 828, 828, 828, 828, 828, 828, 830, 830, + + 830, 830, 830, 830, 834, 834, 834, 834, 834, 834, + 834, 819, 819, 819, 819, 819, 819, 819, 820, 820, + 820, 820, 820, 820, 821, 821, 821, 821, 821, 821, + 812, 812, 812, 812, 812, 812, 824, 824, 824, 824, + 824, 824, 825, 825, 825, 825, 825, 825, 826, 826, + 826, 826, 826, 826, 827, 827, 827, 827, 827, 827, + 828, 828, 828, 828, 828, 828, 830, 830, 830, 830, + 830, 830, 834, 834, 834, 834, 834, 834, 819, 819, + 819, 820, 820, 821, 821, 812, 812, 824, 824, 825, + 825, 826, 826, 827, 827, 828, 828, 830, 830, 834, + + 834, 819, 819, 820, 820, 821, 821, 812, 812, 824, + 824, 825, 825, 826, 826, 827, 827, 828, 828, 830, + 830, 834, 834, 819, 819, 820, 820, 821, 821, 812, + 812, 824, 824, 825, 825, 826, 826, 827, 827, 828, + 828, 830, 830, 834, 834, 819, 820, 821, 812, 824, + 825, 826, 827, 828, 830, 834, 819, 820, 821, 812, + 824, 825, 826, 827, 828, 830, 834, 819, 820, 821, + 812, 824, 825, 826, 827, 828, 830, 834, 819, 820, + 821, 812, 824, 825, 826, 827, 828, 830, 834, 819, + 820, 821, 812, 824, 825, 826, 827, 828, 830, 834, + + 819, 820, 821, 812, 824, 825, 826, 827, 828, 830, + 834, 0, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812 } ; -static yyconst flex_int16_t yy_nxt[2216] = +static yyconst flex_int16_t yy_nxt[2368] = { 0, 24, 25, 26, 25, 24, 27, 28, 24, 29, 24, - 30, 24, 24, 24, 24, 24, 31, 32, 33, 34, - 34, 35, 34, 34, 34, 34, 34, 34, 34, 34, - 34, 34, 24, 24, 24, 34, 36, 34, 34, 37, - 38, 39, 34, 40, 34, 34, 34, 34, 41, 34, - 42, 34, 34, 34, 34, 34, 24, 24, 24, 25, + 30, 24, 24, 31, 24, 24, 32, 33, 34, 35, + 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 24, 24, 24, 35, 37, 35, 35, 38, + 39, 40, 35, 41, 35, 35, 35, 35, 42, 35, + 43, 35, 35, 35, 35, 35, 24, 24, 24, 25, 26, 25, 24, 27, 24, 24, 29, 24, 30, 24, - 24, 24, 24, 24, 31, 32, 33, 43, 43, 44, - 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, - 24, 24, 24, 43, 45, 43, 43, 46, 43, 43, - - 43, 47, 43, 43, 43, 43, 43, 43, 48, 43, - 43, 43, 43, 43, 24, 24, 50, 51, 52, 151, - 53, 157, 157, 54, 157, 55, 157, 152, 176, 177, - 157, 56, 57, 58, 175, 157, 59, 157, 183, 149, - 175, 182, 175, 175, 175, 157, 157, 159, 159, 160, - 159, 60, 159, 179, 61, 161, 159, 185, 62, 205, - 162, 159, 175, 159, 188, 63, 50, 51, 52, 175, - 53, 159, 159, 54, 175, 55, 164, 165, 163, 167, - 180, 56, 57, 58, 166, 186, 59, 205, 181, 175, - 184, 191, 192, 187, 151, 175, 205, 219, 189, 210, - - 205, 60, 152, 205, 61, 219, 219, 219, 62, 219, - 227, 227, 207, 230, 227, 63, 65, 66, 67, 227, - 68, 231, 221, 69, 227, 70, 232, 234, 227, 208, - 227, 71, 72, 73, 209, 227, 74, 211, 222, 233, - 223, 227, 227, 225, 271, 235, 272, 224, 238, 241, - 242, 75, 246, 247, 76, 249, 244, 236, 77, 244, - 295, 255, 244, 157, 296, 78, 65, 66, 67, 157, - 68, 244, 237, 69, 244, 70, 157, 244, 175, 157, - 240, 71, 72, 73, 250, 239, 74, 256, 245, 159, - 151, 176, 177, 149, 420, 159, 283, 405, 152, 175, - - 379, 75, 159, 245, 76, 159, 175, 179, 77, 300, - 380, 305, 284, 191, 192, 78, 24, 25, 79, 25, - 24, 27, 24, 24, 29, 24, 30, 24, 24, 24, - 24, 24, 31, 32, 33, 80, 80, 81, 80, 80, - 80, 80, 80, 80, 80, 80, 80, 80, 24, 24, - 24, 80, 82, 80, 80, 83, 80, 80, 80, 84, - 80, 80, 80, 80, 80, 80, 85, 80, 80, 80, - 80, 80, 24, 24, 24, 25, 26, 25, 24, 27, - 86, 24, 29, 24, 30, 24, 24, 87, 87, 24, - 31, 32, 33, 87, 87, 88, 87, 87, 87, 87, - - 87, 87, 87, 87, 87, 87, 24, 24, 24, 87, - 89, 87, 87, 90, 87, 87, 87, 91, 87, 87, - 87, 87, 87, 87, 92, 87, 87, 87, 87, 87, - 24, 24, 24, 25, 93, 25, 24, 27, 24, 24, - 29, 24, 30, 24, 24, 24, 24, 24, 31, 32, - 33, 94, 94, 95, 94, 94, 94, 94, 94, 94, - 94, 94, 94, 94, 24, 24, 24, 94, 96, 94, - 94, 97, 94, 94, 94, 98, 94, 94, 94, 94, - 94, 94, 99, 94, 94, 94, 94, 94, 24, 24, - 24, 25, 26, 25, 24, 27, 100, 24, 29, 24, - - 30, 24, 24, 101, 101, 24, 31, 32, 33, 101, - 101, 102, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 24, 24, 24, 101, 103, 101, 101, 104, - 101, 101, 101, 105, 101, 101, 101, 101, 101, 101, - 106, 101, 101, 101, 101, 101, 24, 24, 108, 109, - 108, 157, 110, 252, 149, 111, 252, 112, 368, 252, - 278, 157, 157, 113, 114, 115, 257, 309, 116, 244, - 175, 310, 244, 227, 258, 157, 244, 159, 244, 244, - 175, 244, 244, 117, 244, 253, 118, 159, 159, 332, - 119, 157, 259, 286, 260, 302, 285, 120, 245, 205, - - 287, 159, 227, 301, 121, 108, 109, 108, 245, 110, - 245, 433, 111, 244, 112, 279, 244, 159, 291, 244, - 113, 114, 115, 244, 175, 116, 244, 244, 244, 244, - 244, 244, 261, 244, 244, 244, 264, 290, 244, 343, - 117, 244, 325, 118, 262, 245, 303, 119, 157, 315, - 304, 265, 205, 316, 120, 245, 205, 263, 205, 245, - 245, 121, 123, 124, 125, 126, 127, 245, 128, 129, - 244, 130, 320, 244, 159, 180, 244, 131, 132, 133, - 288, 298, 134, 181, 289, 244, 219, 219, 244, 321, - 175, 244, 244, 322, 135, 244, 175, 136, 244, 329, - - 137, 205, 245, 330, 138, 219, 334, 219, 219, 266, - 227, 139, 123, 124, 125, 126, 127, 245, 128, 129, - 335, 130, 227, 175, 245, 241, 242, 131, 132, 133, - 267, 268, 134, 323, 230, 227, 299, 324, 318, 337, - 336, 363, 231, 338, 135, 364, 342, 136, 175, 344, - 137, 339, 246, 247, 138, 366, 367, 385, 427, 428, - 390, 139, 24, 25, 140, 25, 24, 27, 24, 24, - 29, 24, 30, 24, 24, 24, 24, 24, 31, 32, - 33, 141, 141, 142, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 24, 24, 24, 141, 143, 144, - - 141, 145, 141, 141, 141, 146, 141, 141, 141, 141, - 141, 141, 147, 141, 141, 141, 141, 141, 24, 24, - 340, 227, 227, 227, 244, 244, 249, 244, 244, 175, - 244, 244, 244, 244, 249, 244, 205, 248, 244, 249, - 252, 149, 278, 252, 252, 149, 252, 252, 252, 348, - 252, 252, 255, 255, 252, 250, 245, 245, 345, 175, - 254, 205, 346, 250, 245, 255, 470, 205, 250, 563, - 347, 349, 253, 205, 244, 341, 253, 244, 256, 256, - 253, 257, 244, 389, 244, 244, 406, 244, 244, 258, - 244, 256, 244, 244, 487, 244, 244, 279, 244, 244, - - 409, 150, 244, 245, 244, 244, 244, 244, 157, 244, - 244, 157, 244, 245, 245, 244, 157, 244, 244, 157, - 244, 244, 245, 244, 245, 157, 350, 244, 175, 351, - 244, 245, 205, 244, 159, 369, 245, 159, 245, 157, - 157, 157, 159, 157, 353, 159, 157, 245, 298, 245, - 175, 159, 392, 205, 355, 354, 219, 388, 356, 245, - 372, 370, 393, 175, 398, 159, 159, 159, 407, 159, - 205, 371, 159, 373, 399, 357, 386, 375, 408, 374, - 384, 367, 376, 413, 219, 219, 387, 410, 377, 219, - 219, 227, 422, 414, 227, 175, 340, 227, 227, 227, - - 366, 367, 423, 299, 421, 244, 349, 244, 244, 244, - 244, 244, 244, 244, 429, 435, 367, 411, 244, 175, - 227, 244, 244, 424, 425, 244, 244, 244, 244, 244, - 244, 436, 244, 244, 430, 219, 426, 245, 245, 245, - 244, 432, 244, 244, 431, 244, 244, 245, 244, 157, - 434, 341, 443, 471, 245, 157, 157, 157, 245, 245, - 175, 350, 444, 437, 157, 157, 157, 157, 205, 175, - 452, 439, 245, 438, 245, 159, 157, 175, 175, 440, - 467, 159, 159, 159, 205, 453, 454, 472, 384, 367, - 159, 159, 159, 159, 441, 205, 205, 468, 469, 205, - - 219, 455, 159, 175, 460, 219, 219, 219, 456, 219, - 458, 219, 457, 227, 488, 490, 227, 459, 427, 428, - 227, 501, 227, 227, 227, 489, 435, 367, 244, 244, - 175, 244, 244, 175, 244, 502, 492, 503, 507, 669, - 491, 175, 244, 542, 157, 244, 506, 205, 244, 713, - 508, 157, 175, 504, 509, 505, 244, 157, 245, 244, - 245, 244, 244, 514, 244, 512, 244, 244, 513, 244, - 159, 511, 244, 510, 245, 244, 157, 159, 244, 157, - 527, 244, 157, 159, 157, 157, 157, 544, 245, 175, - 205, 515, 562, 245, 157, 175, 529, 175, 245, 175, - - 205, 205, 159, 219, 205, 159, 219, 245, 159, 219, - 159, 159, 159, 516, 219, 517, 528, 518, 532, 543, - 159, 533, 545, 531, 546, 530, 534, 560, 219, 547, - 561, 219, 572, 227, 227, 227, 227, 564, 535, 227, - 227, 157, 175, 573, 175, 565, 205, 575, 175, 244, - 244, 574, 244, 244, 788, 244, 244, 766, 244, 157, - 578, 244, 675, 610, 244, 576, 244, 159, 244, 244, - 597, 244, 244, 581, 244, 577, 157, 584, 579, 157, - 582, 245, 245, 244, 580, 159, 244, 157, 583, 244, - 245, 157, 598, 157, 157, 585, 157, 175, 245, 175, - - 245, 175, 159, 205, 587, 159, 175, 175, 586, 205, - 588, 205, 205, 159, 599, 245, 205, 159, 205, 159, - 159, 613, 159, 219, 611, 601, 219, 612, 600, 219, - 603, 615, 589, 219, 219, 219, 629, 227, 628, 602, - 227, 227, 614, 227, 227, 157, 631, 227, 244, 630, - 157, 244, 633, 205, 244, 640, 641, 244, 244, 205, - 244, 244, 632, 244, 244, 157, 664, 642, 643, 645, - 646, 159, 244, 175, 227, 244, 159, 647, 244, 644, - 245, 649, 652, 648, 665, 651, 157, 157, 157, 245, - 245, 159, 157, 244, 650, 653, 244, 244, 676, 244, - - 244, 654, 670, 244, 245, 219, 219, 227, 175, 796, - 175, 655, 159, 159, 159, 205, 244, 682, 159, 244, - 244, 679, 244, 244, 691, 245, 244, 681, 244, 245, - 157, 244, 666, 157, 244, 244, 657, 683, 244, 157, - 244, 244, 175, 244, 656, 680, 244, 244, 245, 698, - 244, 205, 245, 244, 687, 219, 159, 219, 227, 159, - 245, 227, 157, 205, 684, 159, 692, 245, 244, 157, - 175, 244, 245, 688, 244, 697, 205, 244, 219, 245, - 244, 701, 219, 244, 227, 227, 703, 709, 159, 702, - 227, 175, 157, 227, 719, 159, 723, 705, 755, 704, - - 245, 157, 244, 739, 714, 244, 710, 720, 244, 245, - 205, 244, 725, 792, 244, 731, 706, 244, 159, 175, - 750, 219, 157, 733, 736, 727, 724, 159, 205, 175, - 244, 219, 726, 244, 245, 738, 244, 227, 244, 157, - 205, 244, 744, 245, 244, 742, 219, 244, 159, 740, - 244, 747, 157, 244, 749, 205, 753, 758, 761, 227, - 728, 244, 245, 760, 244, 159, 219, 244, 157, 175, - 245, 764, 205, 219, 769, 751, 227, 777, 159, 245, - 157, 244, 772, 762, 244, 771, 775, 244, 205, 244, - 780, 782, 244, 245, 159, 244, 219, 227, 783, 157, - - 790, 244, 786, 789, 244, 773, 159, 244, 244, 787, - 791, 244, 784, 245, 244, 785, 781, 779, 793, 778, - 776, 245, 774, 794, 770, 159, 768, 767, 795, 765, - 763, 759, 757, 245, 756, 754, 752, 748, 746, 745, - 245, 49, 49, 49, 49, 49, 49, 49, 49, 49, - 49, 49, 49, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 107, 107, 107, 107, 107, - 107, 107, 107, 107, 107, 107, 107, 122, 122, 122, - 122, 122, 122, 122, 122, 122, 122, 122, 122, 148, - 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, - - 148, 158, 158, 158, 743, 158, 158, 158, 168, 168, - 741, 168, 168, 174, 227, 174, 174, 174, 174, 174, - 174, 174, 174, 174, 174, 178, 178, 178, 178, 178, - 178, 178, 178, 178, 178, 178, 178, 190, 190, 190, - 190, 190, 190, 190, 190, 190, 190, 190, 190, 198, - 198, 219, 198, 198, 206, 206, 737, 206, 206, 206, - 212, 212, 205, 212, 212, 220, 220, 735, 220, 220, - 220, 226, 226, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 226, 228, 228, 228, 228, 228, 228, 228, - 228, 228, 228, 228, 228, 243, 734, 243, 243, 243, - - 243, 243, 243, 243, 243, 243, 243, 248, 175, 732, - 248, 248, 248, 248, 248, 248, 248, 248, 248, 251, - 251, 251, 251, 251, 251, 251, 251, 251, 251, 251, - 251, 254, 730, 729, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 269, 269, 722, 269, 269, 277, 277, - 277, 721, 277, 277, 277, 281, 281, 718, 281, 403, - 403, 717, 403, 403, 716, 715, 403, 418, 418, 712, - 418, 418, 711, 708, 418, 450, 450, 707, 450, 450, - 700, 699, 450, 485, 485, 696, 485, 485, 695, 694, - 485, 499, 499, 693, 499, 499, 690, 689, 499, 686, - - 685, 227, 227, 227, 227, 219, 219, 219, 219, 678, - 677, 205, 205, 205, 205, 674, 673, 672, 671, 175, - 175, 175, 175, 668, 667, 663, 662, 661, 660, 659, - 658, 639, 638, 637, 636, 635, 634, 627, 626, 625, - 624, 623, 622, 621, 620, 619, 618, 617, 616, 609, - 608, 607, 606, 605, 604, 596, 595, 594, 593, 592, - 591, 590, 219, 500, 571, 570, 569, 568, 567, 566, - 205, 486, 559, 558, 557, 556, 555, 554, 553, 552, - 551, 550, 549, 548, 541, 540, 539, 538, 537, 536, - 451, 526, 525, 524, 523, 522, 521, 520, 519, 428, - - 500, 219, 419, 498, 497, 496, 495, 494, 493, 486, - 205, 404, 484, 483, 482, 481, 480, 479, 478, 477, - 476, 475, 474, 473, 466, 465, 464, 463, 462, 461, - 451, 367, 449, 448, 447, 446, 445, 442, 352, 227, - 219, 419, 417, 416, 415, 412, 205, 404, 402, 401, - 400, 397, 396, 395, 394, 391, 175, 383, 382, 381, - 378, 282, 365, 362, 361, 360, 359, 358, 352, 247, - 242, 227, 227, 227, 227, 227, 229, 227, 227, 219, - 333, 331, 328, 327, 326, 205, 319, 317, 314, 313, - 312, 311, 308, 307, 306, 192, 175, 175, 175, 149, - - 175, 297, 294, 293, 292, 282, 280, 149, 276, 275, - 274, 273, 270, 247, 229, 227, 227, 227, 219, 218, - 217, 216, 215, 214, 213, 205, 204, 203, 202, 201, - 200, 199, 197, 196, 195, 194, 193, 156, 155, 154, - 153, 149, 154, 175, 175, 173, 172, 171, 170, 169, - 156, 155, 154, 153, 149, 797, 23, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797 + 24, 31, 24, 24, 32, 33, 34, 44, 44, 45, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 24, 24, 24, 44, 46, 44, 44, 47, 44, 44, + + 44, 48, 44, 44, 44, 44, 44, 44, 49, 44, + 44, 44, 44, 44, 24, 24, 51, 52, 53, 158, + 54, 163, 166, 55, 164, 56, 166, 159, 57, 156, + 166, 58, 59, 60, 166, 166, 61, 166, 185, 186, + 184, 191, 184, 188, 435, 166, 166, 184, 168, 238, + 166, 62, 168, 184, 63, 169, 168, 196, 64, 170, + 168, 168, 238, 168, 173, 65, 51, 52, 53, 171, + 54, 168, 168, 55, 184, 56, 168, 199, 57, 184, + 176, 58, 59, 60, 189, 172, 61, 184, 192, 184, + 174, 249, 190, 252, 175, 184, 195, 193, 198, 184, + + 194, 62, 197, 184, 63, 202, 203, 163, 64, 238, + 164, 158, 238, 200, 262, 65, 67, 68, 69, 159, + 70, 420, 238, 71, 216, 72, 216, 216, 73, 216, + 216, 74, 75, 76, 216, 161, 77, 812, 812, 230, + 812, 812, 216, 263, 230, 812, 230, 251, 230, 250, + 161, 78, 218, 812, 79, 812, 238, 812, 80, 812, + 253, 230, 219, 156, 220, 81, 67, 68, 69, 230, + 70, 232, 812, 71, 221, 72, 222, 188, 73, 230, + 812, 74, 75, 76, 241, 238, 77, 238, 235, 238, + 812, 238, 242, 358, 233, 238, 238, 246, 254, 255, + + 247, 78, 243, 234, 79, 286, 244, 287, 80, 383, + 245, 248, 347, 236, 333, 81, 24, 25, 82, 25, + 24, 27, 24, 24, 29, 24, 30, 24, 24, 31, + 24, 24, 32, 33, 34, 83, 83, 84, 83, 83, + 83, 83, 83, 83, 83, 83, 83, 83, 24, 24, + 24, 83, 85, 83, 83, 86, 83, 83, 83, 87, + 83, 83, 83, 83, 83, 83, 88, 83, 83, 83, + 83, 83, 24, 24, 24, 25, 26, 25, 24, 27, + 89, 24, 29, 24, 30, 24, 24, 90, 91, 24, + 32, 33, 34, 91, 91, 92, 91, 91, 91, 91, + + 91, 91, 91, 91, 91, 91, 24, 24, 24, 91, + 93, 91, 91, 94, 91, 91, 91, 95, 91, 91, + 91, 91, 91, 91, 96, 91, 91, 91, 91, 91, + 24, 24, 24, 25, 97, 25, 24, 27, 24, 24, + 29, 24, 30, 24, 24, 31, 24, 24, 32, 33, + 34, 98, 98, 99, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 24, 24, 24, 98, 100, 98, + 98, 101, 98, 98, 98, 102, 98, 98, 98, 98, + 98, 98, 103, 98, 98, 98, 98, 98, 24, 24, + 24, 25, 26, 25, 24, 27, 104, 24, 29, 24, + + 30, 24, 24, 105, 106, 24, 32, 33, 34, 106, + 106, 107, 106, 106, 106, 106, 106, 106, 106, 106, + 106, 106, 24, 24, 24, 106, 108, 106, 106, 109, + 106, 106, 106, 110, 106, 106, 106, 106, 106, 106, + 111, 106, 106, 106, 106, 106, 24, 24, 113, 114, + 113, 268, 115, 257, 166, 116, 257, 117, 157, 257, + 118, 259, 260, 119, 120, 121, 257, 158, 122, 257, + 265, 156, 257, 265, 166, 159, 265, 269, 185, 186, + 168, 270, 293, 123, 257, 258, 124, 257, 310, 271, + 125, 184, 311, 184, 238, 189, 184, 126, 258, 184, + + 168, 315, 266, 190, 127, 113, 114, 113, 400, 115, + 184, 184, 116, 258, 117, 184, 166, 118, 357, 316, + 119, 120, 121, 257, 257, 122, 257, 257, 257, 257, + 257, 257, 166, 275, 257, 257, 276, 294, 257, 272, + 123, 257, 168, 124, 273, 486, 166, 125, 320, 299, + 184, 274, 298, 238, 126, 258, 258, 166, 168, 184, + 258, 127, 129, 130, 131, 132, 133, 258, 134, 135, + 257, 136, 168, 257, 137, 317, 257, 138, 139, 140, + 238, 300, 141, 168, 166, 257, 277, 216, 257, 238, + 257, 257, 359, 257, 142, 629, 257, 143, 812, 301, + + 144, 184, 258, 257, 145, 166, 257, 268, 166, 257, + 168, 146, 129, 130, 131, 132, 133, 258, 134, 135, + 278, 136, 258, 280, 137, 404, 184, 138, 139, 140, + 305, 168, 141, 269, 168, 258, 202, 203, 254, 255, + 449, 324, 281, 302, 142, 325, 230, 143, 318, 330, + 144, 306, 319, 331, 145, 344, 378, 812, 184, 345, + 379, 146, 24, 25, 147, 25, 24, 27, 24, 24, + 29, 24, 30, 24, 24, 31, 24, 24, 32, 33, + 34, 148, 148, 149, 148, 148, 148, 148, 148, 148, + 148, 148, 148, 148, 24, 24, 24, 148, 150, 151, + + 148, 152, 148, 148, 148, 153, 148, 148, 148, 148, + 148, 148, 154, 148, 148, 148, 148, 148, 24, 24, + 257, 279, 257, 257, 257, 257, 257, 257, 257, 166, + 257, 313, 216, 216, 216, 238, 216, 216, 230, 230, + 230, 355, 238, 812, 812, 812, 184, 812, 812, 812, + 812, 812, 258, 335, 258, 168, 258, 238, 349, 230, + 230, 303, 811, 283, 338, 304, 268, 282, 339, 336, + 812, 812, 337, 350, 351, 241, 238, 340, 257, 259, + 260, 257, 362, 242, 257, 262, 314, 262, 261, 166, + 262, 352, 269, 360, 807, 353, 356, 361, 257, 257, + + 257, 257, 257, 354, 257, 257, 265, 156, 267, 265, + 258, 293, 265, 268, 263, 168, 263, 265, 156, 263, + 265, 265, 363, 265, 265, 238, 270, 265, 184, 257, + 258, 258, 257, 184, 271, 381, 382, 364, 266, 269, + 257, 257, 257, 257, 257, 257, 166, 257, 257, 266, + 522, 257, 216, 266, 257, 487, 257, 257, 258, 257, + 166, 257, 257, 812, 257, 257, 294, 257, 257, 258, + 405, 257, 168, 258, 258, 257, 257, 166, 257, 257, + 166, 257, 257, 258, 257, 166, 168, 257, 258, 166, + 257, 166, 365, 258, 388, 257, 257, 258, 257, 257, + + 366, 257, 257, 168, 384, 166, 168, 258, 258, 166, + 394, 168, 184, 385, 368, 168, 258, 168, 313, 184, + 395, 387, 184, 386, 369, 391, 184, 258, 258, 805, + 389, 168, 370, 184, 728, 168, 371, 399, 382, 390, + 407, 403, 483, 413, 372, 401, 216, 216, 216, 216, + 408, 216, 184, 414, 428, 402, 392, 812, 812, 812, + 812, 230, 812, 230, 429, 421, 230, 230, 230, 238, + 230, 238, 812, 314, 812, 355, 238, 812, 812, 812, + 436, 812, 238, 422, 238, 425, 238, 424, 442, 443, + 458, 257, 444, 423, 257, 364, 426, 257, 257, 437, + + 459, 257, 440, 184, 450, 382, 439, 257, 238, 438, + 257, 445, 257, 257, 482, 257, 257, 441, 257, 257, + 523, 446, 448, 258, 804, 447, 257, 258, 257, 257, + 356, 257, 257, 166, 257, 257, 258, 451, 257, 381, + 382, 257, 166, 257, 258, 258, 257, 166, 184, 257, + 365, 184, 166, 452, 467, 166, 526, 166, 258, 168, + 258, 166, 166, 453, 166, 399, 382, 258, 168, 442, + 443, 484, 454, 168, 455, 258, 802, 468, 168, 800, + 184, 168, 469, 168, 238, 485, 470, 168, 168, 216, + 168, 216, 238, 184, 238, 456, 216, 216, 216, 471, + + 812, 475, 812, 474, 472, 473, 216, 812, 812, 812, + 216, 230, 502, 230, 230, 238, 166, 812, 230, 230, + 230, 812, 812, 558, 812, 812, 503, 504, 230, 812, + 812, 812, 664, 527, 516, 525, 166, 450, 382, 812, + 257, 796, 168, 257, 517, 505, 794, 507, 518, 524, + 506, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 184, 238, 168, 166, 520, 521, 519, 257, 257, 258, + 257, 257, 257, 257, 257, 257, 543, 528, 257, 166, + 166, 166, 166, 258, 258, 258, 542, 529, 530, 168, + 166, 184, 166, 793, 166, 559, 184, 184, 184, 258, + + 258, 184, 216, 684, 258, 168, 168, 168, 168, 557, + 595, 238, 216, 812, 533, 547, 168, 532, 168, 531, + 168, 560, 546, 812, 544, 562, 545, 548, 561, 216, + 216, 216, 549, 216, 216, 575, 230, 230, 550, 230, + 812, 812, 812, 230, 812, 812, 230, 812, 812, 238, + 812, 230, 230, 238, 812, 594, 238, 812, 238, 184, + 587, 166, 812, 812, 578, 166, 184, 166, 184, 576, + 579, 257, 748, 791, 257, 577, 593, 257, 580, 588, + 706, 238, 626, 591, 590, 166, 257, 168, 589, 257, + 596, 168, 257, 168, 612, 257, 592, 597, 257, 599, + + 613, 257, 257, 258, 257, 257, 598, 257, 257, 257, + 257, 168, 257, 166, 184, 257, 166, 166, 258, 216, + 184, 166, 166, 614, 184, 184, 216, 258, 789, 741, + 812, 600, 238, 625, 258, 238, 258, 812, 238, 168, + 602, 258, 168, 168, 628, 601, 603, 168, 168, 630, + 616, 216, 627, 216, 615, 643, 618, 645, 604, 216, + 216, 230, 812, 617, 812, 230, 230, 230, 230, 230, + 812, 812, 812, 238, 663, 662, 812, 812, 812, 812, + 812, 238, 238, 257, 644, 665, 257, 646, 184, 257, + 655, 785, 166, 257, 648, 770, 257, 184, 656, 257, + + 754, 658, 166, 660, 657, 647, 661, 257, 679, 803, + 257, 166, 166, 257, 659, 258, 166, 667, 168, 666, + 257, 257, 166, 257, 257, 258, 257, 257, 168, 257, + 166, 668, 257, 184, 216, 257, 216, 168, 168, 258, + 216, 680, 168, 216, 216, 812, 216, 812, 168, 238, + 669, 812, 258, 258, 812, 812, 168, 812, 681, 670, + 690, 258, 685, 230, 230, 230, 230, 230, 672, 230, + 238, 783, 671, 691, 812, 812, 812, 812, 812, 694, + 812, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 696, 257, 697, 257, 257, 257, 257, 257, 257, 257, + + 184, 257, 698, 695, 166, 166, 166, 216, 230, 216, + 230, 238, 238, 258, 258, 258, 238, 166, 812, 812, + 812, 812, 184, 258, 707, 258, 699, 258, 702, 782, + 168, 168, 168, 712, 716, 724, 166, 238, 740, 703, + 718, 713, 717, 168, 257, 257, 216, 257, 257, 719, + 257, 257, 216, 166, 230, 230, 729, 812, 216, 166, + 787, 184, 168, 812, 734, 812, 812, 746, 257, 812, + 781, 257, 738, 720, 257, 257, 258, 258, 257, 168, + 725, 257, 230, 216, 721, 168, 257, 230, 166, 257, + 238, 742, 257, 812, 812, 184, 735, 751, 812, 739, + + 258, 753, 216, 257, 230, 755, 257, 258, 759, 257, + 780, 757, 166, 812, 168, 812, 257, 765, 258, 257, + 216, 238, 257, 230, 743, 762, 778, 764, 166, 768, + 257, 812, 216, 257, 812, 258, 257, 773, 168, 230, + 775, 184, 776, 812, 766, 166, 216, 779, 258, 792, + 812, 784, 777, 257, 168, 230, 257, 812, 786, 257, + 238, 166, 258, 790, 795, 238, 812, 216, 230, 257, + 216, 168, 257, 797, 166, 257, 774, 788, 812, 812, + 772, 812, 798, 801, 230, 258, 771, 168, 769, 806, + 808, 809, 799, 257, 767, 812, 257, 763, 761, 257, + + 168, 258, 257, 760, 758, 257, 756, 238, 257, 752, + 750, 749, 184, 747, 745, 744, 737, 736, 733, 732, + 810, 731, 730, 727, 726, 258, 723, 722, 715, 714, + 711, 710, 709, 708, 258, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 66, 66, 66, + 66, 66, 66, 66, 66, 66, 66, 66, 66, 112, + 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, + 112, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 167, 167, 167, 705, 167, + + 167, 167, 177, 177, 704, 177, 177, 183, 701, 183, + 183, 183, 183, 183, 183, 183, 183, 183, 183, 187, + 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, + 187, 201, 201, 201, 201, 201, 201, 201, 201, 201, + 201, 201, 201, 209, 209, 700, 209, 209, 217, 217, + 238, 217, 217, 217, 223, 223, 238, 223, 223, 231, + 231, 238, 231, 231, 231, 237, 237, 237, 237, 237, + 237, 237, 237, 237, 237, 237, 237, 239, 239, 239, + 239, 239, 239, 239, 239, 239, 239, 239, 239, 256, + 238, 256, 256, 256, 256, 256, 256, 256, 256, 256, + + 256, 261, 693, 692, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 267, 689, 688, 267, 267, + 267, 267, 267, 267, 267, 267, 267, 284, 284, 687, + 284, 284, 292, 292, 292, 686, 292, 292, 292, 296, + 296, 184, 296, 418, 418, 184, 418, 418, 184, 184, + 418, 433, 433, 683, 433, 433, 682, 678, 433, 465, + 465, 677, 465, 465, 676, 675, 465, 500, 500, 674, + 500, 500, 673, 654, 500, 514, 514, 653, 514, 514, + 652, 651, 514, 650, 649, 642, 641, 640, 639, 638, + + 637, 636, 635, 634, 633, 632, 631, 624, 623, 622, + 621, 620, 619, 611, 610, 609, 608, 607, 606, 605, + 515, 586, 585, 584, 583, 582, 581, 501, 574, 573, + 572, 571, 570, 569, 568, 567, 566, 565, 564, 563, + 556, 555, 554, 553, 552, 551, 466, 541, 540, 539, + 538, 537, 536, 535, 534, 443, 515, 434, 513, 512, + 511, 510, 509, 508, 501, 419, 499, 498, 497, 496, + 495, 494, 493, 492, 491, 490, 489, 488, 481, 480, + 479, 478, 477, 476, 466, 382, 464, 463, 462, 461, + 460, 457, 367, 238, 434, 432, 431, 430, 427, 419, + + 417, 416, 415, 412, 411, 410, 409, 406, 184, 398, + 397, 396, 393, 297, 380, 377, 376, 375, 374, 373, + 367, 260, 255, 238, 238, 238, 238, 238, 238, 238, + 240, 238, 238, 348, 346, 343, 342, 341, 334, 332, + 329, 328, 327, 326, 323, 322, 321, 203, 184, 184, + 184, 184, 184, 156, 184, 312, 309, 308, 307, 297, + 295, 156, 291, 290, 289, 288, 285, 260, 240, 238, + 238, 238, 229, 228, 227, 226, 225, 224, 215, 214, + 213, 212, 211, 210, 208, 207, 206, 205, 204, 165, + 162, 161, 160, 156, 162, 184, 184, 182, 181, 180, + + 179, 178, 165, 162, 161, 160, 156, 812, 23, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812 } ; -static yyconst flex_int16_t yy_chk[2216] = +static yyconst flex_int16_t yy_chk[2368] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -953,28 +973,28 @@ static yyconst flex_int16_t yy_chk[2216] = 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 5, 29, - 5, 34, 36, 5, 35, 5, 37, 29, 50, 50, - 38, 5, 5, 5, 62, 41, 5, 40, 57, 53, - 55, 55, 59, 50, 57, 42, 39, 34, 36, 35, - 35, 5, 37, 53, 5, 36, 38, 59, 5, 91, - 37, 41, 60, 40, 62, 5, 6, 6, 6, 61, - 6, 42, 39, 6, 63, 6, 39, 40, 38, 42, - 54, 6, 6, 6, 41, 60, 6, 88, 54, 58, - 58, 65, 65, 61, 69, 54, 89, 102, 63, 91, - - 90, 6, 69, 92, 6, 103, 104, 105, 6, 106, - 118, 112, 88, 111, 111, 6, 7, 7, 7, 114, - 7, 111, 102, 7, 113, 7, 112, 114, 116, 89, - 115, 7, 7, 7, 90, 117, 7, 92, 103, 113, - 104, 119, 120, 106, 143, 115, 143, 105, 118, 121, - 121, 7, 123, 123, 7, 126, 122, 116, 7, 122, - 172, 128, 122, 150, 172, 7, 8, 8, 8, 158, - 8, 125, 117, 8, 125, 8, 160, 125, 189, 161, - 120, 8, 8, 8, 126, 119, 8, 128, 122, 150, - 151, 176, 176, 178, 828, 158, 160, 826, 151, 185, - - 293, 8, 160, 125, 8, 161, 176, 178, 8, 185, - 293, 189, 161, 191, 191, 8, 9, 9, 9, 9, + 5, 33, 35, 5, 33, 5, 37, 29, 5, 54, + 36, 5, 5, 5, 40, 38, 5, 39, 51, 51, + 56, 56, 61, 54, 843, 42, 43, 64, 35, 125, + 41, 5, 37, 51, 5, 36, 36, 61, 5, 37, + 40, 38, 122, 39, 40, 5, 6, 6, 6, 38, + 6, 42, 43, 6, 63, 6, 41, 64, 6, 62, + 43, 6, 6, 6, 55, 39, 6, 57, 57, 65, + 41, 122, 55, 125, 42, 60, 60, 59, 63, 55, + + 59, 6, 62, 59, 6, 67, 67, 75, 6, 124, + 75, 71, 123, 65, 132, 6, 7, 7, 7, 71, + 7, 841, 126, 7, 90, 7, 91, 92, 7, 93, + 94, 7, 7, 7, 95, 90, 7, 91, 92, 105, + 93, 94, 96, 132, 106, 95, 107, 124, 110, 123, + 105, 7, 92, 96, 7, 106, 250, 107, 7, 110, + 126, 108, 93, 187, 94, 7, 8, 8, 8, 109, + 8, 107, 108, 8, 95, 8, 96, 187, 8, 111, + 109, 8, 8, 8, 116, 116, 8, 117, 110, 120, + 111, 118, 116, 250, 108, 119, 121, 120, 127, 127, + + 120, 8, 117, 109, 8, 150, 118, 150, 8, 839, + 119, 121, 838, 111, 837, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, @@ -1000,198 +1020,214 @@ static yyconst flex_int16_t yy_chk[2216] = 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 17, 17, - 17, 163, 17, 127, 127, 17, 127, 17, 824, 127, - 152, 162, 164, 17, 17, 17, 129, 196, 17, 129, - 187, 196, 129, 346, 129, 167, 130, 163, 131, 130, - 186, 131, 130, 17, 131, 127, 17, 162, 164, 823, - 17, 166, 130, 163, 131, 187, 162, 17, 129, 211, - - 164, 167, 237, 186, 17, 18, 18, 18, 130, 18, - 131, 346, 18, 136, 18, 152, 136, 166, 167, 136, - 18, 18, 18, 132, 188, 18, 132, 134, 133, 132, - 134, 133, 132, 134, 133, 135, 135, 166, 135, 237, - 18, 135, 211, 18, 133, 136, 188, 18, 165, 202, - 188, 136, 207, 202, 18, 132, 208, 134, 209, 134, - 133, 18, 19, 19, 19, 19, 19, 135, 19, 19, - 137, 19, 207, 137, 165, 180, 137, 19, 19, 19, - 165, 181, 19, 180, 165, 138, 221, 222, 138, 208, - 180, 138, 139, 209, 19, 139, 181, 19, 139, 216, - - 19, 210, 137, 216, 19, 223, 221, 224, 225, 137, - 238, 19, 20, 20, 20, 20, 20, 138, 20, 20, - 222, 20, 236, 305, 139, 241, 241, 20, 20, 20, - 138, 139, 20, 210, 230, 230, 181, 210, 822, 224, - 223, 275, 230, 224, 20, 275, 236, 20, 300, 238, - 20, 225, 246, 246, 20, 279, 279, 300, 341, 341, - 305, 20, 21, 21, 21, 21, 21, 21, 21, 21, + 17, 134, 17, 128, 157, 17, 128, 17, 818, 128, + 17, 129, 129, 17, 17, 17, 131, 158, 17, 131, + 133, 133, 131, 133, 167, 158, 133, 134, 185, 185, + 157, 135, 159, 17, 135, 128, 17, 135, 181, 135, + 17, 196, 181, 185, 249, 189, 197, 17, 131, 315, + + 167, 196, 133, 189, 17, 18, 18, 18, 315, 18, + 189, 404, 18, 135, 18, 200, 170, 18, 249, 197, + 18, 18, 18, 136, 139, 18, 136, 139, 137, 136, + 139, 137, 169, 139, 137, 138, 139, 159, 138, 136, + 18, 138, 170, 18, 137, 404, 171, 18, 200, 170, + 198, 138, 169, 251, 18, 136, 139, 172, 169, 561, + 137, 18, 19, 19, 19, 19, 19, 138, 19, 19, + 140, 19, 171, 140, 19, 198, 140, 19, 19, 19, + 809, 171, 19, 172, 175, 143, 140, 217, 143, 362, + 141, 143, 251, 141, 19, 561, 141, 19, 217, 172, + + 19, 319, 140, 144, 19, 173, 144, 267, 176, 144, + 175, 19, 20, 20, 20, 20, 20, 143, 20, 20, + 141, 20, 141, 143, 20, 319, 199, 20, 20, 20, + 175, 173, 20, 267, 176, 144, 202, 202, 254, 254, + 362, 207, 144, 173, 20, 207, 231, 20, 199, 213, + 20, 176, 199, 213, 20, 227, 290, 231, 803, 227, + 290, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, - 231, 231, 239, 240, 243, 244, 248, 243, 244, 388, - 243, 244, 245, 245, 249, 245, 490, 250, 245, 250, - 251, 251, 278, 251, 252, 252, 251, 252, 253, 253, - 252, 253, 254, 255, 253, 248, 243, 244, 239, 304, - 256, 323, 239, 249, 245, 256, 388, 320, 250, 490, - 240, 258, 251, 406, 258, 231, 252, 258, 254, 255, - 253, 257, 259, 304, 257, 259, 320, 257, 259, 257, - 260, 256, 261, 260, 406, 261, 260, 278, 261, 262, - - 323, 803, 262, 258, 263, 262, 265, 263, 277, 265, - 263, 285, 265, 257, 259, 266, 283, 267, 266, 286, - 267, 266, 260, 267, 261, 284, 258, 268, 303, 263, - 268, 262, 321, 268, 277, 283, 263, 285, 265, 287, - 288, 291, 283, 289, 265, 286, 290, 266, 298, 267, - 301, 284, 307, 324, 267, 266, 335, 303, 267, 268, - 286, 284, 307, 298, 313, 287, 288, 291, 321, 289, - 325, 284, 290, 287, 313, 268, 301, 289, 321, 288, - 299, 299, 290, 327, 337, 334, 301, 324, 291, 339, - 338, 342, 335, 327, 343, 299, 340, 340, 345, 347, - - 366, 366, 335, 298, 334, 348, 349, 351, 348, 349, - 351, 348, 349, 351, 342, 350, 350, 325, 350, 389, - 794, 350, 353, 337, 338, 353, 354, 355, 353, 354, - 355, 351, 354, 355, 343, 793, 339, 348, 349, 351, - 356, 345, 357, 356, 343, 357, 356, 350, 357, 369, - 347, 340, 359, 389, 353, 370, 371, 372, 354, 355, - 390, 349, 359, 353, 373, 374, 375, 377, 409, 385, - 369, 355, 356, 353, 357, 369, 376, 386, 387, 356, - 385, 370, 371, 372, 407, 370, 371, 390, 384, 384, - 373, 374, 375, 377, 357, 408, 410, 386, 387, 411, - - 421, 372, 376, 384, 377, 422, 424, 423, 373, 426, - 375, 425, 374, 429, 407, 409, 430, 376, 427, 427, - 431, 421, 432, 433, 434, 408, 435, 435, 437, 435, - 467, 437, 435, 610, 437, 422, 411, 423, 429, 610, - 410, 691, 436, 467, 451, 436, 426, 489, 436, 691, - 430, 454, 469, 424, 431, 425, 438, 452, 435, 438, - 437, 439, 438, 437, 439, 434, 440, 439, 436, 440, - 451, 433, 440, 432, 436, 441, 453, 454, 441, 455, - 452, 441, 456, 452, 458, 457, 459, 469, 438, 468, - 488, 438, 489, 439, 460, 472, 454, 471, 440, 470, - - 491, 492, 453, 502, 487, 455, 503, 441, 456, 501, - 458, 457, 459, 439, 504, 440, 453, 441, 457, 468, - 460, 458, 470, 456, 471, 455, 459, 487, 505, 472, - 488, 506, 501, 507, 508, 509, 510, 491, 460, 511, - 512, 527, 777, 502, 542, 492, 628, 504, 755, 513, - 514, 503, 513, 514, 777, 513, 514, 755, 515, 528, - 507, 515, 628, 542, 515, 505, 516, 527, 517, 516, - 527, 517, 516, 510, 517, 506, 529, 513, 508, 530, - 511, 513, 514, 518, 509, 528, 518, 531, 512, 518, - 515, 532, 528, 533, 534, 514, 535, 545, 516, 544, - - 517, 543, 529, 561, 516, 530, 546, 547, 515, 560, - 517, 562, 563, 531, 529, 518, 564, 532, 565, 533, - 534, 545, 535, 573, 543, 532, 572, 544, 531, 574, - 535, 547, 518, 576, 575, 577, 561, 578, 560, 533, - 579, 580, 546, 581, 582, 598, 563, 583, 584, 562, - 597, 584, 565, 791, 584, 572, 573, 585, 586, 629, - 585, 586, 564, 585, 586, 599, 597, 574, 575, 577, - 578, 598, 587, 611, 647, 587, 597, 579, 587, 576, - 584, 581, 584, 580, 598, 583, 600, 601, 602, 585, - 586, 599, 603, 588, 582, 585, 588, 589, 629, 588, - - 589, 586, 611, 589, 587, 640, 641, 646, 788, 785, - 669, 587, 600, 601, 602, 676, 652, 647, 603, 652, - 653, 640, 652, 653, 669, 588, 653, 646, 654, 589, - 664, 654, 600, 666, 654, 655, 589, 652, 655, 665, - 656, 655, 670, 656, 588, 641, 656, 657, 652, 676, - 657, 675, 653, 657, 664, 680, 664, 679, 681, 666, - 654, 682, 688, 698, 653, 665, 670, 655, 683, 687, - 692, 683, 656, 665, 683, 675, 697, 684, 701, 657, - 684, 679, 702, 684, 704, 725, 681, 687, 688, 680, - 703, 744, 710, 739, 697, 687, 701, 683, 744, 682, - - 683, 709, 705, 725, 692, 705, 688, 698, 705, 684, - 719, 706, 703, 781, 706, 709, 684, 706, 710, 713, - 739, 723, 731, 713, 719, 705, 702, 709, 736, 733, - 727, 738, 704, 727, 705, 723, 727, 750, 728, 742, - 747, 728, 733, 706, 728, 731, 749, 740, 731, 727, - 740, 736, 753, 740, 738, 758, 742, 747, 750, 761, - 706, 751, 727, 749, 751, 742, 760, 751, 764, 766, - 728, 753, 769, 771, 758, 740, 772, 766, 753, 740, - 775, 762, 761, 751, 762, 760, 764, 762, 780, 773, - 769, 771, 773, 751, 764, 773, 782, 783, 772, 786, - - 779, 784, 775, 778, 784, 762, 775, 784, 795, 776, - 780, 795, 773, 762, 795, 774, 770, 768, 782, 767, - 765, 773, 763, 783, 759, 786, 757, 756, 784, 754, - 752, 748, 746, 784, 745, 743, 741, 737, 735, 734, - 795, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 799, 799, 799, 799, 799, 799, 799, - 799, 799, 799, 799, 799, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 801, 801, 801, - 801, 801, 801, 801, 801, 801, 801, 801, 801, 802, - 802, 802, 802, 802, 802, 802, 802, 802, 802, 802, - - 802, 804, 804, 804, 732, 804, 804, 804, 805, 805, - 729, 805, 805, 806, 726, 806, 806, 806, 806, 806, - 806, 806, 806, 806, 806, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 808, 808, 808, - 808, 808, 808, 808, 808, 808, 808, 808, 808, 809, - 809, 724, 809, 809, 810, 810, 721, 810, 810, 810, - 811, 811, 720, 811, 811, 812, 812, 717, 812, 812, - 812, 813, 813, 813, 813, 813, 813, 813, 813, 813, - 813, 813, 813, 814, 814, 814, 814, 814, 814, 814, - 814, 814, 814, 814, 814, 815, 715, 815, 815, 815, - - 815, 815, 815, 815, 815, 815, 815, 816, 714, 711, - 816, 816, 816, 816, 816, 816, 816, 816, 816, 817, - 817, 817, 817, 817, 817, 817, 817, 817, 817, 817, - 817, 818, 708, 707, 818, 818, 818, 818, 818, 818, - 818, 818, 818, 819, 819, 700, 819, 819, 820, 820, - 820, 699, 820, 820, 820, 821, 821, 696, 821, 825, - 825, 695, 825, 825, 694, 693, 825, 827, 827, 690, - 827, 827, 689, 686, 827, 829, 829, 685, 829, 829, - 678, 677, 829, 830, 830, 674, 830, 830, 673, 672, - 830, 831, 831, 671, 831, 831, 668, 667, 831, 659, - - 658, 651, 650, 649, 648, 645, 644, 643, 642, 635, - 634, 633, 632, 631, 630, 623, 622, 617, 616, 615, - 614, 613, 612, 605, 604, 596, 595, 594, 592, 591, - 590, 571, 570, 569, 568, 567, 566, 559, 558, 557, - 556, 555, 554, 553, 552, 551, 550, 549, 548, 541, - 540, 539, 538, 537, 536, 526, 525, 524, 523, 521, - 520, 519, 500, 499, 498, 497, 496, 495, 494, 493, - 486, 485, 484, 483, 482, 481, 480, 479, 478, 477, - 476, 475, 474, 473, 466, 465, 464, 463, 462, 461, - 450, 449, 448, 447, 446, 445, 444, 443, 442, 428, - - 420, 419, 418, 417, 416, 415, 414, 413, 412, 405, - 404, 403, 402, 401, 400, 399, 398, 397, 396, 395, - 394, 393, 392, 391, 383, 382, 381, 380, 379, 378, - 368, 367, 365, 364, 363, 361, 360, 358, 352, 344, - 336, 332, 331, 330, 329, 326, 322, 318, 317, 316, - 315, 312, 311, 310, 309, 306, 302, 297, 296, 295, - 292, 281, 276, 274, 273, 272, 271, 270, 264, 247, - 242, 235, 234, 233, 232, 229, 228, 227, 226, 220, - 219, 217, 215, 214, 213, 206, 205, 203, 201, 200, - 199, 197, 195, 194, 193, 190, 184, 183, 182, 179, - - 174, 173, 171, 170, 169, 159, 157, 148, 147, 146, - 145, 144, 142, 124, 110, 109, 108, 107, 101, 100, - 99, 98, 97, 96, 95, 87, 86, 85, 84, 83, - 82, 81, 78, 77, 76, 75, 74, 73, 72, 71, - 70, 68, 56, 52, 49, 48, 47, 46, 45, 44, - 33, 32, 31, 30, 27, 23, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - - 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - 797, 797, 797, 797, 797 + 142, 142, 145, 142, 146, 145, 142, 146, 145, 174, + 146, 190, 221, 218, 222, 253, 219, 220, 232, 234, + 233, 242, 242, 221, 218, 222, 190, 219, 220, 232, + 234, 233, 142, 218, 145, 174, 146, 252, 232, 235, + 236, 174, 800, 146, 221, 174, 268, 145, 221, 219, + 235, 236, 220, 233, 234, 241, 241, 222, 256, 259, + 259, 256, 253, 241, 256, 261, 190, 262, 263, 292, + 263, 235, 268, 252, 796, 235, 242, 252, 257, 258, + + 258, 257, 258, 236, 257, 258, 264, 264, 269, 264, + 256, 293, 264, 269, 261, 292, 262, 265, 265, 263, + 265, 266, 266, 265, 266, 444, 270, 266, 405, 270, + 257, 258, 270, 320, 270, 294, 294, 271, 264, 269, + 271, 272, 273, 271, 272, 273, 300, 272, 273, 265, + 444, 274, 337, 266, 274, 405, 275, 274, 270, 275, + 302, 276, 275, 337, 276, 277, 293, 276, 277, 271, + 320, 277, 300, 272, 273, 278, 280, 299, 278, 280, + 301, 278, 280, 274, 281, 298, 302, 281, 275, 305, + 281, 303, 271, 276, 302, 282, 283, 277, 282, 283, + + 278, 282, 283, 299, 298, 304, 301, 278, 280, 306, + 308, 298, 318, 299, 280, 305, 281, 303, 313, 316, + 308, 301, 401, 299, 281, 305, 706, 282, 283, 794, + 303, 304, 282, 313, 706, 306, 282, 314, 314, 304, + 322, 318, 401, 328, 283, 316, 335, 336, 338, 340, + 322, 339, 314, 328, 342, 316, 306, 335, 336, 338, + 340, 349, 339, 350, 342, 335, 351, 352, 353, 357, + 354, 358, 349, 313, 350, 355, 355, 351, 352, 353, + 349, 354, 360, 336, 361, 339, 445, 338, 356, 356, + 374, 363, 357, 336, 363, 364, 340, 363, 364, 350, + + 374, 364, 353, 400, 365, 365, 352, 365, 448, 350, + 365, 358, 368, 366, 400, 368, 366, 354, 368, 366, + 445, 358, 361, 363, 793, 360, 369, 364, 370, 369, + 355, 370, 369, 384, 370, 371, 365, 366, 371, 381, + 381, 371, 387, 372, 368, 366, 372, 385, 403, 372, + 364, 402, 386, 368, 384, 388, 448, 389, 369, 384, + 370, 390, 391, 368, 392, 399, 399, 371, 387, 442, + 442, 402, 370, 385, 371, 372, 791, 385, 386, 789, + 399, 388, 386, 389, 447, 403, 387, 390, 391, 419, + 392, 421, 449, 483, 596, 372, 422, 423, 424, 388, + + 419, 392, 421, 391, 389, 390, 425, 422, 423, 424, + 426, 434, 421, 436, 437, 446, 466, 425, 438, 439, + 440, 426, 434, 483, 436, 437, 422, 423, 441, 438, + 439, 440, 596, 449, 436, 447, 468, 450, 450, 441, + 450, 785, 466, 450, 437, 424, 783, 426, 438, 446, + 425, 451, 452, 453, 451, 452, 453, 451, 452, 453, + 484, 524, 468, 467, 440, 441, 439, 454, 455, 450, + 454, 455, 456, 454, 455, 456, 468, 451, 456, 469, + 470, 471, 472, 451, 452, 453, 467, 452, 453, 467, + 473, 487, 474, 782, 475, 484, 482, 625, 485, 454, + + 455, 486, 501, 625, 456, 469, 470, 471, 472, 482, + 524, 523, 502, 501, 456, 472, 473, 455, 474, 454, + 475, 485, 471, 502, 469, 487, 470, 473, 486, 503, + 504, 505, 474, 506, 507, 502, 515, 516, 475, 517, + 503, 504, 505, 518, 506, 507, 520, 515, 516, 522, + 517, 519, 521, 525, 518, 523, 526, 520, 527, 558, + 516, 545, 519, 521, 505, 542, 684, 543, 728, 503, + 506, 528, 728, 780, 528, 504, 522, 528, 507, 517, + 684, 719, 558, 520, 519, 544, 529, 545, 518, 529, + 525, 542, 529, 543, 542, 530, 521, 526, 530, 528, + + 543, 530, 531, 528, 532, 531, 527, 532, 531, 533, + 532, 544, 533, 546, 557, 533, 547, 548, 529, 577, + 560, 549, 550, 544, 559, 562, 575, 530, 778, 719, + 577, 529, 595, 557, 531, 597, 532, 575, 594, 546, + 531, 533, 547, 548, 560, 530, 532, 549, 550, 562, + 547, 576, 559, 578, 546, 575, 550, 577, 533, 579, + 580, 587, 576, 548, 578, 588, 589, 590, 591, 592, + 579, 580, 587, 593, 595, 594, 588, 589, 590, 591, + 592, 598, 740, 599, 576, 597, 599, 578, 759, 599, + 587, 774, 612, 600, 580, 759, 600, 792, 588, 600, + + 740, 590, 613, 592, 589, 579, 593, 601, 612, 792, + 601, 614, 615, 601, 591, 599, 616, 599, 612, 598, + 602, 603, 617, 602, 603, 600, 602, 603, 613, 604, + 618, 600, 604, 626, 644, 604, 645, 614, 615, 601, + 646, 613, 616, 647, 643, 644, 648, 645, 617, 662, + 601, 646, 602, 603, 647, 643, 618, 648, 615, 602, + 643, 604, 626, 655, 656, 657, 658, 659, 604, 660, + 661, 772, 603, 644, 655, 656, 657, 658, 659, 655, + 660, 667, 668, 669, 667, 668, 669, 667, 668, 669, + 661, 670, 662, 671, 670, 672, 671, 670, 672, 671, + + 685, 672, 667, 656, 679, 680, 681, 691, 695, 690, + 694, 697, 696, 667, 668, 669, 718, 702, 691, 695, + 690, 694, 707, 670, 685, 671, 668, 672, 679, 771, + 679, 680, 681, 690, 694, 702, 703, 776, 718, 680, + 696, 691, 695, 702, 698, 699, 712, 698, 699, 697, + 698, 699, 713, 724, 716, 717, 707, 712, 735, 725, + 776, 770, 703, 713, 712, 716, 717, 724, 720, 735, + 770, 720, 716, 698, 720, 721, 698, 699, 721, 724, + 703, 721, 739, 734, 699, 725, 742, 738, 746, 742, + 754, 720, 742, 739, 734, 748, 713, 734, 738, 717, + + 720, 738, 751, 743, 753, 742, 743, 721, 748, 743, + 769, 746, 757, 751, 746, 753, 755, 754, 742, 755, + 762, 765, 755, 764, 721, 751, 767, 753, 768, 757, + 766, 762, 773, 766, 764, 743, 766, 762, 757, 775, + 764, 781, 765, 773, 755, 779, 784, 768, 755, 781, + 775, 773, 766, 777, 768, 786, 777, 784, 775, 777, + 787, 790, 766, 779, 784, 798, 786, 795, 797, 788, + 806, 779, 788, 786, 801, 788, 763, 777, 795, 797, + 761, 806, 787, 790, 808, 777, 760, 790, 758, 795, + 797, 798, 788, 799, 756, 808, 799, 752, 750, 799, + + 801, 788, 810, 749, 747, 810, 744, 741, 810, 736, + 732, 730, 729, 726, 723, 722, 715, 714, 711, 710, + 799, 709, 708, 705, 704, 799, 701, 700, 693, 692, + 689, 688, 687, 686, 810, 813, 813, 813, 813, 813, + 813, 813, 813, 813, 813, 813, 813, 814, 814, 814, + 814, 814, 814, 814, 814, 814, 814, 814, 814, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 816, 816, 816, 816, 816, 816, 816, 816, 816, + 816, 816, 816, 817, 817, 817, 817, 817, 817, 817, + 817, 817, 817, 817, 817, 819, 819, 819, 683, 819, + + 819, 819, 820, 820, 682, 820, 820, 821, 674, 821, + 821, 821, 821, 821, 821, 821, 821, 821, 821, 822, + 822, 822, 822, 822, 822, 822, 822, 822, 822, 822, + 822, 823, 823, 823, 823, 823, 823, 823, 823, 823, + 823, 823, 823, 824, 824, 673, 824, 824, 825, 825, + 666, 825, 825, 825, 826, 826, 665, 826, 826, 827, + 827, 664, 827, 827, 827, 828, 828, 828, 828, 828, + 828, 828, 828, 828, 828, 828, 828, 829, 829, 829, + 829, 829, 829, 829, 829, 829, 829, 829, 829, 830, + 663, 830, 830, 830, 830, 830, 830, 830, 830, 830, + + 830, 831, 650, 649, 831, 831, 831, 831, 831, 831, + 831, 831, 831, 832, 832, 832, 832, 832, 832, 832, + 832, 832, 832, 832, 832, 833, 638, 637, 833, 833, + 833, 833, 833, 833, 833, 833, 833, 834, 834, 632, + 834, 834, 835, 835, 835, 631, 835, 835, 835, 836, + 836, 630, 836, 840, 840, 629, 840, 840, 628, 627, + 840, 842, 842, 620, 842, 842, 619, 611, 842, 844, + 844, 610, 844, 844, 609, 607, 844, 845, 845, 606, + 845, 845, 605, 586, 845, 846, 846, 585, 846, 846, + 584, 583, 846, 582, 581, 574, 573, 572, 571, 570, + + 569, 568, 567, 566, 565, 564, 563, 556, 555, 554, + 553, 552, 551, 541, 540, 539, 538, 536, 535, 534, + 514, 513, 512, 511, 510, 509, 508, 500, 499, 498, + 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, + 481, 480, 479, 478, 477, 476, 465, 464, 463, 462, + 461, 460, 459, 458, 457, 443, 435, 433, 432, 431, + 430, 429, 428, 427, 420, 418, 417, 416, 415, 414, + 413, 412, 411, 410, 409, 408, 407, 406, 398, 397, + 396, 395, 394, 393, 383, 382, 380, 379, 378, 376, + 375, 373, 367, 359, 347, 346, 345, 344, 341, 333, + + 332, 331, 330, 327, 326, 325, 324, 321, 317, 312, + 311, 310, 307, 296, 291, 289, 288, 287, 286, 285, + 279, 260, 255, 248, 247, 246, 245, 244, 243, 240, + 239, 238, 237, 230, 228, 226, 225, 224, 216, 214, + 212, 211, 210, 208, 206, 205, 204, 201, 195, 194, + 193, 192, 191, 188, 183, 182, 180, 179, 178, 168, + 166, 155, 154, 153, 152, 151, 149, 130, 115, 114, + 113, 112, 104, 103, 102, 101, 100, 99, 89, 88, + 87, 86, 85, 84, 81, 80, 79, 78, 77, 76, + 74, 73, 72, 70, 58, 53, 50, 49, 48, 47, + + 46, 45, 34, 32, 31, 30, 27, 23, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, + 812, 812, 812, 812, 812, 812, 812 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[46] = +static yyconst flex_int32_t yy_rule_can_match_eol[48] = { 0, -0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 0, 0, }; +0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, }; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. @@ -1279,6 +1315,7 @@ extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt); //static const char* rgbInput; //static size_t cbInput; +extern "C" { int lineError; int errorParse; @@ -1289,6 +1326,8 @@ enum { errorUnsupportedFeature, }; +} + #define YY_EXTRA_TYPE lex_t* /* Read from buffer */ @@ -1312,7 +1351,7 @@ static const char* fixup_escapes (const char* sz); -#line 1316 "<stdout>" +#line 1355 "<stdout>" #define INITIAL 0 #define S_DEF 1 @@ -1326,11 +1365,13 @@ static const char* fixup_escapes (const char* sz); #define S_RVALUE 9 #define S_TASK 10 +#ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ #include <unistd.h> +#endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * @@ -1370,6 +1411,8 @@ struct yyguts_t }; /* end struct yyguts_t */ +static int yy_init_globals (yyscan_t yyscanner ); + /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ @@ -1541,10 +1584,10 @@ YY_DECL register int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; -#line 159 "bitbakescanner.l" +#line 164 "bitbakescanner.l" -#line 1548 "<stdout>" +#line 1591 "<stdout>" if ( yyg->yy_init ) { @@ -1597,13 +1640,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 798 ) + if ( yy_current_state >= 813 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_current_state != 797 ); + while ( yy_current_state != 812 ); yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; @@ -1637,44 +1680,56 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 161 "bitbakescanner.l" +#line 166 "bitbakescanner.l" { BEGIN S_RVALUE; yyextra->accept (T_OP_APPEND); } YY_BREAK case 2: YY_RULE_SETUP -#line 163 "bitbakescanner.l" +#line 168 "bitbakescanner.l" { BEGIN S_RVALUE; yyextra->accept (T_OP_PREPEND); } YY_BREAK case 3: YY_RULE_SETUP -#line 165 "bitbakescanner.l" +#line 170 "bitbakescanner.l" { BEGIN S_RVALUE; yyextra->accept (T_OP_IMMEDIATE); } YY_BREAK case 4: YY_RULE_SETUP -#line 167 "bitbakescanner.l" +#line 172 "bitbakescanner.l" { BEGIN S_RVALUE; yyextra->accept (T_OP_ASSIGN); } YY_BREAK case 5: YY_RULE_SETUP -#line 169 "bitbakescanner.l" +#line 174 "bitbakescanner.l" { BEGIN S_RVALUE; - yyextra->accept (T_OP_COND); } + yyextra->accept (T_OP_PREDOT); } YY_BREAK case 6: -/* rule 6 can match eol */ YY_RULE_SETUP -#line 172 "bitbakescanner.l" -{ } +#line 176 "bitbakescanner.l" +{ BEGIN S_RVALUE; + yyextra->accept (T_OP_POSTDOT); } YY_BREAK case 7: -/* rule 7 can match eol */ YY_RULE_SETUP -#line 173 "bitbakescanner.l" +#line 178 "bitbakescanner.l" +{ BEGIN S_RVALUE; + yyextra->accept (T_OP_COND); } + YY_BREAK +case 8: +/* rule 8 can match eol */ +YY_RULE_SETUP +#line 181 "bitbakescanner.l" +{ } + YY_BREAK +case 9: +/* rule 9 can match eol */ +YY_RULE_SETUP +#line 182 "bitbakescanner.l" { BEGIN INITIAL; size_t cb = yyleng; while (cb && isspace (yytext[cb - 1])) @@ -1682,10 +1737,10 @@ YY_RULE_SETUP yytext[cb - 1] = 0; yyextra->accept (T_STRING, yytext + 1); } YY_BREAK -case 8: -/* rule 8 can match eol */ +case 10: +/* rule 10 can match eol */ YY_RULE_SETUP -#line 179 "bitbakescanner.l" +#line 188 "bitbakescanner.l" { BEGIN INITIAL; size_t cb = yyleng; while (cb && isspace (yytext[cb - 1])) @@ -1693,208 +1748,208 @@ YY_RULE_SETUP yytext[cb - 1] = 0; yyextra->accept (T_STRING, yytext + 1); } YY_BREAK -case 9: -/* rule 9 can match eol */ +case 11: +/* rule 11 can match eol */ YY_RULE_SETUP -#line 186 "bitbakescanner.l" +#line 195 "bitbakescanner.l" { ERROR (errorUnexpectedInput); } YY_BREAK -case 10: -/* rule 10 can match eol */ +case 12: +/* rule 12 can match eol */ YY_RULE_SETUP -#line 187 "bitbakescanner.l" +#line 196 "bitbakescanner.l" { BEGIN INITIAL; yyextra->accept (T_STRING, NULL); } YY_BREAK -case 11: +case 13: YY_RULE_SETUP -#line 190 "bitbakescanner.l" +#line 199 "bitbakescanner.l" { BEGIN S_INCLUDE; yyextra->accept (T_INCLUDE); } YY_BREAK -case 12: +case 14: YY_RULE_SETUP -#line 192 "bitbakescanner.l" +#line 201 "bitbakescanner.l" { BEGIN S_REQUIRE; yyextra->accept (T_REQUIRE); } YY_BREAK -case 13: +case 15: YY_RULE_SETUP -#line 194 "bitbakescanner.l" +#line 203 "bitbakescanner.l" { BEGIN S_INHERIT; yyextra->accept (T_INHERIT); } YY_BREAK -case 14: +case 16: YY_RULE_SETUP -#line 196 "bitbakescanner.l" +#line 205 "bitbakescanner.l" { BEGIN S_TASK; yyextra->accept (T_ADDTASK); } YY_BREAK -case 15: +case 17: YY_RULE_SETUP -#line 198 "bitbakescanner.l" +#line 207 "bitbakescanner.l" { yyextra->accept (T_ADDHANDLER); } YY_BREAK -case 16: +case 18: YY_RULE_SETUP -#line 199 "bitbakescanner.l" +#line 208 "bitbakescanner.l" { BEGIN S_FUNC; yyextra->accept (T_EXPORT_FUNC); } YY_BREAK -case 17: +case 19: YY_RULE_SETUP -#line 201 "bitbakescanner.l" +#line 210 "bitbakescanner.l" { yyextra->accept (T_BEFORE); } YY_BREAK -case 18: +case 20: YY_RULE_SETUP -#line 202 "bitbakescanner.l" +#line 211 "bitbakescanner.l" { yyextra->accept (T_AFTER); } YY_BREAK -case 19: +case 21: YY_RULE_SETUP -#line 203 "bitbakescanner.l" +#line 212 "bitbakescanner.l" { yyextra->accept (T_EXPORT); } YY_BREAK -case 20: +case 22: YY_RULE_SETUP -#line 205 "bitbakescanner.l" +#line 214 "bitbakescanner.l" { yyextra->accept (T_FAKEROOT); } YY_BREAK -case 21: +case 23: YY_RULE_SETUP -#line 206 "bitbakescanner.l" +#line 215 "bitbakescanner.l" { yyextra->accept (T_PYTHON); } YY_BREAK -case 22: -/* rule 22 can match eol */ +case 24: +/* rule 24 can match eol */ YY_RULE_SETUP -#line 207 "bitbakescanner.l" +#line 216 "bitbakescanner.l" { BEGIN S_PROC; yyextra->accept (T_PROC_OPEN); } YY_BREAK -case 23: -/* rule 23 can match eol */ +case 25: +/* rule 25 can match eol */ YY_RULE_SETUP -#line 209 "bitbakescanner.l" +#line 218 "bitbakescanner.l" { BEGIN INITIAL; yyextra->accept (T_PROC_CLOSE); } YY_BREAK -case 24: -/* rule 24 can match eol */ +case 26: +/* rule 26 can match eol */ YY_RULE_SETUP -#line 211 "bitbakescanner.l" +#line 220 "bitbakescanner.l" { yyextra->accept (T_PROC_BODY, yytext); } YY_BREAK -case 25: +case 27: YY_RULE_SETUP -#line 213 "bitbakescanner.l" +#line 222 "bitbakescanner.l" { BEGIN S_DEF; } YY_BREAK -case 26: +case 28: YY_RULE_SETUP -#line 214 "bitbakescanner.l" +#line 223 "bitbakescanner.l" { BEGIN S_DEF_ARGS; yyextra->accept (T_SYMBOL, yytext); } YY_BREAK -case 27: +case 29: YY_RULE_SETUP -#line 216 "bitbakescanner.l" +#line 225 "bitbakescanner.l" { yyextra->accept (T_DEF_ARGS, yytext); } YY_BREAK -case 28: -/* rule 28 can match eol */ +case 30: +/* rule 30 can match eol */ YY_RULE_SETUP -#line 217 "bitbakescanner.l" +#line 226 "bitbakescanner.l" { BEGIN S_DEF_BODY; } YY_BREAK -case 29: -/* rule 29 can match eol */ +case 31: +/* rule 31 can match eol */ YY_RULE_SETUP -#line 218 "bitbakescanner.l" +#line 227 "bitbakescanner.l" { yyextra->accept (T_DEF_BODY, yytext); } YY_BREAK -case 30: -/* rule 30 can match eol */ +case 32: +/* rule 32 can match eol */ YY_RULE_SETUP -#line 219 "bitbakescanner.l" +#line 228 "bitbakescanner.l" { yyextra->accept (T_DEF_BODY, yytext); } YY_BREAK -case 31: +case 33: YY_RULE_SETUP -#line 220 "bitbakescanner.l" +#line 229 "bitbakescanner.l" { BEGIN INITIAL; unput (yytext[0]); } YY_BREAK -case 32: -/* rule 32 can match eol */ +case 34: +/* rule 34 can match eol */ YY_RULE_SETUP -#line 222 "bitbakescanner.l" +#line 231 "bitbakescanner.l" { } YY_BREAK -case 33: +case 35: YY_RULE_SETUP -#line 224 "bitbakescanner.l" +#line 233 "bitbakescanner.l" { yyextra->accept (T_SYMBOL, yytext); } YY_BREAK -case 34: +case 36: YY_RULE_SETUP -#line 225 "bitbakescanner.l" +#line 234 "bitbakescanner.l" { yyextra->accept (T_VARIABLE, yytext); } YY_BREAK -case 35: +case 37: YY_RULE_SETUP -#line 227 "bitbakescanner.l" +#line 236 "bitbakescanner.l" { yyextra->accept (T_TSYMBOL, yytext); } YY_BREAK -case 36: +case 38: YY_RULE_SETUP -#line 228 "bitbakescanner.l" +#line 237 "bitbakescanner.l" { yyextra->accept (T_FSYMBOL, yytext); } YY_BREAK -case 37: +case 39: YY_RULE_SETUP -#line 229 "bitbakescanner.l" +#line 238 "bitbakescanner.l" { yyextra->accept (T_ISYMBOL, yytext); } YY_BREAK -case 38: +case 40: YY_RULE_SETUP -#line 230 "bitbakescanner.l" +#line 239 "bitbakescanner.l" { BEGIN INITIAL; yyextra->accept (T_ISYMBOL, yytext); } YY_BREAK -case 39: +case 41: YY_RULE_SETUP -#line 232 "bitbakescanner.l" +#line 241 "bitbakescanner.l" { BEGIN INITIAL; yyextra->accept (T_ISYMBOL, yytext); } YY_BREAK -case 40: -/* rule 40 can match eol */ +case 42: +/* rule 42 can match eol */ YY_RULE_SETUP -#line 234 "bitbakescanner.l" +#line 243 "bitbakescanner.l" { BEGIN INITIAL; } YY_BREAK -case 41: -/* rule 41 can match eol */ +case 43: +/* rule 43 can match eol */ YY_RULE_SETUP -#line 235 "bitbakescanner.l" +#line 244 "bitbakescanner.l" { BEGIN INITIAL; } YY_BREAK -case 42: -/* rule 42 can match eol */ +case 44: +/* rule 44 can match eol */ YY_RULE_SETUP -#line 236 "bitbakescanner.l" +#line 245 "bitbakescanner.l" { BEGIN INITIAL; } YY_BREAK -case 43: -/* rule 43 can match eol */ +case 45: +/* rule 45 can match eol */ YY_RULE_SETUP -#line 238 "bitbakescanner.l" +#line 247 "bitbakescanner.l" /* Insignificant whitespace */ YY_BREAK -case 44: +case 46: YY_RULE_SETUP -#line 240 "bitbakescanner.l" +#line 249 "bitbakescanner.l" { ERROR (errorUnexpectedInput); } YY_BREAK /* Check for premature termination */ @@ -1909,15 +1964,15 @@ case YY_STATE_EOF(S_REQUIRE): case YY_STATE_EOF(S_PROC): case YY_STATE_EOF(S_RVALUE): case YY_STATE_EOF(S_TASK): -#line 243 "bitbakescanner.l" +#line 252 "bitbakescanner.l" { return T_EOF; } YY_BREAK -case 45: +case 47: YY_RULE_SETUP -#line 245 "bitbakescanner.l" +#line 254 "bitbakescanner.l" ECHO; YY_BREAK -#line 1921 "<stdout>" +#line 1976 "<stdout>" case YY_END_OF_BUFFER: { @@ -2103,7 +2158,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { - size_t num_to_read = + int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) @@ -2202,7 +2257,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 798 ) + if ( yy_current_state >= 813 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -2231,11 +2286,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 798 ) + if ( yy_current_state >= 813 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 797); + yy_is_jam = (yy_current_state == 812); return yy_is_jam ? 0 : yy_current_state; } @@ -2675,10 +2730,10 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscann * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ -YY_BUFFER_STATE yy_scan_string (yyconst char * str , yyscan_t yyscanner) +YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner) { - return yy_scan_bytes(str,strlen(str) ,yyscanner); + return yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will @@ -3077,7 +3132,7 @@ void yyfree (void * ptr , yyscan_t yyscanner) #undef YY_DECL_IS_OURS #undef YY_DECL #endif -#line 245 "bitbakescanner.l" +#line 254 "bitbakescanner.l" @@ -3091,36 +3146,56 @@ void lex_t::accept (int token, const char* sz) parse (parser, token, t, this); } -int lex_t::line ()const +void lex_t::input (char *buf, int *result, int max_size) { - return yyget_lineno (scanner); + printf("lex_t::input %p %d\n", buf, max_size); + *result = fread(buf, 1, max_size, file); + printf("lex_t::input result %d\n", *result); } -void parse (FILE* file, PyObject* data) +int lex_t::line ()const { - void* parser = bbparseAlloc (malloc); - yyscan_t scanner; - lex_t lex; - - yylex_init (&scanner); - - lex.parser = parser; - lex.scanner = scanner; - lex.file = file; - lex.data = data; - lex.parse = bbparse; - yyset_extra (&lex, scanner); - + printf("lex_t::line\n"); + return yyget_lineno (scanner); +} - int result = yylex (scanner); - lex.accept (0); - bbparseTrace (NULL, NULL); +extern "C" { - if (result != T_EOF) - printf ("premature end of file\n"); + void parse (FILE* file, PyObject* data) + { + printf("parse bbparseAlloc\n"); + void* parser = bbparseAlloc (malloc); + yyscan_t scanner; + lex_t lex; + + printf("parse yylex_init\n"); + yylex_init (&scanner); + + lex.parser = parser; + lex.scanner = scanner; + lex.file = file; + lex.data = data; + lex.parse = bbparse; + printf("parse yyset_extra\n"); + yyset_extra (&lex, scanner); + + printf("parse yylex\n"); + int result = yylex (scanner); + + printf("parse result %d\n", result); + + lex.accept (0); + printf("parse lex.accept\n"); + bbparseTrace (NULL, NULL); + printf("parse bbparseTrace\n"); + + if (result != T_EOF) + printf ("premature end of file\n"); + + yylex_destroy (scanner); + bbparseFree (parser, free); + } - yylex_destroy (scanner); - bbparseFree (parser, free); } diff --git a/bitbake/lib/bb/parse/parse_c/bitbakescanner.l b/bitbake/lib/bb/parse/parse_c/bitbakescanner.l index 782bc57a0f..f69a7325c3 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakescanner.l +++ b/bitbake/lib/bb/parse/parse_c/bitbakescanner.l @@ -83,6 +83,7 @@ extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt); //static const char* rgbInput; //static size_t cbInput; +extern "C" { int lineError; int errorParse; @@ -93,6 +94,8 @@ enum { errorUnsupportedFeature, }; +} + #define YY_EXTRA_TYPE lex_t* /* Read from buffer */ @@ -112,6 +115,8 @@ static const char* fixup_escapes (const char* sz); C_SP [ \t] COMMENT #.*\n OP_ASSIGN "=" +OP_PREDOT ".=" +OP_POSTDOT "=." OP_IMMEDIATE ":=" OP_PREPEND "=+" OP_APPEND "+=" @@ -166,6 +171,10 @@ PROC \({C_SP}*\) yyextra->accept (T_OP_IMMEDIATE); } {OP_ASSIGN} { BEGIN S_RVALUE; yyextra->accept (T_OP_ASSIGN); } +{OP_PREDOT} { BEGIN S_RVALUE; + yyextra->accept (T_OP_PREDOT); } +{OP_POSTDOT} { BEGIN S_RVALUE; + yyextra->accept (T_OP_POSTDOT); } {OP_COND} { BEGIN S_RVALUE; yyextra->accept (T_OP_COND); } @@ -254,35 +263,55 @@ void lex_t::accept (int token, const char* sz) parse (parser, token, t, this); } +void lex_t::input (char *buf, int *result, int max_size) +{ + printf("lex_t::input %p %d\n", buf, max_size); + *result = fread(buf, 1, max_size, file); + printf("lex_t::input result %d\n", *result); +} + int lex_t::line ()const { + printf("lex_t::line\n"); return yyget_lineno (scanner); } -void parse (FILE* file, PyObject* data) -{ - void* parser = bbparseAlloc (malloc); - yyscan_t scanner; - lex_t lex; - yylex_init (&scanner); +extern "C" { + + void parse (FILE* file, PyObject* data) + { + printf("parse bbparseAlloc\n"); + void* parser = bbparseAlloc (malloc); + yyscan_t scanner; + lex_t lex; + + printf("parse yylex_init\n"); + yylex_init (&scanner); - lex.parser = parser; - lex.scanner = scanner; - lex.file = file; - lex.data = data; - lex.parse = bbparse; - yyset_extra (&lex, scanner); + lex.parser = parser; + lex.scanner = scanner; + lex.file = file; + lex.data = data; + lex.parse = bbparse; + printf("parse yyset_extra\n"); + yyset_extra (&lex, scanner); + printf("parse yylex\n"); + int result = yylex (scanner); + + printf("parse result %d\n", result); - int result = yylex (scanner); + lex.accept (0); + printf("parse lex.accept\n"); + bbparseTrace (NULL, NULL); + printf("parse bbparseTrace\n"); - lex.accept (0); - bbparseTrace (NULL, NULL); + if (result != T_EOF) + printf ("premature end of file\n"); - if (result != T_EOF) - printf ("premature end of file\n"); + yylex_destroy (scanner); + bbparseFree (parser, free); + } - yylex_destroy (scanner); - bbparseFree (parser, free); } diff --git a/bitbake/lib/bb/parse/parse_c/lexer.h b/bitbake/lib/bb/parse/parse_c/lexer.h index 0a985edf23..651f3a8618 100644 --- a/bitbake/lib/bb/parse/parse_c/lexer.h +++ b/bitbake/lib/bb/parse/parse_c/lexer.h @@ -24,30 +24,23 @@ THE USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef LEXER_H #define LEXER_H -/* - * The PyObject Token. Likely to be - * a bb.data implementation - */ -struct PyObject; - - -/** - * This is used by the Parser and Scanner - * of BitBake. - * The implementation and creation is done - * in the scanner. - */ +#include "Python.h" + +extern "C" { + struct lex_t { - void *parser; - void *scanner; - FILE *file; + void* parser; + void* scanner; + FILE* file; PyObject *data; + void* (*parse)(void*, int, token_t, lex_t*); - void accept(int token, const char* string = 0); + void accept(int token, const char* sz = NULL); void input(char *buf, int *result, int max_size); int line()const; }; +} #endif diff --git a/bitbake/lib/bb/parse/parse_c/lexerc.h b/bitbake/lib/bb/parse/parse_c/lexerc.h new file mode 100644 index 0000000000..0163a7d632 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/lexerc.h @@ -0,0 +1,17 @@ + +#ifndef LEXERC_H +#define LEXERC_H + +#include <stdio.h> + +extern int lineError; +extern int errorParse; + +typedef struct { + void *parser; + void *scanner; + FILE *file; + PyObject *data; +} lex_t; + +#endif diff --git a/bitbake/lib/bb/parse/parse_c/python_output.h b/bitbake/lib/bb/parse/parse_c/python_output.h index de7544cc9d..bf34527c0a 100644 --- a/bitbake/lib/bb/parse/parse_c/python_output.h +++ b/bitbake/lib/bb/parse/parse_c/python_output.h @@ -27,15 +27,19 @@ This is the glue: */ +extern "C" { + struct lex_t; extern void e_assign(lex_t*, const char*, const char*); extern void e_export(lex_t*, const char*); extern void e_immediate(lex_t*, const char*, const char*); extern void e_cond(lex_t*, const char*, const char*); -extern void e_assign(lex_t*, const char*, const char*); extern void e_prepend(lex_t*, const char*, const char*); extern void e_append(lex_t*, const char*, const char*); +extern void e_precat(lex_t*, const char*, const char*); +extern void e_postcat(lex_t*, const char*, const char*); + extern void e_addtask(lex_t*, const char*, const char*, const char*); extern void e_addhandler(lex_t*,const char*); extern void e_export_func(lex_t*, const char*); @@ -48,4 +52,5 @@ extern void e_proc_fakeroot(lex_t*, const char*, const char*); extern void e_def(lex_t*, const char*, const char*, const char*); extern void e_parse_error(lex_t*); +} #endif // PYTHON_OUTPUT_H diff --git a/bitbake/lib/bb/parse/parse_py/BBHandler.py b/bitbake/lib/bb/parse/parse_py/BBHandler.py index 422ce6f9ef..c82090fec0 100644 --- a/bitbake/lib/bb/parse/parse_py/BBHandler.py +++ b/bitbake/lib/bb/parse/parse_py/BBHandler.py @@ -21,9 +21,9 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.""" -import re, bb, os, sys +import re, bb, os, sys, time import bb.fetch, bb.build, bb.utils -from bb import debug, data, fetch, fatal +from bb import debug, data, fetch, fatal, methodpool from ConfHandler import include, localpath, obtain, init from bb.parse import ParseError @@ -44,6 +44,8 @@ __bbpath_found__ = 0 __classname__ = "" classes = [ None, ] +__parsed_methods__ = methodpool.get_parsed_dict() + def supports(fn, d): localfn = localpath(fn, d) return localfn[-3:] == ".bb" or localfn[-8:] == ".bbclass" or localfn[-4:] == ".inc" @@ -78,6 +80,7 @@ def handle(fn, d, include = 0): debug(2, "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": @@ -126,10 +129,10 @@ def handle(fn, d, include = 0): s = f.readline() if not s: break s = s.rstrip() - feeder(lineno, s, fn, d) + feeder(lineno, s, fn, base_name, d) if __inpython__: # add a blank line to close out any python definition - feeder(lineno + 1, "", fn, d) + feeder(lineno + 1, "", fn, base_name, d) if ext == ".bbclass": classes.remove(__classname__) else: @@ -156,9 +159,15 @@ def handle(fn, d, include = 0): set_additional_vars(fn, d, include) data.update_data(d) + all_handlers = {} for var in data.keys(d): + # try to add the handler + # if we added it remember the choiche if data.getVarFlag(var, 'handler', d): - bb.event.register(data.getVar(var, d)) + handler = data.getVar(var,d) + if bb.event.register(var,handler) == bb.event.Registered: + all_handlers[var] = handler + continue if not data.getVarFlag(var, 'task', d): @@ -172,12 +181,22 @@ def handle(fn, d, include = 0): 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) if oldfile: bb.data.setVar("FILE", oldfile, d) + + # we have parsed the bb class now + if ext == ".bbclass" or ext == ".inc": + __parsed_methods__[base_name] = 1 + return d -def 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__, __bbpath_found__, classes, bb, __residue__ if __infunc__: if s == '}': @@ -205,13 +224,22 @@ def feeder(lineno, s, fn, d): __body__.append(s) return else: - text = '\n'.join(__body__) - comp = bb.utils.better_compile(text, "<bb>", fn ) - bb.utils.better_exec(comp, __builtins__, text, 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 ) + 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 - 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 diff --git a/bitbake/lib/bb/shell.py b/bitbake/lib/bb/shell.py index b86dc9753c..93ad00d1ed 100644 --- a/bitbake/lib/bb/shell.py +++ b/bitbake/lib/bb/shell.py @@ -3,7 +3,8 @@ # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- ########################################################################## # -# Copyright (C) 2005 Michael 'Mickey' Lauer <mickey@Vanille.de>, Vanille Media +# Copyright (C) 2005-2006 Michael 'Mickey' Lauer <mickey@Vanille.de> +# Copyright (C) 2005-2006 Vanille Media # # This program is free software; you can redistribute it and/or modify it under # the terms of the GNU General Public License as published by the Free Software @@ -59,7 +60,7 @@ import sys, os, imp, readline, socket, httplib, urllib, commands, popen2, copy, imp.load_source( "bitbake", os.path.dirname( sys.argv[0] )+"/bitbake" ) from bb import data, parse, build, fatal -__version__ = "0.5.3" +__version__ = "0.5.3.1" __credits__ = """BitBake Shell Version %s (C) 2005 Michael 'Mickey' Lauer <mickey@Vanille.de> Type 'help' for more information, press CTRL-D to exit.""" % __version__ @@ -263,9 +264,10 @@ class BitBakeShellCommands: bbfile = params[0] print "SHELL: Parsing '%s'" % bbfile parse.update_mtime( bbfile ) - bb_data, fromCache = cooker.load_bbfile( bbfile ) - cooker.pkgdata[bbfile] = bb_data - if fromCache: + cooker.bb_cache.cacheValidUpdate(bbfile) + fromCache = cooker.bb_cache.loadData(bbfile, cooker) + cooker.bb_cache.sync() + if False: #from Cache print "SHELL: File has not been updated, not reparsing" else: print "SHELL: Parsed" @@ -307,7 +309,7 @@ class BitBakeShellCommands: what, globexpr = params if what == "files": self._checkParsed() - for key in globfilter( cooker.pkgdata.keys(), globexpr ): print key + for key in globfilter( cooker.status.pkg_fn.keys(), globexpr ): print key elif what == "providers": self._checkParsed() for key in globfilter( cooker.status.pkg_pn.keys(), globexpr ): print key @@ -374,7 +376,7 @@ SRC_URI = "" pasteBin.usage = "<index>" def pasteLog( self, params ): - """Send the last event exception error log (if there is one) to http://pastebin.com""" + """Send the last event exception error log (if there is one) to http://oe.pastebin.com""" if last_exception is None: print "SHELL: No Errors yet (Phew)..." else: @@ -432,7 +434,8 @@ SRC_URI = "" name, var = params bbfile = self._findProvider( name ) if bbfile is not None: - value = cooker.pkgdata[bbfile].getVar( var, 1 ) + the_data = cooker.bb_cache.loadDataFull(bbfile, cooker) + value = the_data.getVar( var, 1 ) print value else: print "ERROR: Nothing provides '%s'" % name @@ -442,13 +445,14 @@ SRC_URI = "" """Set contents of variable defined in providee's metadata""" name, var, value = params bbfile = self._findProvider( name ) - d = cooker.pkgdata[bbfile] if bbfile is not None: - data.setVar( var, value, d ) + print "ERROR: Sorry, this functionality is currently broken" + #d = cooker.pkgdata[bbfile] + #data.setVar( var, value, d ) # mark the change semi persistant - cooker.pkgdata.setDirty(bbfile, d) - print "OK" + #cooker.pkgdata.setDirty(bbfile, d) + #print "OK" else: print "ERROR: Nothing provides '%s'" % name poke.usage = "<providee> <variable> <value>" @@ -458,7 +462,7 @@ SRC_URI = "" what = params[0] if what == "files": self._checkParsed() - for key in cooker.pkgdata.keys(): print key + for key in cooker.status.pkg_fn.keys(): print key elif what == "providers": self._checkParsed() for key in cooker.status.providers.keys(): print key @@ -555,14 +559,14 @@ SRC_URI = "" def completeFilePath( bbfile ): """Get the complete bbfile path""" - if not cooker.pkgdata: return bbfile - for key in cooker.pkgdata.keys(): + if not cooker.status.pkg_fn: return bbfile + for key in cooker.status.pkg_fn.keys(): if key.endswith( bbfile ): return key return bbfile def sendToPastebin( content ): - """Send content to http://www.pastebin.com""" + """Send content to http://oe.pastebin.com""" mydata = {} mydata["parent_pid"] = "" mydata["format"] = "bash" @@ -572,7 +576,7 @@ def sendToPastebin( content ): params = urllib.urlencode( mydata ) headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"} - conn = httplib.HTTPConnection( "pastebin.com:80" ) + conn = httplib.HTTPConnection( "oe.pastebin.com:80" ) conn.request("POST", "/", params, headers ) response = conn.getresponse() @@ -594,10 +598,10 @@ def completer( text, state ): if u == "<variable>": allmatches = cooker.configuration.data.keys() elif u == "<bbfile>": - if cooker.pkgdata is None: allmatches = [ "(No Matches Available. Parsed yet?)" ] - else: allmatches = [ x.split("/")[-1] for x in cooker.pkgdata.keys() ] + if cooker.status.pkg_fn is None: allmatches = [ "(No Matches Available. Parsed yet?)" ] + else: allmatches = [ x.split("/")[-1] for x in cooker.status.pkg_fn.keys() ] elif u == "<providee>": - if cooker.pkgdata is None: allmatches = [ "(No Matches Available. Parsed yet?)" ] + if cooker.status.pkg_fn is None: allmatches = [ "(No Matches Available. Parsed yet?)" ] else: allmatches = cooker.status.providers.iterkeys() else: allmatches = [ "(No tab completion available for this command)" ] else: allmatches = [ "(No tab completion available for this command)" ] |