scripts/config/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 #include <glob.h>
  17 #include <libgen.h>
  18
  19 #include "lkc.h"
  20
  21 #define START_STRSIZE   16
  22
  23 static struct {
  24         struct file *file;
  25         int lineno;
  26 } current_pos;
  27
  28 static char *text;
  29 static int text_size, text_asize;
  30
  31 struct buffer {
  32         struct buffer *parent;
  33         YY_BUFFER_STATE state;
  34 };
  35
  36 struct buffer *current_buf;
  37
  38 static int last_ts, first_ts;
  39
  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 = realloc(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                 zconf_curname(), zconf_lineno(), 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         current_file->lineno++;
  89         return T_EOL;
  90 }
  91 [ \t]*#.*
  92
  93
  94 [ \t]+  {
  95         BEGIN(COMMAND);
  96 }
  97
  98 .       {
  99         unput(yytext[0]);
 100         BEGIN(COMMAND);
 101 }
 102
 103
 104 <COMMAND>{
 105         {n}+    {
 106                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
 107                 BEGIN(PARAM);
 108                 current_pos.file = current_file;
 109                 current_pos.lineno = current_file->lineno;
 110                 if (id && id->flags & TF_COMMAND) {
 111                         zconflval.id = id;
 112                         return id->token;
 113                 }
 114                 alloc_string(yytext, yyleng);
 115                 zconflval.string = text;
 116                 return T_WORD;
 117         }
 118         .       warn_ignored_character(*yytext);
 119         \n      {
 120                 BEGIN(INITIAL);
 121                 current_file->lineno++;
 122                 return T_EOL;
 123         }
 124 }
 125
 126 <PARAM>{
 127         "&&"    return T_AND;
 128         "||"    return T_OR;
 129         "("     return T_OPEN_PAREN;
 130         ")"     return T_CLOSE_PAREN;
 131         "!"     return T_NOT;
 132         "="     return T_EQUAL;
 133         "!="    return T_UNEQUAL;
 134         "<="    return T_LESS_EQUAL;
 135         ">="    return T_GREATER_EQUAL;
 136         "<"     return T_LESS;
 137         ">"     return T_GREATER;
 138         \"|\'   {
 139                 str = yytext[0];
 140                 new_string();
 141                 BEGIN(STRING);
 142         }
 143         \n      BEGIN(INITIAL); current_file->lineno++; return T_EOL;
 144         ({n}|[/.])+     {
 145                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
 146                 if (id && id->flags & TF_PARAM) {
 147                         zconflval.id = id;
 148                         return id->token;
 149                 }
 150                 alloc_string(yytext, yyleng);
 151                 zconflval.string = text;
 152                 return T_WORD;
 153         }
 154         #.*     /* comment */
 155         \\\n    current_file->lineno++;
 156         [[:blank:]]+
 157         .       warn_ignored_character(*yytext);
 158         <<EOF>> {
 159                 BEGIN(INITIAL);
 160         }
 161 }
 162
 163 <STRING>{
 164         [^'"\\\n]+/\n   {
 165                 append_string(yytext, yyleng);
 166                 zconflval.string = text;
 167                 return T_WORD_QUOTE;
 168         }
 169         [^'"\\\n]+      {
 170                 append_string(yytext, yyleng);
 171         }
 172         \\.?/\n {
 173                 append_string(yytext + 1, yyleng - 1);
 174                 zconflval.string = text;
 175                 return T_WORD_QUOTE;
 176         }
 177         \\.?    {
 178                 append_string(yytext + 1, yyleng - 1);
 179         }
 180         \'|\"   {
 181                 if (str == yytext[0]) {
 182                         BEGIN(PARAM);
 183                         zconflval.string = text;
 184                         return T_WORD_QUOTE;
 185                 } else
 186                         append_string(yytext, 1);
 187         }
 188         \n      {
 189                 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
 190                 current_file->lineno++;
 191                 BEGIN(INITIAL);
 192                 return T_EOL;
 193         }
 194         <<EOF>> {
 195                 BEGIN(INITIAL);
 196         }
 197 }
 198
 199 <HELP>{
 200         [ \t]+  {
 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                 current_file->lineno++;
 224                 zconf_endhelp();
 225                 return T_HELPTEXT;
 226         }
 227         [ \t]*\n        {
 228                 current_file->lineno++;
 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         if (current_file) {
 249                 zconf_endfile();
 250                 return T_EOL;
 251         }
 252         fclose(yyin);
 253         yyterminate();
 254 }
 255
 256 %%
 257 void zconf_starthelp(void)
 258 {
 259         new_string();
 260         last_ts = first_ts = 0;
 261         BEGIN(HELP);
 262 }
 263
 264 static void zconf_endhelp(void)
 265 {
 266         zconflval.string = text;
 267         BEGIN(INITIAL);
 268 }
 269
 270
 271 /*
 272  * Try to open specified file with following names:
 273  * ./name
 274  * $(srctree)/name
 275  * The latter is used when srctree is separate from objtree
 276  * when compiling the kernel.
 277  * Return NULL if file is not found.
 278  */
 279 FILE *zconf_fopen(const char *name)
 280 {
 281         char *env, fullname[PATH_MAX+1];
 282         FILE *f;
 283
 284         f = fopen(name, "r");
 285         if (!f && name != NULL && name[0] != '/') {
 286                 env = getenv(SRCTREE);
 287                 if (env) {
 288                         sprintf(fullname, "%s/%s", env, name);
 289                         f = fopen(fullname, "r");
 290                 }
 291         }
 292         return f;
 293 }
 294
 295 void zconf_initscan(const char *name)
 296 {
 297         yyin = zconf_fopen(name);
 298         if (!yyin) {
 299                 printf("can't find file %s\n", name);
 300                 exit(1);
 301         }
 302
 303         current_buf = xmalloc(sizeof(*current_buf));
 304         memset(current_buf, 0, sizeof(*current_buf));
 305
 306         current_file = file_lookup(name);
 307         current_file->lineno = 1;
 308 }
 309
 310 static void __zconf_nextfile(const char *name)
 311 {
 312         struct file *iter;
 313         struct file *file = file_lookup(name);
 314         struct buffer *buf = xmalloc(sizeof(*buf));
 315         memset(buf, 0, sizeof(*buf));
 316
 317         current_buf->state = YY_CURRENT_BUFFER;
 318         yyin = zconf_fopen(file->name);
 319         if (!yyin) {
 320                 printf("%s:%d: can't open file \"%s\"\n",
 321                     zconf_curname(), zconf_lineno(), file->name);
 322                 exit(1);
 323         }
 324         yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
 325         buf->parent = current_buf;
 326         current_buf = buf;
 327
 328         for (iter = current_file->parent; iter; iter = iter->parent ) {
 329                 if (!strcmp(current_file->name,iter->name) ) {
 330                         printf("%s:%d: recursive inclusion detected. "
 331                                "Inclusion path:\n  current file : '%s'\n",
 332                                zconf_curname(), zconf_lineno(),
 333                                zconf_curname());
 334                         iter = current_file->parent;
 335                         while (iter && \
 336                                strcmp(iter->name,current_file->name)) {
 337                                 printf("  included from: '%s:%d'\n",
 338                                        iter->name, iter->lineno-1);
 339                                 iter = iter->parent;
 340                         }
 341                         if (iter)
 342                                 printf("  included from: '%s:%d'\n",
 343                                        iter->name, iter->lineno+1);
 344                         exit(1);
 345                 }
 346         }
 347         file->lineno = 1;
 348         file->parent = current_file;
 349         current_file = file;
 350 }
 351
 352 void zconf_nextfile(const char *name)
 353 {
 354         glob_t gl;
 355         int err;
 356         int i;
 357         char path[PATH_MAX], *p;
 358
 359         err = glob(name, GLOB_ERR | GLOB_MARK, NULL, &gl);
 360
 361         /* ignore wildcard patterns that return no result */
 362         if (err == GLOB_NOMATCH && strchr(name, '*')) {
 363                 err = 0;
 364                 gl.gl_pathc = 0;
 365         }
 366
 367         if (err == GLOB_NOMATCH) {
 368                 p = strdup(current_file->name);
 369                 if (p) {
 370                         snprintf(path, sizeof(path), "%s/%s", dirname(p), name);
 371                         err = glob(path, GLOB_ERR | GLOB_MARK, NULL, &gl);
 372                         free(p);
 373                 }
 374         }
 375
 376         if (err) {
 377                 const char *reason = "unknown error";
 378
 379                 switch (err) {
 380                 case GLOB_NOSPACE:
 381                         reason = "out of memory";
 382                         break;
 383                 case GLOB_ABORTED:
 384                         reason = "read error";
 385                         break;
 386                 case GLOB_NOMATCH:
 387                         reason = "No files found";
 388                         break;
 389                 default:
 390                         break;
 391                 }
 392
 393                 printf("%s:%d: glob failed: %s \"%s\"\n", zconf_curname(), zconf_lineno(),
 394                         reason, name);
 395
 396                 exit(1);
 397         }
 398
 399         for (i = 0; i < gl.gl_pathc; i++)
 400                 __zconf_nextfile(gl.gl_pathv[i]);
 401 }
 402
 403 static void zconf_endfile(void)
 404 {
 405         struct buffer *parent;
 406
 407         current_file = current_file->parent;
 408
 409         parent = current_buf->parent;
 410         if (parent) {
 411                 fclose(yyin);
 412                 yy_delete_buffer(YY_CURRENT_BUFFER);
 413                 yy_switch_to_buffer(parent->state);
 414         }
 415         free(current_buf);
 416         current_buf = parent;
 417 }
 418
 419 int zconf_lineno(void)
 420 {
 421         return current_pos.lineno;
 422 }
 423
 424 const char *zconf_curname(void)
 425 {
 426         return current_pos.file ? current_pos.file->name : "<none>";
 427 }