UnknownSec Bypass 403

: /usr/src/linux-headers-4.4.0-210/scripts/genksyms/ [ drwxr-xr-x ]
name : lex.l /* 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. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ %{ #include <limits.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 %% /* 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.hash.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. */ 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_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4, ST_TABLE_5, ST_TABLE_6 } lexstate = ST_NOTSTARTED; static int suppress_type_lookup, dont_want_brace_phrase; static struct string_list *next_node; 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: switch (token) { case IDENT: APP; { const struct resword *r = is_reserved_word(yytext, yyleng); if (r) { switch (token = r->token) { 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; } } if (!suppress_type_lookup) { if (find_symbol(yytext, SYM_TYPEDEF, 1)) token = TYPE; } } break; case '[': APP; lexstate = ST_BRACKET; count = 1; goto repeat; case '{': APP; if (dont_want_brace_phrase) break; lexstate = ST_BRACE; count = 1; goto repeat; case '=': case ':': APP; lexstate = ST_EXPRESSION; break; case DOTS: default: APP; 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: 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_TYPEOF_1: if (token == IDENT) { if (is_reserved_word(yytext, yyleng) || find_symbol(yytext, SYM_TYPEDEF, 1)) { yyless(0); unput('('); lexstate = ST_NORMAL; token = TYPEOF_KEYW; break; } _APP("(", 1); } APP; lexstate = ST_TYPEOF; goto repeat; 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_TABLE_1: goto repeat; case ST_TABLE_2: if (token == IDENT && yyleng == 1 && yytext[0] == 'X') { token = EXPORT_SYMBOL_KEYW; lexstate = ST_TABLE_5; APP; break; } lexstate = ST_TABLE_6; /* FALLTHRU */ case ST_TABLE_6: switch (token) { case '{': case '[': case '(': ++count; break; case '}': case ']': case ')': --count; break; case ',': if (count == 0) lexstate = ST_TABLE_2; break; }; goto repeat; case ST_TABLE_3: goto repeat; case ST_TABLE_4: if (token == ';') lexstate = ST_NORMAL; goto repeat; case ST_TABLE_5: switch (token) { case ',': token = ';'; lexstate = ST_TABLE_2; APP; break; default: APP; break; } break; default: exit(1); } fini: if (suppress_type_lookup > 0) --suppress_type_lookup; if (dont_want_brace_phrase > 0) --dont_want_brace_phrase; yylval = &next_node->next; return token; }