diff options
Diffstat (limited to 'bitbake/lib/bb/parse/parse_c')
-rw-r--r-- | bitbake/lib/bb/parse/parse_c/bitbakeparser.l | 288 | ||||
-rw-r--r-- | bitbake/lib/bb/parse/parse_c/bitbakeparser.py | 133 | ||||
-rw-r--r-- | bitbake/lib/bb/parse/parse_c/bitbakeparser.y | 161 | ||||
-rw-r--r-- | bitbake/lib/bb/parse/parse_c/lexer.h | 41 | ||||
-rw-r--r-- | bitbake/lib/bb/parse/parse_c/token.h | 83 |
5 files changed, 706 insertions, 0 deletions
diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.l b/bitbake/lib/bb/parse/parse_c/bitbakeparser.l new file mode 100644 index 0000000000..ee4ce14839 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.l | |||
@@ -0,0 +1,288 @@ | |||
1 | /* bbf.flex | ||
2 | |||
3 | written by Marc Singer | ||
4 | 6 January 2005 | ||
5 | |||
6 | This program is free software; you can redistribute it and/or | ||
7 | modify it under the terms of the GNU General Public License as | ||
8 | published by the Free Software Foundation; either version 2 of the | ||
9 | License, or (at your option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, but | ||
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program; if not, write to the Free Software | ||
18 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | ||
19 | USA. | ||
20 | |||
21 | DESCRIPTION | ||
22 | ----------- | ||
23 | |||
24 | flex lexer specification for a BitBake input file parser. | ||
25 | |||
26 | Unfortunately, flex doesn't welcome comments within the rule sets. | ||
27 | I say unfortunately because this lexer is unreasonably complex and | ||
28 | comments would make the code much easier to comprehend. | ||
29 | |||
30 | The BitBake grammar is not regular. In order to interpret all | ||
31 | of the available input files, the lexer maintains much state as it | ||
32 | parses. There are places where this lexer will emit tokens that | ||
33 | are invalid. The parser will tend to catch these. | ||
34 | |||
35 | The lexer requires C++ at the moment. The only reason for this has | ||
36 | to do with a very small amount of managed state. Producing a C | ||
37 | lexer should be a reasonably easy task as long as the %reentrant | ||
38 | option is used. | ||
39 | |||
40 | |||
41 | NOTES | ||
42 | ----- | ||
43 | |||
44 | o RVALUES. There are three kinds of RVALUES. There are unquoted | ||
45 | values, double quote enclosed strings, and single quote | ||
46 | strings. Quoted strings may contain unescaped quotes (of either | ||
47 | type), *and* any type may span more than one line by using a | ||
48 | continuation '\' at the end of the line. This requires us to | ||
49 | recognize all types of values with a single expression. | ||
50 | Moreover, the only reason to quote a value is to include | ||
51 | trailing or leading whitespace. Whitespace within a value is | ||
52 | preserved, ugh. | ||
53 | |||
54 | o CLASSES. C_ patterns define classes. Classes ought not include | ||
55 | a repitition operator, instead letting the reference to the class | ||
56 | define the repitition count. | ||
57 | |||
58 | C_SS - symbol start | ||
59 | C_SB - symbol body | ||
60 | C_SP - whitespace | ||
61 | |||
62 | */ | ||
63 | |||
64 | %option never-interactive | ||
65 | %option yylineno | ||
66 | %option noyywrap | ||
67 | %option reentrant stack | ||
68 | |||
69 | |||
70 | %{ | ||
71 | |||
72 | #include "token.h" | ||
73 | #include "lexer.h" | ||
74 | #include <ctype.h> | ||
75 | |||
76 | extern void *bbparseAlloc(void *(*mallocProc)(size_t)); | ||
77 | extern void bbparseFree(void *p, void (*freeProc)(void*)); | ||
78 | extern void *bbparseAlloc(void *(*mallocProc)(size_t)); | ||
79 | extern void *bbparse(void*, int, token_t, lex_t*); | ||
80 | extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt); | ||
81 | |||
82 | //static const char* rgbInput; | ||
83 | //static size_t cbInput; | ||
84 | |||
85 | |||
86 | int lineError; | ||
87 | int errorParse; | ||
88 | |||
89 | enum { | ||
90 | errorNone = 0, | ||
91 | errorUnexpectedInput, | ||
92 | errorUnsupportedFeature, | ||
93 | }; | ||
94 | |||
95 | #define YY_EXTRA_TYPE lex_t* | ||
96 | |||
97 | /* Read from buffer */ | ||
98 | #define YY_INPUT(buf,result,max_size) \ | ||
99 | { yyextra->input(buf, &result, max_size); } | ||
100 | |||
101 | //#define YY_DECL static size_t yylex () | ||
102 | |||
103 | #define ERROR(e) \ | ||
104 | do { lineError = yylineno; errorParse = e; yyterminate (); } while (0) | ||
105 | |||
106 | static const char* fixup_escapes (const char* sz); | ||
107 | |||
108 | %} | ||
109 | |||
110 | |||
111 | C_SP [ \t] | ||
112 | COMMENT #.*\n | ||
113 | OP_ASSIGN "=" | ||
114 | OP_IMMEDIATE ":=" | ||
115 | OP_PREPEND "=+" | ||
116 | OP_APPEND "+=" | ||
117 | OP_COND "?=" | ||
118 | B_OPEN "{" | ||
119 | B_CLOSE "}" | ||
120 | |||
121 | K_ADDTASK "addtask" | ||
122 | K_ADDHANDLER "addhandler" | ||
123 | K_AFTER "after" | ||
124 | K_BEFORE "before" | ||
125 | K_DEF "def" | ||
126 | K_INCLUDE "include" | ||
127 | K_INHERIT "inherit" | ||
128 | K_PYTHON "python" | ||
129 | K_FAKEROOT "fakeroot" | ||
130 | K_EXPORT "export" | ||
131 | K_EXPORT_FUNC "EXPORT_FUNCTIONS" | ||
132 | |||
133 | STRING \"([^\n\r]|"\\\n")*\" | ||
134 | SSTRING \'([^\n\r]|"\\\n")*\' | ||
135 | VALUE ([^'" \t\n])|([^'" \t\n]([^\n]|(\\\n))*[^'" \t\n]) | ||
136 | |||
137 | C_SS [a-zA-Z_] | ||
138 | C_SB [a-zA-Z0-9_+-.] | ||
139 | REF $\{{C_SS}{C_SB}*\} | ||
140 | SYMBOL {C_SS}{C_SB}* | ||
141 | VARIABLE $?{C_SS}({C_SB}*|{REF})*(\[[a-zA-Z0-9_]*\])? | ||
142 | FILENAME ([a-zA-Z_./]|{REF})(([-+a-zA-Z0-9_./]*)|{REF})* | ||
143 | |||
144 | PROC \({C_SP}*\) | ||
145 | |||
146 | %s S_DEF | ||
147 | %s S_DEF_ARGS | ||
148 | %s S_DEF_BODY | ||
149 | %s S_FUNC | ||
150 | %s S_INCLUDE | ||
151 | %s S_INHERIT | ||
152 | %s S_PROC | ||
153 | %s S_RVALUE | ||
154 | %s S_TASK | ||
155 | |||
156 | %% | ||
157 | |||
158 | {OP_APPEND} { BEGIN S_RVALUE; | ||
159 | yyextra->accept (T_OP_APPEND); } | ||
160 | {OP_PREPEND} { BEGIN S_RVALUE; | ||
161 | yyextra->accept (T_OP_PREPEND); } | ||
162 | {OP_IMMEDIATE} { BEGIN S_RVALUE; | ||
163 | yyextra->accept (T_OP_IMMEDIATE); } | ||
164 | {OP_ASSIGN} { BEGIN S_RVALUE; | ||
165 | yyextra->accept (T_OP_ASSIGN); } | ||
166 | {OP_COND} { BEGIN S_RVALUE; | ||
167 | yyextra->accept (T_OP_COND); } | ||
168 | |||
169 | <S_RVALUE>\\\n{C_SP}* { } | ||
170 | <S_RVALUE>{STRING} { BEGIN INITIAL; | ||
171 | size_t cb = yyleng; | ||
172 | while (cb && isspace (yytext[cb - 1])) | ||
173 | --cb; | ||
174 | yytext[cb - 1] = 0; | ||
175 | yyextra->accept (T_STRING, yytext + 1); } | ||
176 | <S_RVALUE>{SSTRING} { BEGIN INITIAL; | ||
177 | size_t cb = yyleng; | ||
178 | while (cb && isspace (yytext[cb - 1])) | ||
179 | --cb; | ||
180 | yytext[cb - 1] = 0; | ||
181 | yyextra->accept (T_STRING, yytext + 1); } | ||
182 | |||
183 | <S_RVALUE>{VALUE} { ERROR (errorUnexpectedInput); } | ||
184 | <S_RVALUE>{C_SP}*\n+ { BEGIN INITIAL; | ||
185 | yyextra->accept (T_STRING, NULL); } | ||
186 | |||
187 | {K_INCLUDE} { BEGIN S_INCLUDE; | ||
188 | yyextra->accept (T_INCLUDE); } | ||
189 | {K_INHERIT} { BEGIN S_INHERIT; | ||
190 | yyextra->accept (T_INHERIT); } | ||
191 | {K_ADDTASK} { BEGIN S_TASK; | ||
192 | yyextra->accept (T_ADDTASK); } | ||
193 | {K_ADDHANDLER} { yyextra->accept (T_ADDHANDLER); } | ||
194 | {K_EXPORT_FUNC} { BEGIN S_FUNC; | ||
195 | yyextra->accept (T_EXPORT_FUNC); } | ||
196 | <S_TASK>{K_BEFORE} { yyextra->accept (T_BEFORE); } | ||
197 | <S_TASK>{K_AFTER} { yyextra->accept (T_AFTER); } | ||
198 | <INITIAL>{K_EXPORT} { yyextra->accept (T_EXPORT); } | ||
199 | |||
200 | <INITIAL>{K_FAKEROOT} { yyextra->accept (T_FAKEROOT); } | ||
201 | <INITIAL>{K_PYTHON} { yyextra->accept (T_PYTHON); } | ||
202 | {PROC}{C_SP}*{B_OPEN}{C_SP}*\n* { BEGIN S_PROC; | ||
203 | yyextra->accept (T_PROC_OPEN); } | ||
204 | <S_PROC>{B_CLOSE}{C_SP}*\n* { BEGIN INITIAL; | ||
205 | yyextra->accept (T_PROC_CLOSE); } | ||
206 | <S_PROC>([^}][^\n]*)?\n* { yyextra->accept (T_PROC_BODY, yytext); } | ||
207 | |||
208 | {K_DEF} { BEGIN S_DEF; } | ||
209 | <S_DEF>{SYMBOL} { BEGIN S_DEF_ARGS; | ||
210 | yyextra->accept (T_SYMBOL, yytext); } | ||
211 | <S_DEF_ARGS>[^\n:]*: { yyextra->accept (T_DEF_ARGS, yytext); } | ||
212 | <S_DEF_ARGS>{C_SP}*\n { BEGIN S_DEF_BODY; } | ||
213 | <S_DEF_BODY>{C_SP}+[^\n]*\n { yyextra->accept (T_DEF_BODY, yytext); } | ||
214 | <S_DEF_BODY>\n { yyextra->accept (T_DEF_BODY, yytext); } | ||
215 | <S_DEF_BODY>. { BEGIN INITIAL; unput (yytext[0]); } | ||
216 | |||
217 | {COMMENT} { } | ||
218 | |||
219 | <INITIAL>{SYMBOL} { yyextra->accept (T_SYMBOL, yytext); } | ||
220 | <INITIAL>{VARIABLE} { yyextra->accept (T_VARIABLE, yytext); } | ||
221 | |||
222 | <S_TASK>{SYMBOL} { yyextra->accept (T_TSYMBOL, yytext); } | ||
223 | <S_FUNC>{SYMBOL} { yyextra->accept (T_FSYMBOL, yytext); } | ||
224 | <S_INHERIT>{SYMBOL} { yyextra->accept (T_ISYMBOL, yytext); } | ||
225 | <S_INCLUDE>{FILENAME} { BEGIN INITIAL; | ||
226 | yyextra->accept (T_ISYMBOL, yytext); } | ||
227 | |||
228 | <S_TASK>\n { BEGIN INITIAL; } | ||
229 | <S_FUNC>\n { BEGIN INITIAL; } | ||
230 | <S_INHERIT>\n { BEGIN INITIAL; } | ||
231 | |||
232 | [ \t\r\n] /* Insignificant whitespace */ | ||
233 | |||
234 | . { ERROR (errorUnexpectedInput); } | ||
235 | |||
236 | /* Check for premature termination */ | ||
237 | <<EOF>> { return T_EOF; } | ||
238 | |||
239 | %% | ||
240 | |||
241 | void lex_t::accept (int token, const char* sz) | ||
242 | { | ||
243 | token_t t; | ||
244 | memset (&t, 0, sizeof (t)); | ||
245 | t.copyString(sz); | ||
246 | |||
247 | /* tell lemon to parse the token */ | ||
248 | parse (parser, token, t, this); | ||
249 | } | ||
250 | |||
251 | int lex_t::line ()const | ||
252 | { | ||
253 | return yyget_lineno (scanner); | ||
254 | } | ||
255 | |||
256 | const char* lex_t::filename ()const | ||
257 | { | ||
258 | return m_fileName; | ||
259 | } | ||
260 | |||
261 | void parse (MappedFile* mf) | ||
262 | { | ||
263 | void* parser = bbparseAlloc (malloc); | ||
264 | yyscan_t scanner; | ||
265 | lex_t lex; | ||
266 | |||
267 | yylex_init (&scanner); | ||
268 | |||
269 | lex.parser = parser; | ||
270 | lex.scanner = scanner; | ||
271 | lex.mf = mf; | ||
272 | lex.rgbInput = mf->m_rgb; | ||
273 | lex.cbInput = mf->m_cb; | ||
274 | lex.parse = bbparse; | ||
275 | yyset_extra (&lex, scanner); | ||
276 | |||
277 | |||
278 | int result = yylex (scanner); | ||
279 | |||
280 | lex.accept (0); | ||
281 | bbparseTrace (NULL, NULL); | ||
282 | |||
283 | if (result != T_EOF) | ||
284 | WARNING ("premature end of file\n"); | ||
285 | |||
286 | yylex_destroy (scanner); | ||
287 | bbparseFree (parser, free); | ||
288 | } | ||
diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.py b/bitbake/lib/bb/parse/parse_c/bitbakeparser.py new file mode 100644 index 0000000000..ed7b13eef9 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.py | |||
@@ -0,0 +1,133 @@ | |||
1 | """ | ||
2 | |||
3 | BitBake C Parser Python Code | ||
4 | |||
5 | Copyright (C) 2005 Holger Hans Peter Freyther | ||
6 | |||
7 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
8 | of this software and associated documentation files (the "Software"), to deal | ||
9 | in the Software without restriction, including without limitation the rights | ||
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
11 | copies of the Software, and to permit persons to whom the Software is | ||
12 | furnished to do so, subject to the following conditions: | ||
13 | |||
14 | The above copyright notice and this permission notice shall be included in all | ||
15 | copies or substantial portions of the Software. | ||
16 | |||
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT | ||
20 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
21 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
22 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR | ||
23 | THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
24 | """ | ||
25 | |||
26 | __version__ = "0xdeadbeef" | ||
27 | |||
28 | class CParser: | ||
29 | """ | ||
30 | The C-based Parser for Bitbake | ||
31 | """ | ||
32 | def __init__(self, data, type): | ||
33 | """ | ||
34 | Constructor | ||
35 | """ | ||
36 | self._data = data | ||
37 | |||
38 | def _syntax_error(self, file, line): | ||
39 | """ | ||
40 | lemon/flex reports an syntax error to us and we will | ||
41 | raise an exception | ||
42 | """ | ||
43 | pass | ||
44 | |||
45 | def _export(self, data): | ||
46 | """ | ||
47 | EXPORT VAR = "MOO" | ||
48 | we will now export VAR | ||
49 | """ | ||
50 | pass | ||
51 | |||
52 | def _assign(self, key, value): | ||
53 | """ | ||
54 | VAR = "MOO" | ||
55 | we will assign moo to VAR | ||
56 | """ | ||
57 | pass | ||
58 | |||
59 | def _assign(self, key, value): | ||
60 | """ | ||
61 | """ | ||
62 | pass | ||
63 | |||
64 | def _append(self, key, value): | ||
65 | """ | ||
66 | VAR += "MOO" | ||
67 | we will append " MOO" to var | ||
68 | """ | ||
69 | pass | ||
70 | |||
71 | def _prepend(self, key, value): | ||
72 | """ | ||
73 | VAR =+ "MOO" | ||
74 | we will prepend "MOO " to var | ||
75 | """ | ||
76 | pass | ||
77 | |||
78 | def _immediate(self, key, value): | ||
79 | """ | ||
80 | VAR := "MOO ${CVSDATE}" | ||
81 | we will assign immediately and expand vars | ||
82 | """ | ||
83 | pass | ||
84 | |||
85 | def _conditional(self, key, value): | ||
86 | """ | ||
87 | """ | ||
88 | pass | ||
89 | |||
90 | def _add_task(self, task, before = None, after = None): | ||
91 | """ | ||
92 | """ | ||
93 | pass | ||
94 | |||
95 | def _include(self, file): | ||
96 | """ | ||
97 | """ | ||
98 | pass | ||
99 | |||
100 | def _inherit(self, file): | ||
101 | """ | ||
102 | """ | ||
103 | pass | ||
104 | |||
105 | def _shell_procedure(self, name, body): | ||
106 | """ | ||
107 | """ | ||
108 | pass | ||
109 | |||
110 | def _python_procedure(self, name, body): | ||
111 | """ | ||
112 | """ | ||
113 | pass | ||
114 | |||
115 | def _fakeroot_procedure(self, name, body): | ||
116 | """ | ||
117 | """ | ||
118 | pass | ||
119 | |||
120 | def _def_procedure(self, a, b, c): | ||
121 | """ | ||
122 | """ | ||
123 | pass | ||
124 | |||
125 | def _export_func(self, name): | ||
126 | """ | ||
127 | """ | ||
128 | pass | ||
129 | |||
130 | def _add_handler(self, handler): | ||
131 | """ | ||
132 | """ | ||
133 | pass | ||
diff --git a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y new file mode 100644 index 0000000000..4bc81a913a --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y | |||
@@ -0,0 +1,161 @@ | |||
1 | /* bbp.lemon | ||
2 | |||
3 | written by Marc Singer | ||
4 | 6 January 2005 | ||
5 | |||
6 | This program is free software; you can redistribute it and/or | ||
7 | modify it under the terms of the GNU General Public License as | ||
8 | published by the Free Software Foundation; either version 2 of the | ||
9 | License, or (at your option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, but | ||
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program; if not, write to the Free Software | ||
18 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | ||
19 | USA. | ||
20 | |||
21 | DESCRIPTION | ||
22 | ----------- | ||
23 | |||
24 | lemon parser specification file for a BitBake input file parser. | ||
25 | |||
26 | Most of the interesting shenanigans are done in the lexer. The | ||
27 | BitBake grammar is not regular. In order to emit tokens that | ||
28 | the parser can properly interpret in LALR fashion, the lexer | ||
29 | manages the interpretation state. This is why there are ISYMBOLs, | ||
30 | SYMBOLS, and TSYMBOLS. | ||
31 | |||
32 | This parser was developed by reading the limited available | ||
33 | documentation for BitBake and by analyzing the available BB files. | ||
34 | There is no assertion of correctness to be made about this parser. | ||
35 | |||
36 | */ | ||
37 | |||
38 | %token_type {token_t} | ||
39 | %name bbparse | ||
40 | %token_prefix T_ | ||
41 | %extra_argument {lex_t* lex} | ||
42 | |||
43 | %include { | ||
44 | #include "token.h" | ||
45 | } | ||
46 | |||
47 | |||
48 | %token_destructor { $$.release_this (); } | ||
49 | |||
50 | %syntax_error { printf ("%s:%d: syntax error\n", | ||
51 | lex->filename (), lex->line ()); } | ||
52 | |||
53 | program ::= statements. | ||
54 | |||
55 | statements ::= statements statement. | ||
56 | statements ::= . | ||
57 | |||
58 | variable(r) ::= SYMBOL(s). | ||
59 | { r.assignString( s.string() ); | ||
60 | s.assignString( 0 ); | ||
61 | s.release_this(); } | ||
62 | variable(r) ::= VARIABLE(v). | ||
63 | { | ||
64 | r.assignString( v.string() ); | ||
65 | v.assignString( 0 ); | ||
66 | v.release_this(); } | ||
67 | |||
68 | statement ::= EXPORT variable(s) OP_ASSIGN STRING(v). | ||
69 | { e_assign( s.string(), v.string() ); | ||
70 | e_export( s.string() ); | ||
71 | s.release_this(); v.release_this(); } | ||
72 | statement ::= EXPORT variable(s) OP_IMMEDIATE STRING(v). | ||
73 | { e_immediate (s.string(), v.string() ); | ||
74 | e_export( s.string() ); | ||
75 | s.release_this(); v.release_this(); } | ||
76 | statement ::= EXPORT variable(s) OP_COND STRING(v). | ||
77 | { e_cond( s.string(), v.string() ); | ||
78 | s.release_this(); v.release_this(); } | ||
79 | |||
80 | statement ::= variable(s) OP_ASSIGN STRING(v). | ||
81 | { e_assign( s.string(), v.string() ); | ||
82 | s.release_this(); v.release_this(); } | ||
83 | statement ::= variable(s) OP_PREPEND STRING(v). | ||
84 | { e_prepend( s.string(), v.string() ); | ||
85 | s.release_this(); v.release_this(); } | ||
86 | statement ::= variable(s) OP_APPEND STRING(v). | ||
87 | { e_append( s.string() , v.string() ); | ||
88 | s.release_this(); v.release_this(); } | ||
89 | statement ::= variable(s) OP_IMMEDIATE STRING(v). | ||
90 | { e_immediate( s.string(), v.string() ); | ||
91 | s.release_this(); v.release_this(); } | ||
92 | statement ::= variable(s) OP_COND STRING(v). | ||
93 | { e_cond( s.string(), v.string() ); | ||
94 | s.release_this(); v.release_this(); } | ||
95 | |||
96 | task ::= TSYMBOL(t) BEFORE TSYMBOL(b) AFTER TSYMBOL(a). | ||
97 | { e_addtask( t.string(), b.string(), a.string() ); | ||
98 | t.release_this(); b.release_this(); a.release_this(); } | ||
99 | task ::= TSYMBOL(t) AFTER TSYMBOL(a) BEFORE TSYMBOL(b). | ||
100 | { e_addtask( t.string(), b.string(), a.string()); | ||
101 | t.release_this(); a.release_this(); b.release_this(); } | ||
102 | task ::= TSYMBOL(t). | ||
103 | { e_addtask( t.string(), NULL, NULL); | ||
104 | t.release_this();} | ||
105 | task ::= TSYMBOL(t) BEFORE TSYMBOL(b). | ||
106 | { e_addtask( t.string(), b.string(), NULL); | ||
107 | t.release_this(); b.release_this(); } | ||
108 | task ::= TSYMBOL(t) AFTER TSYMBOL(a). | ||
109 | { e_addtask( t.string(), NULL, a.string()); | ||
110 | t.release_this(); a.release_this(); } | ||
111 | tasks ::= tasks task. | ||
112 | tasks ::= task. | ||
113 | statement ::= ADDTASK tasks. | ||
114 | |||
115 | statement ::= ADDHANDLER SYMBOL(s). | ||
116 | { e_addhandler( s.string()); s.release_this (); } | ||
117 | |||
118 | func ::= FSYMBOL(f). { e_export_func(f.string()); f.release_this(); } | ||
119 | funcs ::= funcs func. | ||
120 | funcs ::= func. | ||
121 | statement ::= EXPORT_FUNC funcs. | ||
122 | |||
123 | inherit ::= ISYMBOL(i). { e_inherit(i.string() ); i.release_this (); } | ||
124 | inherits ::= inherits inherit. | ||
125 | inherits ::= inherit. | ||
126 | statement ::= INHERIT inherits. | ||
127 | |||
128 | statement ::= INCLUDE ISYMBOL(i). | ||
129 | { e_include(i.string() ); i.release_this(); } | ||
130 | |||
131 | proc_body(r) ::= proc_body(l) PROC_BODY(b). | ||
132 | { /* concatenate body lines */ | ||
133 | r.assignString( token_t::concatString(l.string(), b.string()) ); | ||
134 | l.release_this (); | ||
135 | b.release_this (); | ||
136 | } | ||
137 | proc_body(b) ::= . { b.assignString(0); } | ||
138 | statement ::= variable(p) PROC_OPEN proc_body(b) PROC_CLOSE. | ||
139 | { e_proc( p.string(), b.string() ); | ||
140 | p.release_this(); b.release_this(); } | ||
141 | statement ::= PYTHON SYMBOL(p) PROC_OPEN proc_body(b) PROC_CLOSE. | ||
142 | { e_proc_python (p.string(), b.string() ); | ||
143 | p.release_this(); b.release_this(); } | ||
144 | statement ::= PYTHON PROC_OPEN proc_body(b) PROC_CLOSE. | ||
145 | { e_proc_python( NULL, b.string()); | ||
146 | b.release_this (); } | ||
147 | |||
148 | statement ::= FAKEROOT SYMBOL(p) PROC_OPEN proc_body(b) PROC_CLOSE. | ||
149 | { e_proc_fakeroot(p.string(), b.string() ); | ||
150 | p.release_this (); b.release_this (); } | ||
151 | |||
152 | def_body(r) ::= def_body(l) DEF_BODY(b). | ||
153 | { /* concatenate body lines */ | ||
154 | r.assignString( token_t::concatString(l.string(), b.string()); | ||
155 | l.release_this (); b.release_this (); | ||
156 | } | ||
157 | def_body(b) ::= . { b.sz = 0; } | ||
158 | statement ::= SYMBOL(p) DEF_ARGS(a) def_body(b). | ||
159 | { e_def( p.string(), a.string(), b.string()); | ||
160 | p.release_this(); a.release_this(); b.release_this(); } | ||
161 | |||
diff --git a/bitbake/lib/bb/parse/parse_c/lexer.h b/bitbake/lib/bb/parse/parse_c/lexer.h new file mode 100644 index 0000000000..1edf72dcf5 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/lexer.h | |||
@@ -0,0 +1,41 @@ | |||
1 | /* | ||
2 | Copyright (C) 2005 Holger Hans Peter Freyther | ||
3 | |||
4 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
5 | of this software and associated documentation files (the "Software"), to deal | ||
6 | in the Software without restriction, including without limitation the rights | ||
7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
8 | copies of the Software, and to permit persons to whom the Software is | ||
9 | furnished to do so, subject to the following conditions: | ||
10 | |||
11 | The above copyright notice and this permission notice shall be included in all | ||
12 | copies or substantial portions of the Software. | ||
13 | |||
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT | ||
17 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
18 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
19 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR | ||
20 | THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
21 | |||
22 | */ | ||
23 | |||
24 | #ifndef LEXER_H | ||
25 | #define LEXER_H | ||
26 | |||
27 | struct lex_t { | ||
28 | void *parser; | ||
29 | void *scanner; | ||
30 | void* (*parse)(void*, int, token_t, lex_t*); | ||
31 | |||
32 | void accept(int token, const char* string = 0); | ||
33 | void input(char *buf, int *result, int_max_size); | ||
34 | int line()const; | ||
35 | const char* filename()const; | ||
36 | private: | ||
37 | const char* m_fileName; | ||
38 | }; | ||
39 | |||
40 | |||
41 | #endif | ||
diff --git a/bitbake/lib/bb/parse/parse_c/token.h b/bitbake/lib/bb/parse/parse_c/token.h new file mode 100644 index 0000000000..2351fda6b5 --- /dev/null +++ b/bitbake/lib/bb/parse/parse_c/token.h | |||
@@ -0,0 +1,83 @@ | |||
1 | /* | ||
2 | Copyright (C) 2005 Holger Hans Peter Freyther | ||
3 | |||
4 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
5 | of this software and associated documentation files (the "Software"), to deal | ||
6 | in the Software without restriction, including without limitation the rights | ||
7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
8 | copies of the Software, and to permit persons to whom the Software is | ||
9 | furnished to do so, subject to the following conditions: | ||
10 | |||
11 | The above copyright notice and this permission notice shall be included in all | ||
12 | copies or substantial portions of the Software. | ||
13 | |||
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT | ||
17 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
18 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
19 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR | ||
20 | THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
21 | |||
22 | */ | ||
23 | |||
24 | #ifndef TOKEN_H | ||
25 | #define TOKEN_H | ||
26 | |||
27 | #define PURE_METHOD | ||
28 | |||
29 | struct token_t { | ||
30 | const char* string()const PURE_METHOD; | ||
31 | |||
32 | static char* concatString(const char* l, const char* r); | ||
33 | void assignString(const char* str); | ||
34 | void copyString(const char* str); | ||
35 | |||
36 | void release_this(); | ||
37 | |||
38 | private: | ||
39 | char *m_string; | ||
40 | size_t m_stringLen; | ||
41 | }; | ||
42 | |||
43 | inline const char* token_t::string()const | ||
44 | { | ||
45 | return m_string; | ||
46 | } | ||
47 | |||
48 | /* | ||
49 | * append str to the current string | ||
50 | */ | ||
51 | inline char* token_t::concatString(const char* l, const char* r) | ||
52 | { | ||
53 | size_t cb = (l ? strlen (l) : 0) + strlen (r) + 1; | ||
54 | r_sz = new char[cb]; | ||
55 | *r_sz = 0; | ||
56 | if (l) strcat (r_sz, l); | ||
57 | strcat (r_sz, r); | ||
58 | |||
59 | return r_sz; | ||
60 | } | ||
61 | |||
62 | inline void token_t::assignString(const char* str) | ||
63 | { | ||
64 | m_string = str; | ||
65 | m_stringLen = str ? strlen(str) : 0; | ||
66 | } | ||
67 | |||
68 | inline void token_t::copyString(const char* str) | ||
69 | { | ||
70 | if( str ) { | ||
71 | m_stringLen = strlen(str); | ||
72 | m_string = new char[m_stringLen+1]; | ||
73 | strcpy(m_string, str) | ||
74 | } | ||
75 | } | ||
76 | |||
77 | inline void token_t::release_this() | ||
78 | { | ||
79 | delete m_string; | ||
80 | m_string = 0; | ||
81 | } | ||
82 | |||
83 | #endif | ||