GNU Linux-libre 4.19.211-gnu1
[releases.git] / scripts / kconfig / zconf.l
1 %option nostdinit noyywrap never-interactive full ecs
2 %option 8bit nodefault yylineno
3 %x COMMAND HELP STRING PARAM ASSIGN_VAL
4 %{
5 /*
6  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
7  * Released under the terms of the GNU GPL v2.0.
8  */
9
10 #include <assert.h>
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 char *expand_token(const char *in, size_t n);
39 static void append_expanded_string(const char *in);
40 static void zconf_endhelp(void);
41 static void zconf_endfile(void);
42
43 static void new_string(void)
44 {
45         text = xmalloc(START_STRSIZE);
46         text_asize = START_STRSIZE;
47         text_size = 0;
48         *text = 0;
49 }
50
51 static void append_string(const char *str, int size)
52 {
53         int new_size = text_size + size + 1;
54         if (new_size > text_asize) {
55                 new_size += START_STRSIZE - 1;
56                 new_size &= -START_STRSIZE;
57                 text = xrealloc(text, new_size);
58                 text_asize = new_size;
59         }
60         memcpy(text + text_size, str, size);
61         text_size += size;
62         text[text_size] = 0;
63 }
64
65 static void alloc_string(const char *str, int size)
66 {
67         text = xmalloc(size + 1);
68         memcpy(text, str, size);
69         text[size] = 0;
70 }
71
72 static void warn_ignored_character(char chr)
73 {
74         fprintf(stderr,
75                 "%s:%d:warning: ignoring unsupported character '%c'\n",
76                 current_file->name, yylineno, chr);
77 }
78 %}
79
80 n       [A-Za-z0-9_-]
81
82 %%
83         int str = 0;
84         int ts, i;
85
86 [ \t]*#.*\n     |
87 [ \t]*\n        {
88         return T_EOL;
89 }
90 [ \t]*#.*
91
92
93 [ \t]+  {
94         BEGIN(COMMAND);
95 }
96
97 .       {
98         unput(yytext[0]);
99         BEGIN(COMMAND);
100 }
101
102
103 <COMMAND>{
104         {n}+    {
105                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
106                 current_pos.file = current_file;
107                 current_pos.lineno = yylineno;
108                 if (id && id->flags & TF_COMMAND) {
109                         BEGIN(PARAM);
110                         yylval.id = id;
111                         return id->token;
112                 }
113                 alloc_string(yytext, yyleng);
114                 yylval.string = text;
115                 return T_VARIABLE;
116         }
117         ({n}|$)+        {
118                 /* this token includes at least one '$' */
119                 yylval.string = expand_token(yytext, yyleng);
120                 if (strlen(yylval.string))
121                         return T_VARIABLE;
122                 free(yylval.string);
123         }
124         "="     { BEGIN(ASSIGN_VAL); yylval.flavor = VAR_RECURSIVE; return T_ASSIGN; }
125         ":="    { BEGIN(ASSIGN_VAL); yylval.flavor = VAR_SIMPLE; return T_ASSIGN; }
126         "+="    { BEGIN(ASSIGN_VAL); yylval.flavor = VAR_APPEND; return T_ASSIGN; }
127         [[:blank:]]+
128         .       warn_ignored_character(*yytext);
129         \n      {
130                 BEGIN(INITIAL);
131                 return T_EOL;
132         }
133 }
134
135 <ASSIGN_VAL>{
136         [^[:blank:]\n]+.*       {
137                 alloc_string(yytext, yyleng);
138                 yylval.string = text;
139                 return T_ASSIGN_VAL;
140         }
141         \n      { BEGIN(INITIAL); return T_EOL; }
142         .
143 }
144
145 <PARAM>{
146         "&&"    return T_AND;
147         "||"    return T_OR;
148         "("     return T_OPEN_PAREN;
149         ")"     return T_CLOSE_PAREN;
150         "!"     return T_NOT;
151         "="     return T_EQUAL;
152         "!="    return T_UNEQUAL;
153         "<="    return T_LESS_EQUAL;
154         ">="    return T_GREATER_EQUAL;
155         "<"     return T_LESS;
156         ">"     return T_GREATER;
157         \"|\'   {
158                 str = yytext[0];
159                 new_string();
160                 BEGIN(STRING);
161         }
162         \n      BEGIN(INITIAL); return T_EOL;
163         ({n}|[/.])+     {
164                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
165                 if (id && id->flags & TF_PARAM) {
166                         yylval.id = id;
167                         return id->token;
168                 }
169                 alloc_string(yytext, yyleng);
170                 yylval.string = text;
171                 return T_WORD;
172         }
173         ({n}|[/.$])+    {
174                 /* this token includes at least one '$' */
175                 yylval.string = expand_token(yytext, yyleng);
176                 if (strlen(yylval.string))
177                         return T_WORD;
178                 free(yylval.string);
179         }
180         #.*     /* comment */
181         \\\n    ;
182         [[:blank:]]+
183         .       warn_ignored_character(*yytext);
184         <<EOF>> {
185                 BEGIN(INITIAL);
186         }
187 }
188
189 <STRING>{
190         "$".*   append_expanded_string(yytext);
191         [^$'"\\\n]+/\n  {
192                 append_string(yytext, yyleng);
193                 yylval.string = text;
194                 return T_WORD_QUOTE;
195         }
196         [^$'"\\\n]+     {
197                 append_string(yytext, yyleng);
198         }
199         \\.?/\n {
200                 append_string(yytext + 1, yyleng - 1);
201                 yylval.string = text;
202                 return T_WORD_QUOTE;
203         }
204         \\.?    {
205                 append_string(yytext + 1, yyleng - 1);
206         }
207         \'|\"   {
208                 if (str == yytext[0]) {
209                         BEGIN(PARAM);
210                         yylval.string = text;
211                         return T_WORD_QUOTE;
212                 } else
213                         append_string(yytext, 1);
214         }
215         \n      {
216                 fprintf(stderr,
217                         "%s:%d:warning: multi-line strings not supported\n",
218                         zconf_curname(), zconf_lineno());
219                 BEGIN(INITIAL);
220                 return T_EOL;
221         }
222         <<EOF>> {
223                 BEGIN(INITIAL);
224                 yylval.string = text;
225                 return T_WORD_QUOTE;
226         }
227 }
228
229 <HELP>{
230         [ \t]+  {
231                 ts = 0;
232                 for (i = 0; i < yyleng; i++) {
233                         if (yytext[i] == '\t')
234                                 ts = (ts & ~7) + 8;
235                         else
236                                 ts++;
237                 }
238                 last_ts = ts;
239                 if (first_ts) {
240                         if (ts < first_ts) {
241                                 zconf_endhelp();
242                                 return T_HELPTEXT;
243                         }
244                         ts -= first_ts;
245                         while (ts > 8) {
246                                 append_string("        ", 8);
247                                 ts -= 8;
248                         }
249                         append_string("        ", ts);
250                 }
251         }
252         [ \t]*\n/[^ \t\n] {
253                 zconf_endhelp();
254                 return T_HELPTEXT;
255         }
256         [ \t]*\n        {
257                 append_string("\n", 1);
258         }
259         [^ \t\n].* {
260                 while (yyleng) {
261                         if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
262                                 break;
263                         yyleng--;
264                 }
265                 append_string(yytext, yyleng);
266                 if (!first_ts)
267                         first_ts = last_ts;
268         }
269         <<EOF>> {
270                 zconf_endhelp();
271                 return T_HELPTEXT;
272         }
273 }
274
275 <<EOF>> {
276         if (current_file) {
277                 zconf_endfile();
278                 return T_EOL;
279         }
280         fclose(yyin);
281         yyterminate();
282 }
283
284 %%
285 static char *expand_token(const char *in, size_t n)
286 {
287         char *out;
288         int c;
289         char c2;
290         const char *rest, *end;
291
292         new_string();
293         append_string(in, n);
294
295         /* get the whole line because we do not know the end of token. */
296         while ((c = input()) != EOF) {
297                 if (c == '\n') {
298                         unput(c);
299                         break;
300                 }
301                 c2 = c;
302                 append_string(&c2, 1);
303         }
304
305         rest = text;
306         out = expand_one_token(&rest);
307
308         /* push back unused characters to the input stream */
309         end = rest + strlen(rest);
310         while (end > rest)
311                 unput(*--end);
312
313         free(text);
314
315         return out;
316 }
317
318 static void append_expanded_string(const char *str)
319 {
320         const char *end;
321         char *res;
322
323         str++;
324
325         res = expand_dollar(&str);
326
327         /* push back unused characters to the input stream */
328         end = str + strlen(str);
329         while (end > str)
330                 unput(*--end);
331
332         append_string(res, strlen(res));
333
334         free(res);
335 }
336
337 void zconf_starthelp(void)
338 {
339         new_string();
340         last_ts = first_ts = 0;
341         BEGIN(HELP);
342 }
343
344 static void zconf_endhelp(void)
345 {
346         yylval.string = text;
347         BEGIN(INITIAL);
348 }
349
350
351 /*
352  * Try to open specified file with following names:
353  * ./name
354  * $(srctree)/name
355  * The latter is used when srctree is separate from objtree
356  * when compiling the kernel.
357  * Return NULL if file is not found.
358  */
359 FILE *zconf_fopen(const char *name)
360 {
361         char *env, fullname[PATH_MAX+1];
362         FILE *f;
363
364         f = fopen(name, "r");
365         if (!f && name != NULL && name[0] != '/') {
366                 env = getenv(SRCTREE);
367                 if (env) {
368                         sprintf(fullname, "%s/%s", env, name);
369                         f = fopen(fullname, "r");
370                 }
371         }
372         return f;
373 }
374
375 void zconf_initscan(const char *name)
376 {
377         yyin = zconf_fopen(name);
378         if (!yyin) {
379                 fprintf(stderr, "can't find file %s\n", name);
380                 exit(1);
381         }
382
383         current_buf = xmalloc(sizeof(*current_buf));
384         memset(current_buf, 0, sizeof(*current_buf));
385
386         current_file = file_lookup(name);
387         yylineno = 1;
388 }
389
390 void zconf_nextfile(const char *name)
391 {
392         struct file *iter;
393         struct file *file = file_lookup(name);
394         struct buffer *buf = xmalloc(sizeof(*buf));
395         memset(buf, 0, sizeof(*buf));
396
397         current_buf->state = YY_CURRENT_BUFFER;
398         yyin = zconf_fopen(file->name);
399         if (!yyin) {
400                 fprintf(stderr, "%s:%d: can't open file \"%s\"\n",
401                         zconf_curname(), zconf_lineno(), file->name);
402                 exit(1);
403         }
404         yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
405         buf->parent = current_buf;
406         current_buf = buf;
407
408         current_file->lineno = yylineno;
409         file->parent = current_file;
410
411         for (iter = current_file; iter; iter = iter->parent) {
412                 if (!strcmp(iter->name, file->name)) {
413                         fprintf(stderr,
414                                 "Recursive inclusion detected.\n"
415                                 "Inclusion path:\n"
416                                 "  current file : %s\n", file->name);
417                         iter = file;
418                         do {
419                                 iter = iter->parent;
420                                 fprintf(stderr, "  included from: %s:%d\n",
421                                         iter->name, iter->lineno - 1);
422                         } while (strcmp(iter->name, file->name));
423                         exit(1);
424                 }
425         }
426
427         yylineno = 1;
428         current_file = file;
429 }
430
431 static void zconf_endfile(void)
432 {
433         struct buffer *parent;
434
435         current_file = current_file->parent;
436         if (current_file)
437                 yylineno = current_file->lineno;
438
439         parent = current_buf->parent;
440         if (parent) {
441                 fclose(yyin);
442                 yy_delete_buffer(YY_CURRENT_BUFFER);
443                 yy_switch_to_buffer(parent->state);
444         }
445         free(current_buf);
446         current_buf = parent;
447 }
448
449 int zconf_lineno(void)
450 {
451         return current_pos.lineno;
452 }
453
454 const char *zconf_curname(void)
455 {
456         return current_pos.file ? current_pos.file->name : "<none>";
457 }