xref: /openbmc/linux/scripts/genksyms/lex.l (revision 27ab1c1c) 
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