Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / 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.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 /* Version 2 checksumming does proper tokenization; version 1 wasn't
59    quite so pedantic.  */
60 %s V2_TOKENS
61
62 /* We don't do multiple input files.  */
63 %option noyywrap
64
65 %option noinput
66
67 %%
68
69
70  /* Keep track of our location in the original source files.  */
71 ^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n     return FILENAME;
72 ^#.*\n                                  cur_line++;
73 \n                                      cur_line++;
74
75  /* Ignore all other whitespace.  */
76 [ \t\f\v\r]+                            ;
77
78
79 {STRING}                                return STRING;
80 {CHAR}                                  return CHAR;
81 {IDENT}                                 return IDENT;
82
83  /* The Pedant requires that the other C multi-character tokens be
84     recognized as tokens.  We don't actually use them since we don't
85     parse expressions, but we do want whitespace to be arranged
86     around them properly.  */
87 <V2_TOKENS>{MC_TOKEN}                   return OTHER;
88 <V2_TOKENS>{INT}                        return INT;
89 <V2_TOKENS>{REAL}                       return REAL;
90
91 "..."                                   return DOTS;
92
93  /* All other tokens are single characters.  */
94 .                                       return yytext[0];
95
96
97 %%
98
99 /* Bring in the keyword recognizer.  */
100
101 #include "keywords.c"
102
103
104 /* Macros to append to our phrase collection list.  */
105
106 #define _APP(T,L)       do {                                               \
107                           cur_node = next_node;                            \
108                           next_node = xmalloc(sizeof(*next_node));         \
109                           next_node->next = cur_node;                      \
110                           cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
111                           cur_node->tag = SYM_NORMAL;                      \
112                         } while (0)
113
114 #define APP             _APP(yytext, yyleng)
115
116
117 /* The second stage lexer.  Here we incorporate knowledge of the state
118    of the parser to tailor the tokens that are returned.  */
119
120 int
121 yylex(void)
122 {
123   static enum {
124     ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE,
125     ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
126     ST_TABLE_5, ST_TABLE_6
127   } lexstate = ST_NOTSTARTED;
128
129   static int suppress_type_lookup, dont_want_brace_phrase;
130   static struct string_list *next_node;
131
132   int token, count = 0;
133   struct string_list *cur_node;
134
135   if (lexstate == ST_NOTSTARTED)
136     {
137       BEGIN(V2_TOKENS);
138       next_node = xmalloc(sizeof(*next_node));
139       next_node->next = NULL;
140       lexstate = ST_NORMAL;
141     }
142
143 repeat:
144   token = yylex1();
145
146   if (token == 0)
147     return 0;
148   else if (token == FILENAME)
149     {
150       char *file, *e;
151
152       /* Save the filename and line number for later error messages.  */
153
154       if (cur_filename)
155         free(cur_filename);
156
157       file = strchr(yytext, '\"')+1;
158       e = strchr(file, '\"');
159       *e = '\0';
160       cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
161       cur_line = atoi(yytext+2);
162
163       goto repeat;
164     }
165
166   switch (lexstate)
167     {
168     case ST_NORMAL:
169       switch (token)
170         {
171         case IDENT:
172           APP;
173           {
174             const struct resword *r = is_reserved_word(yytext, yyleng);
175             if (r)
176               {
177                 switch (token = r->token)
178                   {
179                   case ATTRIBUTE_KEYW:
180                     lexstate = ST_ATTRIBUTE;
181                     count = 0;
182                     goto repeat;
183                   case ASM_KEYW:
184                     lexstate = ST_ASM;
185                     count = 0;
186                     goto repeat;
187
188                   case STRUCT_KEYW:
189                   case UNION_KEYW:
190                     dont_want_brace_phrase = 3;
191                   case ENUM_KEYW:
192                     suppress_type_lookup = 2;
193                     goto fini;
194
195                   case EXPORT_SYMBOL_KEYW:
196                       goto fini;
197                   }
198               }
199             if (!suppress_type_lookup)
200               {
201                 struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF);
202                 if (sym && sym->type == SYM_TYPEDEF)
203                   token = TYPE;
204               }
205           }
206           break;
207
208         case '[':
209           APP;
210           lexstate = ST_BRACKET;
211           count = 1;
212           goto repeat;
213
214         case '{':
215           APP;
216           if (dont_want_brace_phrase)
217             break;
218           lexstate = ST_BRACE;
219           count = 1;
220           goto repeat;
221
222         case '=': case ':':
223           APP;
224           lexstate = ST_EXPRESSION;
225           break;
226
227         case DOTS:
228         default:
229           APP;
230           break;
231         }
232       break;
233
234     case ST_ATTRIBUTE:
235       APP;
236       switch (token)
237         {
238         case '(':
239           ++count;
240           goto repeat;
241         case ')':
242           if (--count == 0)
243             {
244               lexstate = ST_NORMAL;
245               token = ATTRIBUTE_PHRASE;
246               break;
247             }
248           goto repeat;
249         default:
250           goto repeat;
251         }
252       break;
253
254     case ST_ASM:
255       APP;
256       switch (token)
257         {
258         case '(':
259           ++count;
260           goto repeat;
261         case ')':
262           if (--count == 0)
263             {
264               lexstate = ST_NORMAL;
265               token = ASM_PHRASE;
266               break;
267             }
268           goto repeat;
269         default:
270           goto repeat;
271         }
272       break;
273
274     case ST_BRACKET:
275       APP;
276       switch (token)
277         {
278         case '[':
279           ++count;
280           goto repeat;
281         case ']':
282           if (--count == 0)
283             {
284               lexstate = ST_NORMAL;
285               token = BRACKET_PHRASE;
286               break;
287             }
288           goto repeat;
289         default:
290           goto repeat;
291         }
292       break;
293
294     case ST_BRACE:
295       APP;
296       switch (token)
297         {
298         case '{':
299           ++count;
300           goto repeat;
301         case '}':
302           if (--count == 0)
303             {
304               lexstate = ST_NORMAL;
305               token = BRACE_PHRASE;
306               break;
307             }
308           goto repeat;
309         default:
310           goto repeat;
311         }
312       break;
313
314     case ST_EXPRESSION:
315       switch (token)
316         {
317         case '(': case '[': case '{':
318           ++count;
319           APP;
320           goto repeat;
321         case ')': case ']': case '}':
322           --count;
323           APP;
324           goto repeat;
325         case ',': case ';':
326           if (count == 0)
327             {
328               /* Put back the token we just read so's we can find it again
329                  after registering the expression.  */
330               unput(token);
331
332               lexstate = ST_NORMAL;
333               token = EXPRESSION_PHRASE;
334               break;
335             }
336           APP;
337           goto repeat;
338         default:
339           APP;
340           goto repeat;
341         }
342       break;
343
344     case ST_TABLE_1:
345       goto repeat;
346
347     case ST_TABLE_2:
348       if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
349         {
350           token = EXPORT_SYMBOL_KEYW;
351           lexstate = ST_TABLE_5;
352           APP;
353           break;
354         }
355       lexstate = ST_TABLE_6;
356       /* FALLTHRU */
357
358     case ST_TABLE_6:
359       switch (token)
360         {
361         case '{': case '[': case '(':
362           ++count;
363           break;
364         case '}': case ']': case ')':
365           --count;
366           break;
367         case ',':
368           if (count == 0)
369             lexstate = ST_TABLE_2;
370           break;
371         };
372       goto repeat;
373
374     case ST_TABLE_3:
375       goto repeat;
376
377     case ST_TABLE_4:
378       if (token == ';')
379         lexstate = ST_NORMAL;
380       goto repeat;
381
382     case ST_TABLE_5:
383       switch (token)
384         {
385         case ',':
386           token = ';';
387           lexstate = ST_TABLE_2;
388           APP;
389           break;
390         default:
391           APP;
392           break;
393         }
394       break;
395
396     default:
397       exit(1);
398     }
399 fini:
400
401   if (suppress_type_lookup > 0)
402     --suppress_type_lookup;
403   if (dont_want_brace_phrase > 0)
404     --dont_want_brace_phrase;
405
406   yylval = &next_node->next;
407
408   return token;
409 }