1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3 * Copyright (C) 2002 Roman Zippel <[email protected]>
4 */
5 %option nostdinit noyywrap never-interactive full ecs
6 %option 8bit nodefault yylineno
7 %x ASSIGN_VAL HELP STRING
8 %{
9
10 #include <assert.h>
11 #include <glob.h>
12 #include <limits.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include "lkc.h"
18 #include "parser.tab.h"
19
20 #define YY_DECL static int yylex1(void)
21
22 #define START_STRSIZE 16
23
24 static struct {
25 struct file *file;
26 int lineno;
27 } current_pos;
28
29 static int prev_prev_token = T_EOL;
30 static int prev_token = T_EOL;
31 static char *text;
32 static int text_size, text_asize;
33
34 struct buffer {
35 struct buffer *parent;
36 YY_BUFFER_STATE state;
37 };
38
39 static struct buffer *current_buf;
40
41 static int last_ts, first_ts;
42
43 static char *expand_token(const char *in, size_t n);
44 static void append_expanded_string(const char *in);
45 static void zconf_endhelp(void);
46 static void zconf_endfile(void);
47
new_string(void)48 static void new_string(void)
49 {
50 text = xmalloc(START_STRSIZE);
51 text_asize = START_STRSIZE;
52 text_size = 0;
53 *text = 0;
54 }
55
append_string(const char * str,int size)56 static void append_string(const char *str, int size)
57 {
58 int new_size = text_size + size + 1;
59 if (new_size > text_asize) {
60 new_size += START_STRSIZE - 1;
61 new_size &= -START_STRSIZE;
62 text = xrealloc(text, new_size);
63 text_asize = new_size;
64 }
65 memcpy(text + text_size, str, size);
66 text_size += size;
67 text[text_size] = 0;
68 }
69
alloc_string(const char * str,int size)70 static void alloc_string(const char *str, int size)
71 {
72 text = xmalloc(size + 1);
73 memcpy(text, str, size);
74 text[size] = 0;
75 }
76
warn_ignored_character(char chr)77 static void warn_ignored_character(char chr)
78 {
79 fprintf(stderr,
80 "%s:%d:warning: ignoring unsupported character '%c'\n",
81 current_file->name, yylineno, chr);
82 }
83 %}
84
85 n [A-Za-z0-9_-]
86
87 %%
88 char open_quote = 0;
89
90 #.* /* ignore comment */
91 [ \t]* /* whitespaces */
92 \\\n /* escaped new line */
93 \n return T_EOL;
94 "bool" return T_BOOL;
95 "choice" return T_CHOICE;
96 "comment" return T_COMMENT;
97 "config" return T_CONFIG;
98 "def_bool" return T_DEF_BOOL;
99 "def_tristate" return T_DEF_TRISTATE;
100 "default" return T_DEFAULT;
101 "depends" return T_DEPENDS;
102 "endchoice" return T_ENDCHOICE;
103 "endif" return T_ENDIF;
104 "endmenu" return T_ENDMENU;
105 "help" return T_HELP;
106 "hex" return T_HEX;
107 "if" return T_IF;
108 "imply" return T_IMPLY;
109 "int" return T_INT;
110 "mainmenu" return T_MAINMENU;
111 "menu" return T_MENU;
112 "menuconfig" return T_MENUCONFIG;
113 "modules" return T_MODULES;
114 "on" return T_ON;
115 "optional" return T_OPTIONAL;
116 "prompt" return T_PROMPT;
117 "range" return T_RANGE;
118 "select" return T_SELECT;
119 "source" return T_SOURCE;
120 "string" return T_STRING;
121 "tristate" return T_TRISTATE;
122 "visible" return T_VISIBLE;
123 "||" return T_OR;
124 "&&" return T_AND;
125 "=" return T_EQUAL;
126 "!=" return T_UNEQUAL;
127 "<" return T_LESS;
128 "<=" return T_LESS_EQUAL;
129 ">" return T_GREATER;
130 ">=" return T_GREATER_EQUAL;
131 "!" return T_NOT;
132 "(" return T_OPEN_PAREN;
133 ")" return T_CLOSE_PAREN;
134 ":=" return T_COLON_EQUAL;
135 "+=" return T_PLUS_EQUAL;
136 \"|\' {
137 open_quote = yytext[0];
138 new_string();
139 BEGIN(STRING);
140 }
141 {n}+ {
142 alloc_string(yytext, yyleng);
143 yylval.string = text;
144 return T_WORD;
145 }
146 ({n}|$)+ {
147 /* this token includes at least one '$' */
148 yylval.string = expand_token(yytext, yyleng);
149 if (strlen(yylval.string))
150 return T_WORD;
151 free(yylval.string);
152 }
153 . warn_ignored_character(*yytext);
154
155 <ASSIGN_VAL>{
156 [^[:blank:]\n]+.* {
157 alloc_string(yytext, yyleng);
158 yylval.string = text;
159 return T_ASSIGN_VAL;
160 }
161 \n { BEGIN(INITIAL); return T_EOL; }
162 .
163 }
164
165 <STRING>{
166 "$".* append_expanded_string(yytext);
167 [^$'"\\\n]+ {
168 append_string(yytext, yyleng);
169 }
170 \\.? {
171 append_string(yytext + 1, yyleng - 1);
172 }
173 \'|\" {
174 if (open_quote == yytext[0]) {
175 BEGIN(INITIAL);
176 yylval.string = text;
177 return T_WORD_QUOTE;
178 } else
179 append_string(yytext, 1);
180 }
181 \n {
182 fprintf(stderr,
183 "%s:%d:warning: multi-line strings not supported\n",
184 zconf_curname(), zconf_lineno());
185 unput('\n');
186 BEGIN(INITIAL);
187 yylval.string = text;
188 return T_WORD_QUOTE;
189 }
190 <<EOF>> {
191 BEGIN(INITIAL);
192 yylval.string = text;
193 return T_WORD_QUOTE;
194 }
195 }
196
197 <HELP>{
198 [ \t]+ {
199 int ts, i;
200
201 ts = 0;
202 for (i = 0; i < yyleng; i++) {
203 if (yytext[i] == '\t')
204 ts = (ts & ~7) + 8;
205 else
206 ts++;
207 }
208 last_ts = ts;
209 if (first_ts) {
210 if (ts < first_ts) {
211 zconf_endhelp();
212 return T_HELPTEXT;
213 }
214 ts -= first_ts;
215 while (ts > 8) {
216 append_string(" ", 8);
217 ts -= 8;
218 }
219 append_string(" ", ts);
220 }
221 }
222 [ \t]*\n/[^ \t\n] {
223 zconf_endhelp();
224 return T_HELPTEXT;
225 }
226 [ \t]*\n {
227 append_string("\n", 1);
228 }
229 [^ \t\n].* {
230 while (yyleng) {
231 if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
232 break;
233 yyleng--;
234 }
235 append_string(yytext, yyleng);
236 if (!first_ts)
237 first_ts = last_ts;
238 }
239 <<EOF>> {
240 zconf_endhelp();
241 return T_HELPTEXT;
242 }
243 }
244
245 <<EOF>> {
246 BEGIN(INITIAL);
247
248 if (prev_token != T_EOL && prev_token != T_HELPTEXT)
249 fprintf(stderr, "%s:%d:warning: no new line at end of file\n",
250 current_file->name, yylineno);
251
252 if (current_file) {
253 zconf_endfile();
254 return T_EOL;
255 }
256 fclose(yyin);
257 yyterminate();
258 }
259
260 %%
261
262 /* second stage lexer */
263 int yylex(void)
264 {
265 int token;
266
267 repeat:
268 token = yylex1();
269
270 if (prev_token == T_EOL || prev_token == T_HELPTEXT) {
271 if (token == T_EOL) {
272 /* Do not pass unneeded T_EOL to the parser. */
273 goto repeat;
274 } else {
275 /*
276 * For the parser, update file/lineno at the first token
277 * of each statement. Generally, \n is a statement
278 * terminator in Kconfig, but it is not always true
279 * because \n could be escaped by a backslash.
280 */
281 current_pos.file = current_file;
282 current_pos.lineno = yylineno;
283 }
284 }
285
286 if (prev_prev_token == T_EOL && prev_token == T_WORD &&
287 (token == T_EQUAL || token == T_COLON_EQUAL || token == T_PLUS_EQUAL))
288 BEGIN(ASSIGN_VAL);
289
290 prev_prev_token = prev_token;
291 prev_token = token;
292
293 return token;
294 }
295
296 static char *expand_token(const char *in, size_t n)
297 {
298 char *out;
299 int c;
300 char c2;
301 const char *rest, *end;
302
303 new_string();
304 append_string(in, n);
305
306 /* get the whole line because we do not know the end of token. */
307 while ((c = input()) != EOF) {
308 if (c == '\n') {
309 unput(c);
310 break;
311 }
312 c2 = c;
313 append_string(&c2, 1);
314 }
315
316 rest = text;
317 out = expand_one_token(&rest);
318
319 /* push back unused characters to the input stream */
320 end = rest + strlen(rest);
321 while (end > rest)
322 unput(*--end);
323
324 free(text);
325
326 return out;
327 }
328
329 static void append_expanded_string(const char *str)
330 {
331 const char *end;
332 char *res;
333
334 str++;
335
336 res = expand_dollar(&str);
337
338 /* push back unused characters to the input stream */
339 end = str + strlen(str);
340 while (end > str)
341 unput(*--end);
342
343 append_string(res, strlen(res));
344
345 free(res);
346 }
347
348 void zconf_starthelp(void)
349 {
350 new_string();
351 last_ts = first_ts = 0;
352 BEGIN(HELP);
353 }
354
355 static void zconf_endhelp(void)
356 {
357 yylval.string = text;
358 BEGIN(INITIAL);
359 }
360
361
362 /*
363 * Try to open specified file with following names:
364 * ./name
365 * $(srctree)/name
366 * The latter is used when srctree is separate from objtree
367 * when compiling the kernel.
368 * Return NULL if file is not found.
369 */
370 FILE *zconf_fopen(const char *name)
371 {
372 char *env, fullname[PATH_MAX+1];
373 FILE *f;
374
375 f = fopen(name, "r");
376 if (!f && name != NULL && name[0] != '/') {
377 env = getenv(SRCTREE);
378 if (env) {
379 snprintf(fullname, sizeof(fullname),
380 "%s/%s", env, name);
381 f = fopen(fullname, "r");
382 }
383 }
384 return f;
385 }
386
387 void zconf_initscan(const char *name)
388 {
389 yyin = zconf_fopen(name);
390 if (!yyin) {
391 fprintf(stderr, "can't find file %s\n", name);
392 exit(1);
393 }
394
395 current_buf = xmalloc(sizeof(*current_buf));
396 memset(current_buf, 0, sizeof(*current_buf));
397
398 current_file = file_lookup(name);
399 yylineno = 1;
400 }
401
402 void zconf_nextfile(const char *name)
403 {
404 struct file *iter;
405 struct file *file = file_lookup(name);
406 struct buffer *buf = xmalloc(sizeof(*buf));
407 memset(buf, 0, sizeof(*buf));
408
409 current_buf->state = YY_CURRENT_BUFFER;
410 yyin = zconf_fopen(file->name);
411 if (!yyin) {
412 fprintf(stderr, "%s:%d: can't open file \"%s\"\n",
413 zconf_curname(), zconf_lineno(), file->name);
414 exit(1);
415 }
416 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
417 buf->parent = current_buf;
418 current_buf = buf;
419
420 current_file->lineno = yylineno;
421 file->parent = current_file;
422
423 for (iter = current_file; iter; iter = iter->parent) {
424 if (!strcmp(iter->name, file->name)) {
425 fprintf(stderr,
426 "Recursive inclusion detected.\n"
427 "Inclusion path:\n"
428 " current file : %s\n", file->name);
429 iter = file;
430 do {
431 iter = iter->parent;
432 fprintf(stderr, " included from: %s:%d\n",
433 iter->name, iter->lineno - 1);
434 } while (strcmp(iter->name, file->name));
435 exit(1);
436 }
437 }
438
439 yylineno = 1;
440 current_file = file;
441 }
442
443 void zconf_nextfiles(const char *wildcard)
444 {
445 glob_t g;
446 char **w;
447 int i;
448
449 if (glob(wildcard, 0, NULL, &g) != 0) {
450 return;
451 }
452 if (g.gl_pathv == NULL) {
453 globfree(&g);
454 return;
455 }
456
457 /* working through files backwards, since
458 * we're first pushing them on a stack
459 * before actually handling them.
460 */
461 for (i = g.gl_pathc; i > 0; i--) {
462 w = &g.gl_pathv[i - 1];
463 zconf_nextfile(*w);
464 }
465
466 globfree(&g);
467 }
468
469 static void zconf_endfile(void)
470 {
471 struct buffer *parent;
472
473 current_file = current_file->parent;
474 if (current_file)
475 yylineno = current_file->lineno;
476
477 parent = current_buf->parent;
478 if (parent) {
479 fclose(yyin);
480 yy_delete_buffer(YY_CURRENT_BUFFER);
481 yy_switch_to_buffer(parent->state);
482 }
483 free(current_buf);
484 current_buf = parent;
485 }
486
487 int zconf_lineno(void)
488 {
489 return current_pos.lineno;
490 }
491
492 const char *zconf_curname(void)
493 {
494 return current_pos.file ? current_pos.file->name : "<none>";
495 }
496