scripts/genksyms/lex.l

   1 /* Lexical analysis for genksyms.
   2    Copyright 1996, 1997 Linux International.
   3
   4    New implementation contributed by Richard Henderson <rth@tamu.edu>
   5    Based on original work by Bjorn Ekwall <bj0rn@blox.se>
   6
   7    Taken from Linux modutils 2.4.22.
   8
   9    This program is free software; you can redistribute it and/or modify it
  10    under the terms of the GNU General Public License as published by the
  11    Free Software Foundation; either version 2 of the License, or (at your
  12    option) any later version.
  13
  14    This program is distributed in the hope that it will be useful, but
  15    WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software Foundation,
  21    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23
  24 %{
  25
  26 #include <limits.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30
  31 #include "genksyms.h"
  32 #include "parse.tab.h"
  33
  34 /* We've got a two-level lexer here.  We let flex do basic tokenization
  35    and then we categorize those basic tokens in the second stage.  */
  36 #define YY_DECL         static int yylex1(void)
  37
  38 %}
  39
  40 IDENT                   [A-Za-z_\$][A-Za-z0-9_\$]*
  41
  42 O_INT                   0[0-7]*
  43 D_INT                   [1-9][0-9]*
  44 X_INT                   0[Xx][0-9A-Fa-f]+
  45 I_SUF                   [Uu]|[Ll]|[Uu][Ll]|[Ll][Uu]
  46 INT                     ({O_INT}|{D_INT}|{X_INT}){I_SUF}?
  47
  48 FRAC                    ([0-9]*\.[0-9]+)|([0-9]+\.)
  49 EXP                     [Ee][+-]?[0-9]+
  50 F_SUF                   [FfLl]
  51 REAL                    ({FRAC}{EXP}?{F_SUF}?)|([0-9]+{EXP}{F_SUF}?)
  52
  53 STRING                  L?\"([^\\\"]*\\.)*[^\\\"]*\"
  54 CHAR                    L?\'([^\\\']*\\.)*[^\\\']*\'
  55
  56 MC_TOKEN                ([~%^&*+=|<>/-]=)|(&&)|("||")|(->)|(<<)|(>>)
  57
  58 /* We don't do multiple input files.  */
  59 %option noyywrap
  60
  61 %option noinput
  62
  63 %%
  64
  65
  66  /* Keep track of our location in the original source files.  */
  67 ^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n     return FILENAME;
  68 ^#.*\n                                  cur_line++;
  69 \n                                      cur_line++;
  70
  71  /* Ignore all other whitespace.  */
  72 [ \t\f\v\r]+                            ;
  73
  74
  75 {STRING}                                return STRING;
  76 {CHAR}                                  return CHAR;
  77 {IDENT}                                 return IDENT;
  78
  79  /* The Pedant requires that the other C multi-character tokens be
  80     recognized as tokens.  We don't actually use them since we don't
  81     parse expressions, but we do want whitespace to be arranged
  82     around them properly.  */
  83 {MC_TOKEN}                              return OTHER;
  84 {INT}                                   return INT;
  85 {REAL}                                  return REAL;
  86
  87 "..."                                   return DOTS;
  88
  89  /* All other tokens are single characters.  */
  90 .                                       return yytext[0];
  91
  92
  93 %%
  94
  95 /* Bring in the keyword recognizer.  */
  96
  97 #include "keywords.hash.c"
  98
  99
 100 /* Macros to append to our phrase collection list.  */
 101
 102 /*
 103  * We mark any token, that that equals to a known enumerator, as
 104  * SYM_ENUM_CONST. The parser will change this for struct and union tags later,
 105  * the only problem is struct and union members:
 106  *    enum e { a, b }; struct s { int a, b; }
 107  * but in this case, the only effect will be, that the ABI checksums become
 108  * more volatile, which is acceptable. Also, such collisions are quite rare,
 109  * so far it was only observed in include/linux/telephony.h.
 110  */
 111 #define _APP(T,L)       do {                                               \
 112                           cur_node = next_node;                            \
 113                           next_node = xmalloc(sizeof(*next_node));         \
 114                           next_node->next = cur_node;                      \
 115                           cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
 116                           cur_node->tag =                                  \
 117                             find_symbol(cur_node->string, SYM_ENUM_CONST, 1)?\
 118                             SYM_ENUM_CONST : SYM_NORMAL ;                  \
 119                           cur_node->in_source_file = in_source_file;       \
 120                         } while (0)
 121
 122 #define APP             _APP(yytext, yyleng)
 123
 124
 125 /* The second stage lexer.  Here we incorporate knowledge of the state
 126    of the parser to tailor the tokens that are returned.  */
 127
 128 int
 129 yylex(void)
 130 {
 131   static enum {
 132     ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_TYPEOF, ST_TYPEOF_1,
 133     ST_BRACKET, ST_BRACE, ST_EXPRESSION,
 134     ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
 135     ST_TABLE_5, ST_TABLE_6
 136   } lexstate = ST_NOTSTARTED;
 137
 138   static int suppress_type_lookup, dont_want_brace_phrase;
 139   static struct string_list *next_node;
 140
 141   int token, count = 0;
 142   struct string_list *cur_node;
 143
 144   if (lexstate == ST_NOTSTARTED)
 145     {
 146       next_node = xmalloc(sizeof(*next_node));
 147       next_node->next = NULL;
 148       lexstate = ST_NORMAL;
 149     }
 150
 151 repeat:
 152   token = yylex1();
 153
 154   if (token == 0)
 155     return 0;
 156   else if (token == FILENAME)
 157     {
 158       char *file, *e;
 159
 160       /* Save the filename and line number for later error messages.  */
 161
 162       if (cur_filename)
 163         free(cur_filename);
 164
 165       file = strchr(yytext, '\"')+1;
 166       e = strchr(file, '\"');
 167       *e = '\0';
 168       cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
 169       cur_line = atoi(yytext+2);
 170
 171       if (!source_file) {
 172         source_file = xstrdup(cur_filename);
 173         in_source_file = 1;
 174       } else {
 175         in_source_file = (strcmp(cur_filename, source_file) == 0);
 176       }
 177
 178       goto repeat;
 179     }
 180
 181   switch (lexstate)
 182     {
 183     case ST_NORMAL:
 184       switch (token)
 185         {
 186         case IDENT:
 187           APP;
 188           {
 189             const struct resword *r = is_reserved_word(yytext, yyleng);
 190             if (r)
 191               {
 192                 switch (token = r->token)
 193                   {
 194                   case ATTRIBUTE_KEYW:
 195                     lexstate = ST_ATTRIBUTE;
 196                     count = 0;
 197                     goto repeat;
 198                   case ASM_KEYW:
 199                     lexstate = ST_ASM;
 200                     count = 0;
 201                     goto repeat;
 202                   case TYPEOF_KEYW:
 203                     lexstate = ST_TYPEOF;
 204                     count = 0;
 205                     goto repeat;
 206
 207                   case STRUCT_KEYW:
 208                   case UNION_KEYW:
 209                   case ENUM_KEYW:
 210                     dont_want_brace_phrase = 3;
 211                     suppress_type_lookup = 2;
 212                     goto fini;
 213
 214                   case EXPORT_SYMBOL_KEYW:
 215                       goto fini;
 216                   }
 217               }
 218             if (!suppress_type_lookup)
 219               {
 220                 if (find_symbol(yytext, SYM_TYPEDEF, 1))
 221                   token = TYPE;
 222               }
 223           }
 224           break;
 225
 226         case '[':
 227           APP;
 228           lexstate = ST_BRACKET;
 229           count = 1;
 230           goto repeat;
 231
 232         case '{':
 233           APP;
 234           if (dont_want_brace_phrase)
 235             break;
 236           lexstate = ST_BRACE;
 237           count = 1;
 238           goto repeat;
 239
 240         case '=': case ':':
 241           APP;
 242           lexstate = ST_EXPRESSION;
 243           break;
 244
 245         case DOTS:
 246         default:
 247           APP;
 248           break;
 249         }
 250       break;
 251
 252     case ST_ATTRIBUTE:
 253       APP;
 254       switch (token)
 255         {
 256         case '(':
 257           ++count;
 258           goto repeat;
 259         case ')':
 260           if (--count == 0)
 261             {
 262               lexstate = ST_NORMAL;
 263               token = ATTRIBUTE_PHRASE;
 264               break;
 265             }
 266           goto repeat;
 267         default:
 268           goto repeat;
 269         }
 270       break;
 271
 272     case ST_ASM:
 273       APP;
 274       switch (token)
 275         {
 276         case '(':
 277           ++count;
 278           goto repeat;
 279         case ')':
 280           if (--count == 0)
 281             {
 282               lexstate = ST_NORMAL;
 283               token = ASM_PHRASE;
 284               break;
 285             }
 286           goto repeat;
 287         default:
 288           goto repeat;
 289         }
 290       break;
 291
 292     case ST_TYPEOF:
 293       switch (token)
 294         {
 295         case '(':
 296           if ( ++count == 1 )
 297             lexstate = ST_TYPEOF_1;
 298           else
 299             APP;
 300           goto repeat;
 301         case ')':
 302           APP;
 303           if (--count == 0)
 304             {
 305               lexstate = ST_NORMAL;
 306               token = TYPEOF_PHRASE;
 307               break;
 308             }
 309           goto repeat;
 310         default:
 311           APP;
 312           goto repeat;
 313         }
 314       break;
 315
 316     case ST_TYPEOF_1:
 317       if (token == IDENT)
 318         {
 319           if (is_reserved_word(yytext, yyleng)
 320               || find_symbol(yytext, SYM_TYPEDEF, 1))
 321             {
 322               yyless(0);
 323               unput('(');
 324               lexstate = ST_NORMAL;
 325               token = TYPEOF_KEYW;
 326               break;
 327             }
 328           _APP("(", 1);
 329         }
 330         APP;
 331         lexstate = ST_TYPEOF;
 332         goto repeat;
 333
 334     case ST_BRACKET:
 335       APP;
 336       switch (token)
 337         {
 338         case '[':
 339           ++count;
 340           goto repeat;
 341         case ']':
 342           if (--count == 0)
 343             {
 344               lexstate = ST_NORMAL;
 345               token = BRACKET_PHRASE;
 346               break;
 347             }
 348           goto repeat;
 349         default:
 350           goto repeat;
 351         }
 352       break;
 353
 354     case ST_BRACE:
 355       APP;
 356       switch (token)
 357         {
 358         case '{':
 359           ++count;
 360           goto repeat;
 361         case '}':
 362           if (--count == 0)
 363             {
 364               lexstate = ST_NORMAL;
 365               token = BRACE_PHRASE;
 366               break;
 367             }
 368           goto repeat;
 369         default:
 370           goto repeat;
 371         }
 372       break;
 373
 374     case ST_EXPRESSION:
 375       switch (token)
 376         {
 377         case '(': case '[': case '{':
 378           ++count;
 379           APP;
 380           goto repeat;
 381         case '}':
 382           /* is this the last line of an enum declaration? */
 383           if (count == 0)
 384             {
 385               /* Put back the token we just read so's we can find it again
 386                  after registering the expression.  */
 387               unput(token);
 388
 389               lexstate = ST_NORMAL;
 390               token = EXPRESSION_PHRASE;
 391               break;
 392             }
 393           /* FALLTHRU */
 394         case ')': case ']':
 395           --count;
 396           APP;
 397           goto repeat;
 398         case ',': case ';':
 399           if (count == 0)
 400             {
 401               /* Put back the token we just read so's we can find it again
 402                  after registering the expression.  */
 403               unput(token);
 404
 405               lexstate = ST_NORMAL;
 406               token = EXPRESSION_PHRASE;
 407               break;
 408             }
 409           APP;
 410           goto repeat;
 411         default:
 412           APP;
 413           goto repeat;
 414         }
 415       break;
 416
 417     case ST_TABLE_1:
 418       goto repeat;
 419
 420     case ST_TABLE_2:
 421       if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
 422         {
 423           token = EXPORT_SYMBOL_KEYW;
 424           lexstate = ST_TABLE_5;
 425           APP;
 426           break;
 427         }
 428       lexstate = ST_TABLE_6;
 429       /* FALLTHRU */
 430
 431     case ST_TABLE_6:
 432       switch (token)
 433         {
 434         case '{': case '[': case '(':
 435           ++count;
 436           break;
 437         case '}': case ']': case ')':
 438           --count;
 439           break;
 440         case ',':
 441           if (count == 0)
 442             lexstate = ST_TABLE_2;
 443           break;
 444         };
 445       goto repeat;
 446
 447     case ST_TABLE_3:
 448       goto repeat;
 449
 450     case ST_TABLE_4:
 451       if (token == ';')
 452         lexstate = ST_NORMAL;
 453       goto repeat;
 454
 455     case ST_TABLE_5:
 456       switch (token)
 457         {
 458         case ',':
 459           token = ';';
 460           lexstate = ST_TABLE_2;
 461           APP;
 462           break;
 463         default:
 464           APP;
 465           break;
 466         }
 467       break;
 468
 469     default:
 470       exit(1);
 471     }
 472 fini:
 473
 474   if (suppress_type_lookup > 0)
 475     --suppress_type_lookup;
 476   if (dont_want_brace_phrase > 0)
 477     --dont_want_brace_phrase;
 478
 479   yylval = &next_node->next;
 480
 481   return token;
 482 }