From b26a945734ce271aa7d443ff9e96fe2851b21138 Mon Sep 17 00:00:00 2001 From: Richard Purdie Date: Mon, 20 Mar 2006 17:45:11 +0000 Subject: Update to latest bitbake git-svn-id: https://svn.o-hand.com/repos/poky/trunk@309 311d38ba-8fff-0310-9ca6-ca027cbcb966 --- bitbake/lib/bb/parse/parse_c/BBHandler.py | 65 + bitbake/lib/bb/parse/parse_c/README.build | 12 + bitbake/lib/bb/parse/parse_c/__init__.py | 28 + bitbake/lib/bb/parse/parse_c/bitbakeparser.cc | 1105 +++++++++ bitbake/lib/bb/parse/parse_c/bitbakeparser.h | 27 + bitbake/lib/bb/parse/parse_c/bitbakeparser.l | 288 --- bitbake/lib/bb/parse/parse_c/bitbakeparser.py | 133 - bitbake/lib/bb/parse/parse_c/bitbakeparser.y | 66 +- bitbake/lib/bb/parse/parse_c/bitbakescanner.cc | 3126 ++++++++++++++++++++++++ bitbake/lib/bb/parse/parse_c/bitbakescanner.l | 288 +++ bitbake/lib/bb/parse/parse_c/lexer.h | 20 +- bitbake/lib/bb/parse/parse_c/python_output.h | 51 + bitbake/lib/bb/parse/parse_c/token.h | 23 +- 13 files changed, 4771 insertions(+), 461 deletions(-) create mode 100644 bitbake/lib/bb/parse/parse_c/BBHandler.py create mode 100644 bitbake/lib/bb/parse/parse_c/README.build create mode 100644 bitbake/lib/bb/parse/parse_c/__init__.py create mode 100644 bitbake/lib/bb/parse/parse_c/bitbakeparser.cc create mode 100644 bitbake/lib/bb/parse/parse_c/bitbakeparser.h delete mode 100644 bitbake/lib/bb/parse/parse_c/bitbakeparser.l delete mode 100644 bitbake/lib/bb/parse/parse_c/bitbakeparser.py create mode 100644 bitbake/lib/bb/parse/parse_c/bitbakescanner.cc create mode 100644 bitbake/lib/bb/parse/parse_c/bitbakescanner.l create mode 100644 bitbake/lib/bb/parse/parse_c/python_output.h (limited to 'bitbake/lib/bb/parse/parse_c') 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 +#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 +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: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** 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: +**
    +**
  • A pointer to the parser. This should be a pointer +** obtained from bbparseAlloc. +**
  • A pointer to a function used to reclaim memory obtained +** from malloc. +**
+*/ +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 %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 + ** { ... } // User supplied code + ** #line + ** 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 "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 754 "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 762 "bitbakeparser.c" + break; + case 15: +#line 104 "bitbakeparser.y" +{ e_addtask( lex, yymsp[0].minor.yy0.string(), NULL, NULL); + yymsp[0].minor.yy0.release_this();} +#line 768 "bitbakeparser.c" + break; + case 16: +#line 107 "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); +} +#line 775 "bitbakeparser.c" + break; + case 17: +#line 110 "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); +} +#line 782 "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); +} +#line 788 "bitbakeparser.c" + break; + case 22: +#line 119 "bitbakeparser.y" +{ e_export_func( lex, yymsp[0].minor.yy0.string()); yymsp[0].minor.yy0.release_this(); } +#line 793 "bitbakeparser.c" + break; + case 26: +#line 124 "bitbakeparser.y" +{ e_inherit( lex, yymsp[0].minor.yy0.string() ); yymsp[0].minor.yy0.release_this (); } +#line 798 "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); +} +#line 804 "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); +} +#line 810 "bitbakeparser.c" + break; + case 32: +#line 136 "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" + break; + case 33: +#line 141 "bitbakeparser.y" +{ yygotominor.yy0.assignString(0); } +#line 824 "bitbakeparser.c" + break; + case 34: +#line 143 "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); +} +#line 832 "bitbakeparser.c" + break; + case 35: +#line 146 "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); +} +#line 841 "bitbakeparser.c" + break; + case 36: +#line 149 "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); +} +#line 850 "bitbakeparser.c" + break; + case 37: +#line 153 "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); +} +#line 859 "bitbakeparser.c" + break; + case 38: +#line 157 "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" + break; + case 39: +#line 161 "bitbakeparser.y" +{ yygotominor.yy0.assignString( 0 ); } +#line 872 "bitbakeparser.c" + break; + case 40: +#line 163 "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" + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto); + if( yyact < YYNSTATE ){ +#ifdef NDEBUG + /* If we are not debugging and the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = yyact; + yymsp->major = yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } + }else if( yyact == YYNSTATE + YYNRULE + 1 ){ + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + bbparseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + bbparseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + bbparseARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 52 "bitbakeparser.y" + e_parse_error( lex ); +#line 938 "bitbakeparser.c" + bbparseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + bbparseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + bbparseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "bbparseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +void bbparse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + bbparseTOKENTYPE yyminor /* The value for the token */ + bbparseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ + int yyerrorhit = 0; /* True if yymajor has invoked an error */ + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ + /* if( yymajor==0 ) return; // not sure why this was here... */ + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + bbparseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,yymajor); + if( yyactyyerrcnt--; + if( yyendofinput && yypParser->yyidx>=0 ){ + yymajor = 0; + }else{ + yymajor = YYNOCODE; + } + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else if( yyact == YY_ERROR_ACTION ){ + int yymx; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_shift_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + }else{ + yy_accept(yypParser); + yymajor = YYNOCODE; + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +} diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.h b/bitbake/lib/bb/parse/parse_c/bitbakeparser.h new file mode 100644 index 0000000000..2e51702be8 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.h @@ -0,0 +1,27 @@ +#define T_SYMBOL 1 +#define T_VARIABLE 2 +#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 diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.l b/bitbake/lib/bb/parse/parse_c/bitbakeparser.l deleted file mode 100644 index ee4ce14839..0000000000 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.l +++ /dev/null @@ -1,288 +0,0 @@ -/* bbf.flex - - written by Marc Singer - 6 January 2005 - - 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. - - DESCRIPTION - ----------- - - flex lexer specification for a BitBake input file parser. - - Unfortunately, flex doesn't welcome comments within the rule sets. - I say unfortunately because this lexer is unreasonably complex and - comments would make the code much easier to comprehend. - - The BitBake grammar is not regular. In order to interpret all - of the available input files, the lexer maintains much state as it - parses. There are places where this lexer will emit tokens that - are invalid. The parser will tend to catch these. - - The lexer requires C++ at the moment. The only reason for this has - to do with a very small amount of managed state. Producing a C - lexer should be a reasonably easy task as long as the %reentrant - option is used. - - - NOTES - ----- - - o RVALUES. There are three kinds of RVALUES. There are unquoted - values, double quote enclosed strings, and single quote - strings. Quoted strings may contain unescaped quotes (of either - type), *and* any type may span more than one line by using a - continuation '\' at the end of the line. This requires us to - recognize all types of values with a single expression. - Moreover, the only reason to quote a value is to include - trailing or leading whitespace. Whitespace within a value is - preserved, ugh. - - o CLASSES. C_ patterns define classes. Classes ought not include - a repitition operator, instead letting the reference to the class - define the repitition count. - - C_SS - symbol start - C_SB - symbol body - C_SP - whitespace - -*/ - -%option never-interactive -%option yylineno -%option noyywrap -%option reentrant stack - - -%{ - -#include "token.h" -#include "lexer.h" -#include - -extern void *bbparseAlloc(void *(*mallocProc)(size_t)); -extern void bbparseFree(void *p, void (*freeProc)(void*)); -extern void *bbparseAlloc(void *(*mallocProc)(size_t)); -extern void *bbparse(void*, int, token_t, lex_t*); -extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt); - -//static const char* rgbInput; -//static size_t cbInput; - - -int lineError; -int errorParse; - -enum { - errorNone = 0, - errorUnexpectedInput, - errorUnsupportedFeature, -}; - -#define YY_EXTRA_TYPE lex_t* - - /* Read from buffer */ -#define YY_INPUT(buf,result,max_size) \ - { yyextra->input(buf, &result, max_size); } - -//#define YY_DECL static size_t yylex () - -#define ERROR(e) \ - do { lineError = yylineno; errorParse = e; yyterminate (); } while (0) - -static const char* fixup_escapes (const char* sz); - -%} - - -C_SP [ \t] -COMMENT #.*\n -OP_ASSIGN "=" -OP_IMMEDIATE ":=" -OP_PREPEND "=+" -OP_APPEND "+=" -OP_COND "?=" -B_OPEN "{" -B_CLOSE "}" - -K_ADDTASK "addtask" -K_ADDHANDLER "addhandler" -K_AFTER "after" -K_BEFORE "before" -K_DEF "def" -K_INCLUDE "include" -K_INHERIT "inherit" -K_PYTHON "python" -K_FAKEROOT "fakeroot" -K_EXPORT "export" -K_EXPORT_FUNC "EXPORT_FUNCTIONS" - -STRING \"([^\n\r]|"\\\n")*\" -SSTRING \'([^\n\r]|"\\\n")*\' -VALUE ([^'" \t\n])|([^'" \t\n]([^\n]|(\\\n))*[^'" \t\n]) - -C_SS [a-zA-Z_] -C_SB [a-zA-Z0-9_+-.] -REF $\{{C_SS}{C_SB}*\} -SYMBOL {C_SS}{C_SB}* -VARIABLE $?{C_SS}({C_SB}*|{REF})*(\[[a-zA-Z0-9_]*\])? -FILENAME ([a-zA-Z_./]|{REF})(([-+a-zA-Z0-9_./]*)|{REF})* - -PROC \({C_SP}*\) - -%s S_DEF -%s S_DEF_ARGS -%s S_DEF_BODY -%s S_FUNC -%s S_INCLUDE -%s S_INHERIT -%s S_PROC -%s S_RVALUE -%s S_TASK - -%% - -{OP_APPEND} { BEGIN S_RVALUE; - yyextra->accept (T_OP_APPEND); } -{OP_PREPEND} { BEGIN S_RVALUE; - yyextra->accept (T_OP_PREPEND); } -{OP_IMMEDIATE} { BEGIN S_RVALUE; - yyextra->accept (T_OP_IMMEDIATE); } -{OP_ASSIGN} { BEGIN S_RVALUE; - yyextra->accept (T_OP_ASSIGN); } -{OP_COND} { BEGIN S_RVALUE; - yyextra->accept (T_OP_COND); } - -\\\n{C_SP}* { } -{STRING} { BEGIN INITIAL; - size_t cb = yyleng; - while (cb && isspace (yytext[cb - 1])) - --cb; - yytext[cb - 1] = 0; - yyextra->accept (T_STRING, yytext + 1); } -{SSTRING} { BEGIN INITIAL; - size_t cb = yyleng; - while (cb && isspace (yytext[cb - 1])) - --cb; - yytext[cb - 1] = 0; - yyextra->accept (T_STRING, yytext + 1); } - -{VALUE} { ERROR (errorUnexpectedInput); } -{C_SP}*\n+ { BEGIN INITIAL; - yyextra->accept (T_STRING, NULL); } - -{K_INCLUDE} { BEGIN S_INCLUDE; - yyextra->accept (T_INCLUDE); } -{K_INHERIT} { BEGIN S_INHERIT; - yyextra->accept (T_INHERIT); } -{K_ADDTASK} { BEGIN S_TASK; - yyextra->accept (T_ADDTASK); } -{K_ADDHANDLER} { yyextra->accept (T_ADDHANDLER); } -{K_EXPORT_FUNC} { BEGIN S_FUNC; - yyextra->accept (T_EXPORT_FUNC); } -{K_BEFORE} { yyextra->accept (T_BEFORE); } -{K_AFTER} { yyextra->accept (T_AFTER); } -{K_EXPORT} { yyextra->accept (T_EXPORT); } - -{K_FAKEROOT} { yyextra->accept (T_FAKEROOT); } -{K_PYTHON} { yyextra->accept (T_PYTHON); } -{PROC}{C_SP}*{B_OPEN}{C_SP}*\n* { BEGIN S_PROC; - yyextra->accept (T_PROC_OPEN); } -{B_CLOSE}{C_SP}*\n* { BEGIN INITIAL; - yyextra->accept (T_PROC_CLOSE); } -([^}][^\n]*)?\n* { yyextra->accept (T_PROC_BODY, yytext); } - -{K_DEF} { BEGIN S_DEF; } -{SYMBOL} { BEGIN S_DEF_ARGS; - yyextra->accept (T_SYMBOL, yytext); } -[^\n:]*: { yyextra->accept (T_DEF_ARGS, yytext); } -{C_SP}*\n { BEGIN S_DEF_BODY; } -{C_SP}+[^\n]*\n { yyextra->accept (T_DEF_BODY, yytext); } -\n { yyextra->accept (T_DEF_BODY, yytext); } -. { BEGIN INITIAL; unput (yytext[0]); } - -{COMMENT} { } - -{SYMBOL} { yyextra->accept (T_SYMBOL, yytext); } -{VARIABLE} { yyextra->accept (T_VARIABLE, yytext); } - -{SYMBOL} { yyextra->accept (T_TSYMBOL, yytext); } -{SYMBOL} { yyextra->accept (T_FSYMBOL, yytext); } -{SYMBOL} { yyextra->accept (T_ISYMBOL, yytext); } -{FILENAME} { BEGIN INITIAL; - yyextra->accept (T_ISYMBOL, yytext); } - -\n { BEGIN INITIAL; } -\n { BEGIN INITIAL; } -\n { BEGIN INITIAL; } - -[ \t\r\n] /* Insignificant whitespace */ - -. { ERROR (errorUnexpectedInput); } - - /* Check for premature termination */ -<> { return T_EOF; } - -%% - -void lex_t::accept (int token, const char* sz) -{ - token_t t; - memset (&t, 0, sizeof (t)); - t.copyString(sz); - - /* tell lemon to parse the token */ - parse (parser, token, t, this); -} - -int lex_t::line ()const -{ - return yyget_lineno (scanner); -} - -const char* lex_t::filename ()const -{ - return m_fileName; -} - -void parse (MappedFile* mf) -{ - void* parser = bbparseAlloc (malloc); - yyscan_t scanner; - lex_t lex; - - yylex_init (&scanner); - - lex.parser = parser; - lex.scanner = scanner; - lex.mf = mf; - lex.rgbInput = mf->m_rgb; - lex.cbInput = mf->m_cb; - lex.parse = bbparse; - yyset_extra (&lex, scanner); - - - int result = yylex (scanner); - - lex.accept (0); - bbparseTrace (NULL, NULL); - - if (result != T_EOF) - WARNING ("premature end of file\n"); - - yylex_destroy (scanner); - bbparseFree (parser, free); -} diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.py b/bitbake/lib/bb/parse/parse_c/bitbakeparser.py deleted file mode 100644 index ed7b13eef9..0000000000 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.py +++ /dev/null @@ -1,133 +0,0 @@ -""" - -BitBake C Parser Python Code - -Copyright (C) 2005 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__ = "0xdeadbeef" - -class CParser: - """ - The C-based Parser for Bitbake - """ - def __init__(self, data, type): - """ - Constructor - """ - self._data = data - - def _syntax_error(self, file, line): - """ - lemon/flex reports an syntax error to us and we will - raise an exception - """ - pass - - def _export(self, data): - """ - EXPORT VAR = "MOO" - we will now export VAR - """ - pass - - def _assign(self, key, value): - """ - VAR = "MOO" - we will assign moo to VAR - """ - pass - - def _assign(self, key, value): - """ - """ - pass - - def _append(self, key, value): - """ - VAR += "MOO" - we will append " MOO" to var - """ - pass - - def _prepend(self, key, value): - """ - VAR =+ "MOO" - we will prepend "MOO " to var - """ - pass - - def _immediate(self, key, value): - """ - VAR := "MOO ${CVSDATE}" - we will assign immediately and expand vars - """ - pass - - def _conditional(self, key, value): - """ - """ - pass - - def _add_task(self, task, before = None, after = None): - """ - """ - pass - - def _include(self, file): - """ - """ - pass - - def _inherit(self, file): - """ - """ - pass - - def _shell_procedure(self, name, body): - """ - """ - pass - - def _python_procedure(self, name, body): - """ - """ - pass - - def _fakeroot_procedure(self, name, body): - """ - """ - pass - - def _def_procedure(self, a, b, c): - """ - """ - pass - - def _export_func(self, name): - """ - """ - pass - - def _add_handler(self, handler): - """ - """ - pass diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y index 4bc81a913a..252d87792f 100644 --- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y @@ -42,13 +42,14 @@ %include { #include "token.h" +#include "lexer.h" +#include "python_output.h" } %token_destructor { $$.release_this (); } -%syntax_error { printf ("%s:%d: syntax error\n", - lex->filename (), lex->line ()); } +%syntax_error { e_parse_error( lex ); } program ::= statements. @@ -56,79 +57,82 @@ statements ::= statements statement. statements ::= . variable(r) ::= SYMBOL(s). - { r.assignString( s.string() ); + { r.assignString( (char*)s.string() ); s.assignString( 0 ); s.release_this(); } variable(r) ::= VARIABLE(v). { - r.assignString( v.string() ); + r.assignString( (char*)v.string() ); v.assignString( 0 ); v.release_this(); } statement ::= EXPORT variable(s) OP_ASSIGN STRING(v). - { e_assign( s.string(), v.string() ); - e_export( s.string() ); + { e_assign( 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 (s.string(), v.string() ); - e_export( s.string() ); + { e_immediate ( lex, s.string(), v.string() ); + e_export( lex, s.string() ); s.release_this(); v.release_this(); } statement ::= EXPORT variable(s) OP_COND STRING(v). - { e_cond( s.string(), v.string() ); + { e_cond( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } statement ::= variable(s) OP_ASSIGN STRING(v). - { e_assign( s.string(), v.string() ); + { e_assign( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } statement ::= variable(s) OP_PREPEND STRING(v). - { e_prepend( s.string(), v.string() ); + { e_prepend( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } statement ::= variable(s) OP_APPEND STRING(v). - { e_append( s.string() , v.string() ); + { e_append( lex, s.string() , v.string() ); s.release_this(); v.release_this(); } statement ::= variable(s) OP_IMMEDIATE STRING(v). - { e_immediate( s.string(), v.string() ); + { e_immediate( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } statement ::= variable(s) OP_COND STRING(v). - { e_cond( s.string(), v.string() ); + { e_cond( lex, s.string(), v.string() ); s.release_this(); v.release_this(); } task ::= TSYMBOL(t) BEFORE TSYMBOL(b) AFTER TSYMBOL(a). - { e_addtask( t.string(), b.string(), a.string() ); + { e_addtask( lex, t.string(), b.string(), a.string() ); t.release_this(); b.release_this(); a.release_this(); } task ::= TSYMBOL(t) AFTER TSYMBOL(a) BEFORE TSYMBOL(b). - { e_addtask( t.string(), b.string(), a.string()); + { e_addtask( lex, t.string(), b.string(), a.string()); t.release_this(); a.release_this(); b.release_this(); } task ::= TSYMBOL(t). - { e_addtask( t.string(), NULL, NULL); + { e_addtask( lex, t.string(), NULL, NULL); t.release_this();} task ::= TSYMBOL(t) BEFORE TSYMBOL(b). - { e_addtask( t.string(), b.string(), NULL); + { e_addtask( lex, t.string(), b.string(), NULL); t.release_this(); b.release_this(); } task ::= TSYMBOL(t) AFTER TSYMBOL(a). - { e_addtask( t.string(), NULL, a.string()); + { e_addtask( lex, t.string(), NULL, a.string()); t.release_this(); a.release_this(); } tasks ::= tasks task. tasks ::= task. statement ::= ADDTASK tasks. statement ::= ADDHANDLER SYMBOL(s). - { e_addhandler( s.string()); s.release_this (); } + { e_addhandler( lex, s.string()); s.release_this (); } -func ::= FSYMBOL(f). { e_export_func(f.string()); f.release_