git.oblomov.eu Git - linux-2.6/blob - scripts/kconfig/zconf.l

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