Update to latest bitbake

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

13 files changed, 4497 insertions, 187 deletions

diff --git a/bitbake/lib/bb/parse/parse_c/BBHandler.py b/bitbake/lib/bb/parse/parse_c/BBHandler.py
new file mode 100644
index 0000000000..300871d9e3
--- /dev/null
+++ b/bitbake/lib/bb/parse/parse_c/BBHandler.py
@@ -0,0 +1,65 @@
+# 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.
+#
+
+from bb import data
+from bb.parse import ParseError
+
+#
+# This is the Python Part of the Native Parser Implementation.
+# We will only parse .bbclass, .inc and .bb files but no
+# configuration files.
+# supports, init and handle are the public methods used by
+# parser module
+#
+# The rest of the methods are internal implementation details.
+
+
+
+#
+# internal
+#
+
+
+#
+# public
+#
+def supports(fn, data):
+    return fn[-3:] == ".bb" or fn[-8:] == ".bbclass" or fn[-4:] == ".inc"
+
+def init(fn, data):
+    print "Init"
+
+def handle(fn, data, include):
+    print ""
+    print "fn: %s" % fn
+    print "data: %s" % data
+    print "include: %s" % include
+
+    pass
+
+# Inform bitbake that we are a parser
+# We need to define all three
+from bb.parse import handlers
+handlers.append( {'supports' : supports, 'handle': handle, 'init' : init})
+del handlers
diff --git a/bitbake/lib/bb/parse/parse_c/README.build b/bitbake/lib/bb/parse/parse_c/README.build
new file mode 100644
index 0000000000..eb6ad8c862
--- /dev/null
+++ b/bitbake/lib/bb/parse/parse_c/README.build
@@ -0,0 +1,12 @@
+To ease portability (lemon, flex, etc) we keep the
+result of flex and lemon in the source code. We agree
+to not manually change the scanner and parser.
+
+
+
+How we create the files:
+   flex -t bitbakescanner.l > bitbakescanner.cc
+   lemon bitbakeparser.y
+   mv bitbakeparser.c bitbakeparser.cc
+
+Now manually create two files
diff --git a/bitbake/lib/bb/parse/parse_c/__init__.py b/bitbake/lib/bb/parse/parse_c/__init__.py
new file mode 100644
index 0000000000..bbb318e51f
--- /dev/null
+++ b/bitbake/lib/bb/parse/parse_c/__init__.py
@@ -0,0 +1,28 @@
+# 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.
+#
+
+__version__ = '0.1'
+__all__     = [ 'BBHandler' ]
+
+import BBHandler
diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc b/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc
new file mode 100644
index 0000000000..3a3c53dd46
--- /dev/null
+++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc
@@ -0,0 +1,1105 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is include which follows the "include" declaration
+** in the input file. */
+#include <stdio.h>
+#line 43 "bitbakeparser.y"
+
+#include "token.h"
+#include "lexer.h"
+#include "python_output.h"
+#line 14 "bitbakeparser.c"
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/* 
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands. 
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 terminals
+**                       and nonterminals.  "int" is used otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE which corresponds
+**                       to no legal terminal or nonterminal number.  This
+**                       number is used to fill in empty slots of the hash 
+**                       table.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       have fall-back values which should be used if the
+**                       original value of the token will not parse.
+**    YYACTIONTYPE       is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 rules and
+**                       states combined.  "int" is used otherwise.
+**    bbparseTOKENTYPE     is the data type used for minor tokens given 
+**                       directly to the parser from the tokenizer.
+**    YYMINORTYPE        is the data type used for all minor tokens.
+**                       This is typically a union of many types, one of
+**                       which is bbparseTOKENTYPE.  The entry in the union
+**                       for base tokens is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.
+**    bbparseARG_SDECL     A static variable declaration for the %extra_argument
+**    bbparseARG_PDECL     A parameter declaration for the %extra_argument
+**    bbparseARG_STORE     Code to store %extra_argument into yypParser
+**    bbparseARG_FETCH     Code to extract %extra_argument from yypParser
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+*/
+#define YYCODETYPE unsigned char
+#define YYNOCODE 42
+#define YYACTIONTYPE unsigned char
+#define bbparseTOKENTYPE token_t
+typedef union {
+  bbparseTOKENTYPE yy0;
+  int yy83;
+} 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 YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
+#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
+#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)
+
+/* Next are that tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.  
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
+**
+**   N == YYNSTATE+YYNRULE              A syntax error has occurred.
+**
+**   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
+**
+**   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+**      yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.  
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  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,
+};
+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,
+};
+#define YY_SHIFT_USE_DFLT (-19)
+#define YY_SHIFT_MAX 43
+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,
+};
+#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,
+};
+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,
+};
+#define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0]))
+
+/* The next table maps tokens into fallback tokens.  If a construct
+** like the following:
+** 
+**      %fallback ID X Y Z.
+**
+** appears in the grammer, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+  int stateno;       /* The state-number */
+  int major;         /* The major token value.  This is the code
+                     ** number for the token at this stack level */
+  YYMINORTYPE minor; /* The user-supplied minor token value.  This
+                     ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+  int yyidx;                    /* Index of top element in stack */
+  int yyerrcnt;                 /* Shifts left before out of the error */
+  bbparseARG_SDECL                /* A place to hold %extra_argument */
+  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* 
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL 
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void bbparseTrace(FILE *TraceFILE, char *zTracePrompt){
+  yyTraceFILE = TraceFILE;
+  yyTracePrompt = zTracePrompt;
+  if( yyTraceFILE==0 ) yyTracePrompt = 0;
+  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** 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",    
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+ /*   0 */ "program ::= statements",
+ /*   1 */ "statements ::= statements statement",
+ /*   2 */ "statements ::=",
+ /*   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",
+};
+#endif /* NDEBUG */
+
+/*
+** This function returns the symbolic name associated with a token
+** value.
+*/
+const char *bbparseTokenName(int tokenType){
+#ifndef NDEBUG
+  if( tokenType>0 && tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){
+    return yyTokenName[tokenType];
+  }else{
+    return "Unknown";
+  }
+#else
+  return "";
+#endif
+}
+
+/* 
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to bbparse and bbparseFree.
+*/
+void *bbparseAlloc(void *(*mallocProc)(size_t)){
+  yyParser *pParser;
+  pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
+  if( pParser ){
+    pParser->yyidx = -1;
+  }
+  return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol.  The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){
+  switch( yymajor ){
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is 
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are not used
+    ** inside the C code.
+    */
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+#line 50 "bitbakeparser.y"
+{ (yypminor->yy0).release_this (); }
+#line 409 "bitbakeparser.c"
+      break;
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static int yy_pop_parser_stack(yyParser *pParser){
+  YYCODETYPE yymajor;
+  yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+  if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+  if( yyTraceFILE && pParser->yyidx>=0 ){
+    fprintf(yyTraceFILE,"%sPopping %s\n",
+      yyTracePrompt,
+      yyTokenName[yytos->major]);
+  }
+#endif
+  yymajor = yytos->major;
+  yy_destructor( yymajor, &yytos->minor);
+  pParser->yyidx--;
+  return yymajor;
+}
+
+/* 
+** Deallocate and destroy a parser.  Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li>  A pointer to the parser.  This should be a pointer
+**       obtained from bbparseAlloc.
+** <li>  A pointer to a function used to reclaim memory obtained
+**       from malloc.
+** </ul>
+*/
+void bbparseFree(
+  void *p,                    /* The parser to be deleted */
+  void (*freeProc)(void*)     /* Function used to reclaim memory */
+){
+  yyParser *pParser = (yyParser*)p;
+  if( pParser==0 ) return;
+  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+  (*freeProc)((void*)pParser);
+}
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_shift_action(
+  yyParser *pParser,        /* The parser */
+  int iLookAhead            /* The look-ahead token */
+){
+  int i;
+  int stateno = pParser->yystack[pParser->yyidx].stateno;
+ 
+  if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+    return yy_default[stateno];
+  }
+  if( iLookAhead==YYNOCODE ){
+    return YY_NO_ACTION;
+  }
+  i += iLookAhead;
+  if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
+#ifdef YYFALLBACK
+    int iFallback;            /* Fallback token */
+    if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+           && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+      if( yyTraceFILE ){
+        fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+           yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+      }
+#endif
+      return yy_find_shift_action(pParser, iFallback);
+    }
+#endif
+    return yy_default[stateno];
+  }else{
+    return yy_action[i];
+  }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_reduce_action(
+  int stateno,              /* Current state number */
+  int iLookAhead            /* The look-ahead token */
+){
+  int i;
+  /* int stateno = pParser->yystack[pParser->yyidx].stateno; */
+ 
+  if( stateno>YY_REDUCE_MAX ||
+      (i = yy_reduce_ofst[stateno])==YY_REDUCE_USE_DFLT ){
+    return yy_default[stateno];
+  }
+  if( iLookAhead==YYNOCODE ){
+    return YY_NO_ACTION;
+  }
+  i += iLookAhead;
+  if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
+    return yy_default[stateno];
+  }else{
+    return yy_action[i];
+  }
+}
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+  yyParser *yypParser,          /* The parser to be shifted */
+  int yyNewState,               /* The new state to shift in */
+  int yyMajor,                  /* The major token to shift in */
+  YYMINORTYPE *yypMinor         /* Pointer ot the minor token to shift in */
+){
+  yyStackEntry *yytos;
+  yypParser->yyidx++;
+  if( yypParser->yyidx>=YYSTACKDEPTH ){
+     bbparseARG_FETCH;
+     yypParser->yyidx--;
+#ifndef NDEBUG
+     if( yyTraceFILE ){
+       fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+     }
+#endif
+     while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+     /* Here code is inserted which will execute if the parser
+     ** stack every overflows */
+     bbparseARG_STORE; /* Suppress warning about unused %extra_argument var */
+     return;
+  }
+  yytos = &yypParser->yystack[yypParser->yyidx];
+  yytos->stateno = yyNewState;
+  yytos->major = yyMajor;
+  yytos->minor = *yypMinor;
+#ifndef NDEBUG
+  if( yyTraceFILE && yypParser->yyidx>0 ){
+    int i;
+    fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
+    fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
+    for(i=1; i<=yypParser->yyidx; i++)
+      fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
+    fprintf(yyTraceFILE,"\n");
+  }
+#endif
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+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 },
+  { 33, 3 },
+  { 33, 3 },
+  { 34, 2 },
+  { 34, 1 },
+  { 31, 2 },
+  { 31, 2 },
+  { 35, 1 },
+  { 36, 2 },
+  { 36, 1 },
+  { 31, 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 },
+  { 40, 2 },
+  { 40, 0 },
+  { 31, 3 },
+};
+
+static void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+  yyParser *yypParser,         /* The parser */
+  int yyruleno                 /* Number of the rule by which to reduce */
+){
+  int yygoto;                     /* The next state */
+  int yyact;                      /* The next action */
+  YYMINORTYPE yygotominor;        /* The LHS of the rule reduced */
+  yyStackEntry *yymsp;            /* The top of the parser's stack */
+  int yysize;                     /* Amount to pop the stack */
+  bbparseARG_FETCH;
+  yymsp = &yypParser->yystack[yypParser->yyidx];
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno>=0 
+        && yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){
+    fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
+      yyRuleName[yyruleno]);
+  }
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+  /* Silence complaints from purify about yygotominor being uninitialized
+  ** in some cases when it is copied into the stack after the following
+  ** switch.  yygotominor is uninitialized when a rule reduces that does
+  ** not set the value of its left-hand side nonterminal.  Leaving the
+  ** value of the nonterminal uninitialized is utterly harmless as long
+  ** as the value is never used.  So really the only thing this code
+  ** accomplishes is to quieten purify.  
+  */
+  memset(&yygotominor, 0, sizeof(yygotominor));
+#endif
+
+  switch( yyruleno ){
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+      case 3:
+#line 60 "bitbakeparser.y"
+{ 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"
+        break;
+      case 4:
+#line 64 "bitbakeparser.y"
+{
+          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"
+        break;
+      case 5:
+#line 70 "bitbakeparser.y"
+{ e_assign( 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(4,&yymsp[-1].minor);
+}
+#line 694 "bitbakeparser.c"
+        break;
+      case 6:
+#line 74 "bitbakeparser.y"
+{ 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(6,&yymsp[-1].minor);
+}
+#line 703 "bitbakeparser.c"
+        break;
+      case 7:
+#line 78 "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(7,&yymsp[-1].minor);
+}
+#line 711 "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);
+}
+#line 718 "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 725 "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 732 "bitbakeparser.c"
+        break;
+      case 11:
+#line 91 "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(6,&yymsp[-1].minor);
+}
+#line 739 "bitbakeparser.c"
+        break;
+      case 12:
+#line 94 "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(7,&yymsp[-1].minor);
+}
+#line 746 "bitbakepar