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