BNX2X: spatch IRQ handlers
[akaros.git] / scripts / kconfig / zconf.l
1 %option nostdinit noyywrap never-interactive full ecs
2 %option 8bit nodefault perf-report perf-report
3 %option noinput
4 %x COMMAND HELP STRING PARAM
5 %{
6 /*
7  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
8  * Released under the terms of the GNU GPL v2.0.
9  */
10
11 #include <limits.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <unistd.h>
16
17 #include "lkc.h"
18
19 #define START_STRSIZE   16
20
21 static struct {
22         struct file *file;
23         int lineno;
24 } current_pos;
25
26 static char *text;
27 static int text_size, text_asize;
28
29 struct buffer {
30         struct buffer *parent;
31         YY_BUFFER_STATE state;
32 };
33
34 struct buffer *current_buf;
35
36 static int last_ts, first_ts;
37
38 static void zconf_endhelp(void);
39 static void zconf_endfile(void);
40
41 static void new_string(void)
42 {
43         text = malloc(START_STRSIZE);
44         text_asize = START_STRSIZE;
45         text_size = 0;
46         *text = 0;
47 }
48
49 static void append_string(const char *str, int size)
50 {
51         int new_size = text_size + size + 1;
52         if (new_size > text_asize) {
53                 new_size += START_STRSIZE - 1;
54                 new_size &= -START_STRSIZE;
55                 text = realloc(text, new_size);
56                 text_asize = new_size;
57         }
58         memcpy(text + text_size, str, size);
59         text_size += size;
60         text[text_size] = 0;
61 }
62
63 static void alloc_string(const char *str, int size)
64 {
65         text = malloc(size + 1);
66         memcpy(text, str, size);
67         text[size] = 0;
68 }
69 %}
70
71 ws      [ \n\t]
72 n       [A-Za-z0-9_]
73
74 %%
75         int str = 0;
76         int ts, i;
77
78 [ \t]*#.*\n     |
79 [ \t]*\n        {
80         current_file->lineno++;
81         return T_EOL;
82 }
83 [ \t]*#.*
84
85
86 [ \t]+  {
87         BEGIN(COMMAND);
88 }
89
90 .       {
91         unput(yytext[0]);
92         BEGIN(COMMAND);
93 }
94
95
96 <COMMAND>{
97         {n}+    {
98                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
99                 BEGIN(PARAM);
100                 current_pos.file = current_file;
101                 current_pos.lineno = current_file->lineno;
102                 if (id && id->flags & TF_COMMAND) {
103                         zconflval.id = id;
104                         return id->token;
105                 }
106                 alloc_string(yytext, yyleng);
107                 zconflval.string = text;
108                 return T_WORD;
109         }
110         .
111         \n      {
112                 BEGIN(INITIAL);
113                 current_file->lineno++;
114                 return T_EOL;
115         }
116 }
117
118 <PARAM>{
119         "&&"    return T_AND;
120         "||"    return T_OR;
121         "("     return T_OPEN_PAREN;
122         ")"     return T_CLOSE_PAREN;
123         "!"     return T_NOT;
124         "="     return T_EQUAL;
125         "!="    return T_UNEQUAL;
126         \"|\'   {
127                 str = yytext[0];
128                 new_string();
129                 BEGIN(STRING);
130         }
131         \n      BEGIN(INITIAL); current_file->lineno++; return T_EOL;
132         ---     /* ignore */
133         ({n}|[-/.])+    {
134                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
135                 if (id && id->flags & TF_PARAM) {
136                         zconflval.id = id;
137                         return id->token;
138                 }
139                 alloc_string(yytext, yyleng);
140                 zconflval.string = text;
141                 return T_WORD;
142         }
143         #.*     /* comment */
144         \\\n    current_file->lineno++;
145         .
146         <<EOF>> {
147                 BEGIN(INITIAL);
148         }
149 }
150
151 <STRING>{
152         [^'"\\\n]+/\n   {
153                 append_string(yytext, yyleng);
154                 zconflval.string = text;
155                 return T_WORD_QUOTE;
156         }
157         [^'"\\\n]+      {
158                 append_string(yytext, yyleng);
159         }
160         \\.?/\n {
161                 append_string(yytext + 1, yyleng - 1);
162                 zconflval.string = text;
163                 return T_WORD_QUOTE;
164         }
165         \\.?    {
166                 append_string(yytext + 1, yyleng - 1);
167         }
168         \'|\"   {
169                 if (str == yytext[0]) {
170                         BEGIN(PARAM);
171                         zconflval.string = text;
172                         return T_WORD_QUOTE;
173                 } else
174                         append_string(yytext, 1);
175         }
176         \n      {
177                 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
178                 current_file->lineno++;
179                 BEGIN(INITIAL);
180                 return T_EOL;
181         }
182         <<EOF>> {
183                 BEGIN(INITIAL);
184         }
185 }
186
187 <HELP>{
188         [ \t]+  {
189                 ts = 0;
190                 for (i = 0; i < yyleng; i++) {
191                         if (yytext[i] == '\t')
192                                 ts = (ts & ~7) + 8;
193                         else
194                                 ts++;
195                 }
196                 last_ts = ts;
197                 if (first_ts) {
198                         if (ts < first_ts) {
199                                 zconf_endhelp();
200                                 return T_HELPTEXT;
201                         }
202                         ts -= first_ts;
203                         while (ts > 8) {
204                                 append_string("        ", 8);
205                                 ts -= 8;
206                         }
207                         append_string("        ", ts);
208                 }
209         }
210         [ \t]*\n/[^ \t\n] {
211                 current_file->lineno++;
212                 zconf_endhelp();
213                 return T_HELPTEXT;
214         }
215         [ \t]*\n        {
216                 current_file->lineno++;
217                 append_string("\n", 1);
218         }
219         [^ \t\n].* {
220                 while (yyleng) {
221                         if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
222                                 break;
223                         yyleng--;
224                 }
225                 append_string(yytext, yyleng);
226                 if (!first_ts)
227                         first_ts = last_ts;
228         }
229         <<EOF>> {
230                 zconf_endhelp();
231                 return T_HELPTEXT;
232         }
233 }
234
235 <<EOF>> {
236         if (current_file) {
237                 zconf_endfile();
238                 return T_EOL;
239         }
240         fclose(yyin);
241         yyterminate();
242 }
243
244 %%
245 void zconf_starthelp(void)
246 {
247         new_string();
248         last_ts = first_ts = 0;
249         BEGIN(HELP);
250 }
251
252 static void zconf_endhelp(void)
253 {
254         zconflval.string = text;
255         BEGIN(INITIAL);
256 }
257
258
259 /*
260  * Try to open specified file with following names:
261  * ./name
262  * $(srctree)/name
263  * The latter is used when srctree is separate from objtree
264  * when compiling the kernel.
265  * Return NULL if file is not found.
266  */
267 FILE *zconf_fopen(const char *name)
268 {
269         char *env, fullname[PATH_MAX+1];
270         FILE *f;
271
272         f = fopen(name, "r");
273         if (!f && name != NULL && name[0] != '/') {
274                 env = getenv(SRCTREE);
275                 if (env) {
276                         sprintf(fullname, "%s/%s", env, name);
277                         f = fopen(fullname, "r");
278                 }
279         }
280         return f;
281 }
282
283 void zconf_initscan(const char *name)
284 {
285         yyin = zconf_fopen(name);
286         if (!yyin) {
287                 printf("can't find file %s\n", name);
288                 exit(1);
289         }
290
291         current_buf = malloc(sizeof(*current_buf));
292         memset(current_buf, 0, sizeof(*current_buf));
293
294         current_file = file_lookup(name);
295         current_file->lineno = 1;
296 }
297
298 void zconf_nextfile(const char *name)
299 {
300         struct file *iter;
301         struct file *file = file_lookup(name);
302         struct buffer *buf = malloc(sizeof(*buf));
303         memset(buf, 0, sizeof(*buf));
304
305         current_buf->state = YY_CURRENT_BUFFER;
306         yyin = zconf_fopen(file->name);
307         if (!yyin) {
308                 printf("%s:%d: can't open file \"%s\"\n",
309                     zconf_curname(), zconf_lineno(), file->name);
310                 exit(1);
311         }
312         yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
313         buf->parent = current_buf;
314         current_buf = buf;
315
316         for (iter = current_file->parent; iter; iter = iter->parent ) {
317                 if (!strcmp(current_file->name,iter->name) ) {
318                         printf("%s:%d: recursive inclusion detected. "
319                                "Inclusion path:\n  current file : '%s'\n",
320                                zconf_curname(), zconf_lineno(),
321                                zconf_curname());
322                         iter = current_file->parent;
323                         while (iter && \
324                                strcmp(iter->name,current_file->name)) {
325                                 printf("  included from: '%s:%d'\n",
326                                        iter->name, iter->lineno-1);
327                                 iter = iter->parent;
328                         }
329                         if (iter)
330                                 printf("  included from: '%s:%d'\n",
331                                        iter->name, iter->lineno+1);
332                         exit(1);
333                 }
334         }
335         file->lineno = 1;
336         file->parent = current_file;
337         current_file = file;
338 }
339
340 static void zconf_endfile(void)
341 {
342         struct buffer *parent;
343
344         current_file = current_file->parent;
345
346         parent = current_buf->parent;
347         if (parent) {
348                 fclose(yyin);
349                 yy_delete_buffer(YY_CURRENT_BUFFER);
350                 yy_switch_to_buffer(parent->state);
351         }
352         free(current_buf);
353         current_buf = parent;
354 }
355
356 int zconf_lineno(void)
357 {
358         return current_pos.lineno;
359 }
360
361 const char *zconf_curname(void)
362 {
363         return current_pos.file ? current_pos.file->name : "<none>";
364 }