Update to bitbake 1.4.2 (latest stable branch release). This includes the caching speedups

git-svn-id: https://svn.o-hand.com/repos/poky/trunk@371 311d38ba-8fff-0310-9ca6-ca027cbcb966

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)" ]