Quelle  lex.l   Sprache: unbekannt

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Lexical analysis for genksyms.
 * Copyright 1996, 1997 Linux International.
 *
 * New implementation contributed by Richard Henderson <rth@tamu.edu>
 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
 *
 * Taken from Linux modutils 2.4.22.
 */

%{

#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "genksyms.h"
#include "parse.tab.h"

/* We've got a two-level lexer here.  We let flex do basic tokenization
   and then we categorize those basic tokens in the second stage.  */
#define YY_DECL  static int yylex1(void)

%}

IDENT   [A-Za-z_\$][A-Za-z0-9_\$]*

O_INT   0[0-7]*
D_INT   [1-9][0-9]*
X_INT   0[Xx][0-9A-Fa-f]+
I_SUF   [Uu]|[Ll]|[Uu][Ll]|[Ll][Uu]
INT   ({O_INT}|{D_INT}|{X_INT}){I_SUF}?

FRAC   ([0-9]*\.[0-9]+)|([0-9]+\.)
EXP   [Ee][+-]?[0-9]+
F_SUF   [FfLl]
REAL   ({FRAC}{EXP}?{F_SUF}?)|([0-9]+{EXP}{F_SUF}?)

STRING   L?\"([^\\\"]*\\.)*[^\\\"]*\"
CHAR   L?\'([^\\\']*\\.)*[^\\\']*\'

MC_TOKEN  ([~%^&*+=|<>/-]=)|(&&)|("||")|(->)|(<<)|(>>)

/* We don't do multiple input files.  */
%option noyywrap

%option noinput

%%

u?int(8|16|32|64)x(1|2|4|8|16)_t return BUILTIN_INT_KEYW;

 /* Keep track of our location in the original source files.  */
^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n return FILENAME;
^#.*\n     cur_line++;
\n     cur_line++;

 /* Ignore all other whitespace.  */
[ \t\f\v\r]+    ;


{STRING}    return STRING;
{CHAR}     return CHAR;
{IDENT}     return IDENT;

 /* The Pedant requires that the other C multi-character tokens be
    recognized as tokens.  We don't actually use them since we don't
    parse expressions, but we do want whitespace to be arranged
    around them properly.  */
{MC_TOKEN}    return OTHER;
{INT}     return INT;
{REAL}     return REAL;

"..."     return DOTS;

 /* All other tokens are single characters.  */
.     return yytext[0];


%%

/* Bring in the keyword recognizer.  */

#include "keywords.c"


/* Macros to append to our phrase collection list.  */

/*
 * We mark any token, that that equals to a known enumerator, as
 * SYM_ENUM_CONST. The parser will change this for struct and union tags later,
 * the only problem is struct and union members:
 *    enum e { a, b }; struct s { int a, b; }
 * but in this case, the only effect will be, that the ABI checksums become
 * more volatile, which is acceptable. Also, such collisions are quite rare,
 * so far it was only observed in include/linux/telephony.h.
 */
#define _APP(T,L) do {         \
     cur_node = next_node;       \
     next_node = xmalloc(sizeof(*next_node));    \
     next_node->next = cur_node;      \
     cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
     cur_node->tag =       \
       find_symbol(cur_node->string, SYM_ENUM_CONST, 1)?\
       SYM_ENUM_CONST : SYM_NORMAL ;     \
     cur_node->in_source_file = in_source_file;       \
   } while (0)

#define APP  _APP(yytext, yyleng)


/* The second stage lexer.  Here we incorporate knowledge of the state
   of the parser to tailor the tokens that are returned.  */

/*
 * The lexer cannot distinguish whether a typedef'ed string is a TYPE or an
 * IDENT. We need a hint from the parser to handle this accurately.
 */
bool dont_want_type_specifier;

int
yylex(void)
{
  static enum {
    ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_TYPEOF, ST_TYPEOF_1,
    ST_BRACKET, ST_BRACE, ST_EXPRESSION, ST_STATIC_ASSERT,
  } lexstate = ST_NOTSTARTED;

  static int suppress_type_lookup, dont_want_brace_phrase;
  static struct string_list *next_node;
  static char *source_file;

  int token, count = 0;
  struct string_list *cur_node;

  if (lexstate == ST_NOTSTARTED)
    {
      next_node = xmalloc(sizeof(*next_node));
      next_node->next = NULL;
      lexstate = ST_NORMAL;
    }

repeat:
  token = yylex1();

  if (token == 0)
    return 0;
  else if (token == FILENAME)
    {
      char *file, *e;

      /* Save the filename and line number for later error messages.  */

      if (cur_filename)
 free(cur_filename);

      file = strchr(yytext, '\"')+1;
      e = strchr(file, '\"');
      *e = '\0';
      cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
      cur_line = atoi(yytext+2);

      if (!source_file) {
        source_file = xstrdup(cur_filename);
        in_source_file = 1;
      } else {
        in_source_file = (strcmp(cur_filename, source_file) == 0);
      }

      goto repeat;
    }

  switch (lexstate)
    {
    case ST_NORMAL:
      APP;
      switch (token)
 {
 case IDENT:
   {
     int r = is_reserved_word(yytext, yyleng);
     if (r >= 0)
       {
  switch (token = r)
    {
    case ATTRIBUTE_KEYW:
      lexstate = ST_ATTRIBUTE;
      count = 0;
      goto repeat;
    case ASM_KEYW:
      lexstate = ST_ASM;
      count = 0;
      goto repeat;
    case TYPEOF_KEYW:
      lexstate = ST_TYPEOF;
      count = 0;
      goto repeat;

    case STRUCT_KEYW:
    case UNION_KEYW:
    case ENUM_KEYW:
      dont_want_brace_phrase = 3;
      suppress_type_lookup = 2;
      goto fini;

    case EXPORT_SYMBOL_KEYW:
        goto fini;

    case STATIC_ASSERT_KEYW:
      lexstate = ST_STATIC_ASSERT;
      count = 0;
      goto repeat;
    }
       }
     if (!suppress_type_lookup && !dont_want_type_specifier)
       {
  if (find_symbol(yytext, SYM_TYPEDEF, 1))
    token = TYPE;
       }
   }
   break;

 case '[':
   lexstate = ST_BRACKET;
   count = 1;
   goto repeat;

 case '{':
   if (dont_want_brace_phrase)
     break;
   lexstate = ST_BRACE;
   count = 1;
   goto repeat;

 case '=': case ':':
   lexstate = ST_EXPRESSION;
   break;

 default:
   break;
 }
      break;

    case ST_ATTRIBUTE:
      APP;
      switch (token)
 {
 case '(':
   ++count;
   goto repeat;
 case ')':
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = ATTRIBUTE_PHRASE;
       break;
     }
   goto repeat;
 default:
   goto repeat;
 }
      break;

    case ST_ASM:
      APP;
      switch (token)
 {
 case '(':
   ++count;
   goto repeat;
 case ')':
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = ASM_PHRASE;
       break;
     }
   goto repeat;
 default:
   goto repeat;
 }
      break;

    case ST_TYPEOF_1:
      if (token == IDENT)
 {
   if (is_reserved_word(yytext, yyleng) >= 0
       || find_symbol(yytext, SYM_TYPEDEF, 1))
     {
       yyless(0);
       unput('(');
       lexstate = ST_NORMAL;
       token = TYPEOF_KEYW;
       break;
     }
   _APP("(", 1);
 }
 lexstate = ST_TYPEOF;
 /* FALLTHRU */

    case ST_TYPEOF:
      switch (token)
 {
 case '(':
   if ( ++count == 1 )
     lexstate = ST_TYPEOF_1;
   else
     APP;
   goto repeat;
 case ')':
   APP;
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = TYPEOF_PHRASE;
       break;
     }
   goto repeat;
 default:
   APP;
   goto repeat;
 }
      break;

    case ST_BRACKET:
      APP;
      switch (token)
 {
 case '[':
   ++count;
   goto repeat;
 case ']':
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = BRACKET_PHRASE;
       break;
     }
   goto repeat;
 default:
   goto repeat;
 }
      break;

    case ST_BRACE:
      APP;
      switch (token)
 {
 case '{':
   ++count;
   goto repeat;
 case '}':
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = BRACE_PHRASE;
       break;
     }
   goto repeat;
 default:
   goto repeat;
 }
      break;

    case ST_EXPRESSION:
      switch (token)
 {
 case '(': case '[': case '{':
   ++count;
   APP;
   goto repeat;
 case '}':
   /* is this the last line of an enum declaration? */
   if (count == 0)
     {
       /* Put back the token we just read so's we can find it again
   after registering the expression.  */
       unput(token);

       lexstate = ST_NORMAL;
       token = EXPRESSION_PHRASE;
       break;
     }
   /* FALLTHRU */
 case ')': case ']':
   --count;
   APP;
   goto repeat;
 case ',': case ';':
   if (count == 0)
     {
       /* Put back the token we just read so's we can find it again
   after registering the expression.  */
       unput(token);

       lexstate = ST_NORMAL;
       token = EXPRESSION_PHRASE;
       break;
     }
   APP;
   goto repeat;
 default:
   APP;
   goto repeat;
 }
      break;

    case ST_STATIC_ASSERT:
      APP;
      switch (token)
 {
 case '(':
   ++count;
   goto repeat;
 case ')':
   if (--count == 0)
     {
       lexstate = ST_NORMAL;
       token = STATIC_ASSERT_PHRASE;
       break;
     }
   goto repeat;
 default:
   goto repeat;
 }
      break;

    default:
      exit(1);
    }
fini:

  if (suppress_type_lookup > 0)
    --suppress_type_lookup;

  /*
   *  __attribute__() can be placed immediately after the 'struct' keyword.
   *  e.g.) struct __attribute__((__packed__)) foo { ... };
   */
  if (token != ATTRIBUTE_PHRASE && dont_want_brace_phrase > 0)
    --dont_want_brace_phrase;

  yylval = &next_node->next;

  return token;
}