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
  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 = xmalloc(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 = xmalloc(size + 1);
  66         memcpy(text, str, size);
  67         text[size] = 0;
  68 }
  69 %}
  70
  71 n       [A-Za-z0-9_]
  72
  73 %%
  74         int str = 0;
  75         int ts, i;
  76
  77 [ \t]*#.*\n     |
  78 [ \t]*\n        {
  79         current_file->lineno++;
  80         return T_EOL;
  81 }
  82 [ \t]*#.*
  83
  84
  85 [ \t]+  {
  86         BEGIN(COMMAND);
  87 }
  88
  89 .       {
  90         unput(yytext[0]);
  91         BEGIN(COMMAND);
  92 }
  93
  94
  95 <COMMAND>{
  96         {n}+    {
  97                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
  98                 BEGIN(PARAM);
  99                 current_pos.file = current_file;
 100                 current_pos.lineno = current_file->lineno;
 101                 if (id && id->flags & TF_COMMAND) {
 102                         zconflval.id = id;
 103                         return id->token;
 104                 }
 105                 alloc_string(yytext, yyleng);
 106                 zconflval.string = text;
 107                 return T_WORD;
 108         }
 109         .
 110         \n      {
 111                 BEGIN(INITIAL);
 112                 current_file->lineno++;
 113                 return T_EOL;
 114         }
 115 }
 116
 117 <PARAM>{
 118         "&&"    return T_AND;
 119         "||"    return T_OR;
 120         "("     return T_OPEN_PAREN;
 121         ")"     return T_CLOSE_PAREN;
 122         "!"     return T_NOT;
 123         "="     return T_EQUAL;
 124         "!="    return T_UNEQUAL;
 125         \"|\'   {
 126                 str = yytext[0];
 127                 new_string();
 128                 BEGIN(STRING);
 129         }
 130         \n      BEGIN(INITIAL); current_file->lineno++; return T_EOL;
 131         ---     /* ignore */
 132         ({n}|[-/.])+    {
 133                 const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);
 134                 if (id && id->flags & TF_PARAM) {
 135                         zconflval.id = id;
 136                         return id->token;
 137                 }
 138                 alloc_string(yytext, yyleng);
 139                 zconflval.string = text;
 140                 return T_WORD;
 141         }
 142         #.*     /* comment */
 143         \\\n    current_file->lineno++;
 144         [[:blank:]]+
 145         .       {
 146                 fprintf(stderr,
 147                         "%s:%d:warning: ignoring unsupported character '%c'\n",
 148                         zconf_curname(), zconf_lineno(), *yytext);
 149         }
 150         <<EOF>> {
 151                 BEGIN(INITIAL);
 152         }
 153 }
 154
 155 <STRING>{
 156         [^'"\\\n]+/\n   {
 157                 append_string(yytext, yyleng);
 158                 zconflval.string = text;
 159                 return T_WORD_QUOTE;
 160         }
 161         [^'"\\\n]+      {
 162                 append_string(yytext, yyleng);
 163         }
 164         \\.?/\n {
 165                 append_string(yytext + 1, yyleng - 1);
 166                 zconflval.string = text;
 167                 return T_WORD_QUOTE;
 168         }
 169         \\.?    {
 170                 append_string(yytext + 1, yyleng - 1);
 171         }
 172         \'|\"   {
 173                 if (str == yytext[0]) {
 174                         BEGIN(PARAM);
 175                         zconflval.string = text;
 176                         return T_WORD_QUOTE;
 177                 } else
 178                         append_string(yytext, 1);
 179         }
 180         \n      {
 181                 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
 182                 current_file->lineno++;
 183                 BEGIN(INITIAL);
 184                 return T_EOL;
 185         }
 186         <<EOF>> {
 187                 BEGIN(INITIAL);
 188         }
 189 }
 190
 191 <HELP>{
 192         [ \t]+  {
 193                 ts = 0;
 194                 for (i = 0; i < yyleng; i++) {
 195                         if (yytext[i] == '\t')
 196                                 ts = (ts & ~7) + 8;
 197                         else
 198                                 ts++;
 199                 }
 200                 last_ts = ts;
 201                 if (first_ts) {
 202                         if (ts < first_ts) {
 203                                 zconf_endhelp();
 204                                 return T_HELPTEXT;
 205                         }
 206                         ts -= first_ts;
 207                         while (ts > 8) {
 208                                 append_string("        ", 8);
 209                                 ts -= 8;
 210                         }
 211                         append_string("        ", ts);
 212                 }
 213         }
 214         [ \t]*\n/[^ \t\n] {
 215                 current_file->lineno++;
 216                 zconf_endhelp();
 217                 return T_HELPTEXT;
 218         }
 219         [ \t]*\n        {
 220                 current_file->lineno++;
 221                 append_string("\n", 1);
 222         }
 223         [^ \t\n].* {
 224                 while (yyleng) {
 225                         if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
 226                                 break;
 227                         yyleng--;
 228                 }
 229                 append_string(yytext, yyleng);
 230                 if (!first_ts)
 231                         first_ts = last_ts;
 232         }
 233         <<EOF>> {
 234                 zconf_endhelp();
 235                 return T_HELPTEXT;
 236         }
 237 }
 238
 239 <<EOF>> {
 240         if (current_file) {
 241                 zconf_endfile();
 242                 return T_EOL;
 243         }
 244         fclose(yyin);
 245         yyterminate();
 246 }
 247
 248 %%
 249 void zconf_starthelp(void)
 250 {
 251         new_string();
 252         last_ts = first_ts = 0;
 253         BEGIN(HELP);
 254 }
 255
 256 static void zconf_endhelp(void)
 257 {
 258         zconflval.string = text;
 259         BEGIN(INITIAL);
 260 }
 261
 262
 263 /*
 264  * Try to open specified file with following names:
 265  * ./name
 266  * $(srctree)/name
 267  * The latter is used when srctree is separate from objtree
 268  * when compiling the firmware.
 269  * Return NULL if file is not found.
 270  */
 271 FILE *zconf_fopen(const char *name)
 272 {
 273         char *env, fullname[PATH_MAX+1];
 274         FILE *f;
 275
 276         f = fopen(name, "r");
 277         if (!f && name != NULL && name[0] != '/') {
 278                 env = getenv(SRCTREE);
 279                 if (env) {
 280                         sprintf(fullname, "%s/%s", env, name);
 281                         f = fopen(fullname, "r");
 282                 }
 283         }
 284         return f;
 285 }
 286
 287 void zconf_initscan(const char *name)
 288 {
 289         yyin = zconf_fopen(name);
 290         if (!yyin) {
 291                 printf("can't find file %s\n", name);
 292                 exit(1);
 293         }
 294
 295         current_buf = xmalloc(sizeof(*current_buf));
 296         memset(current_buf, 0, sizeof(*current_buf));
 297
 298         current_file = file_lookup(name);
 299         current_file->lineno = 1;
 300 }
 301
 302 void zconf_nextfile(const char *name)
 303 {
 304         struct file *iter;
 305         struct file *file = file_lookup(name);
 306         struct buffer *buf = xmalloc(sizeof(*buf));
 307         memset(buf, 0, sizeof(*buf));
 308
 309         current_buf->state = YY_CURRENT_BUFFER;
 310         yyin = zconf_fopen(file->name);
 311         if (!yyin) {
 312                 printf("%s:%d: can't open file \"%s\"\n",
 313                     zconf_curname(), zconf_lineno(), file->name);
 314                 exit(1);
 315         }
 316         yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
 317         buf->parent = current_buf;
 318         current_buf = buf;
 319
 320         for (iter = current_file->parent; iter; iter = iter->parent ) {
 321                 if (!strcmp(current_file->name,iter->name) ) {
 322                         printf("%s:%d: recursive inclusion detected. "
 323                                "Inclusion path:\n  current file : '%s'\n",
 324                                zconf_curname(), zconf_lineno(),
 325                                zconf_curname());
 326                         iter = current_file->parent;
 327                         while (iter && \
 328                                strcmp(iter->name,current_file->name)) {
 329                                 printf("  included from: '%s:%d'\n",
 330                                        iter->name, iter->lineno-1);
 331                                 iter = iter->parent;
 332                         }
 333                         if (iter)
 334                                 printf("  included from: '%s:%d'\n",
 335                                        iter->name, iter->lineno+1);
 336                         exit(1);
 337                 }
 338         }
 339         file->lineno = 1;
 340         file->parent = current_file;
 341         current_file = file;
 342 }
 343
 344 static void zconf_endfile(void)
 345 {
 346         struct buffer *parent;
 347
 348         current_file = current_file->parent;
 349
 350         parent = current_buf->parent;
 351         if (parent) {
 352                 fclose(yyin);
 353                 yy_delete_buffer(YY_CURRENT_BUFFER);
 354                 yy_switch_to_buffer(parent->state);
 355         }
 356         free(current_buf);
 357         current_buf = parent;
 358 }
 359
 360 int zconf_lineno(void)
 361 {
 362         return current_pos.lineno;
 363 }
 364
 365 const char *zconf_curname(void)
 366 {
 367         return current_pos.file ? current_pos.file->name : "<none>";
 368 }