scripts/kconfig/lexer.l

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