Branch data Line data Source code
1 : : %{
2 : : /* m2.flex implements lexical analysis for Modula-2.
3 : :
4 : : Copyright (C) 2004-2025 Free Software Foundation, Inc.
5 : : Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
6 : :
7 : : This file is part of GNU Modula-2.
8 : :
9 : : GNU Modula-2 is free software; you can redistribute it and/or modify
10 : : it under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3, or (at your option)
12 : : any later version.
13 : :
14 : : GNU Modula-2 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 GNU Modula-2; see the file COPYING3. If not see
21 : : <http://www.gnu.org/licenses/>. */
22 : :
23 : : #include "gm2-gcc/gcc-consolidation.h"
24 : :
25 : : #include "GM2Reserved.h"
26 : : #include "GM2LexBuf.h"
27 : : #include "input.h"
28 : : #include "m2options.h"
29 : : #include "Gm2linemap.h"
30 : :
31 : : static int cpreprocessor = 0; /* Replace this with correct getter. */
32 : :
33 : : #if defined(GM2USEGGC)
34 : : # include "ggc.h"
35 : : #endif
36 : :
37 : : #include "timevar.h"
38 : :
39 : : #define START_FILE(F,L) m2linemap_StartFile(F,L)
40 : : #define END_FILE() m2linemap_EndFile()
41 : : #define START_LINE(N,S) m2linemap_StartLine(N,S)
42 : : #define GET_LOCATION(COLUMN_START,COLUMN_END) \
43 : : m2linemap_GetLocationRange(COLUMN_START,COLUMN_END)
44 : : #define TIMEVAR_PUSH_LEX timevar_push (TV_LEX)
45 : : #define TIMEVAR_POP_LEX timevar_pop (TV_LEX)
46 : :
47 : : #ifdef __cplusplus
48 : : #define EXTERN extern "C"
49 : : #endif
50 : :
51 : : #define FIRST_COLUMN 1
52 : :
53 : : /* m2.flex provides a lexical analyser for GNU Modula-2. */
54 : :
55 : : struct lineInfo {
56 : : char *linebuf; /* line contents */
57 : : int linelen; /* length */
58 : : int tokenpos; /* start position of token within line */
59 : : int toklen; /* a copy of yylen (length of token) */
60 : : int nextpos; /* position after token */
61 : : int lineno; /* line number of this line */
62 : : int column; /* first column number of token on this line */
63 : : bool inuse; /* do we need to keep this line info? */
64 : : location_t location; /* the corresponding gcc location_t */
65 : : struct lineInfo *next;
66 : : };
67 : :
68 : : struct functionInfo {
69 : : char *name; /* function name */
70 : : bool module; /* is it really a module? */
71 : : struct functionInfo *next; /* list of nested functions */
72 : : };
73 : :
74 : : static int lineno =1; /* a running count of the file line number */
75 : : static char *filename =NULL;
76 : : static int commentLevel=0;
77 : : static int commentCLevel=0;
78 : : static struct lineInfo *currentLine=NULL;
79 : : static struct functionInfo *currentFunction=NULL;
80 : : static bool seenFunctionStart=false;
81 : : static bool seenEnd=false;
82 : : static bool seenModuleStart=false;
83 : : static bool isDefinitionModule=false;
84 : : static int totalLines=0;
85 : :
86 : : static void pushLine (void);
87 : : static void popLine (void);
88 : : static void finishedLine (void);
89 : : static void resetpos (void);
90 : : static void consumeLine (void);
91 : : static void updatepos (void);
92 : : static void skippos (void);
93 : : static void poperrorskip (const char *);
94 : : static void endOfComment (void);
95 : : static void endOfCComment (void);
96 : : static void splitSlashStar (void);
97 : : static void handleDate (void);
98 : : static void handleLine (void);
99 : : static void handleFile (void);
100 : : static void handleFunction (void);
101 : : static void handleColumn (void);
102 : : static void pushFunction (char *function, bool module);
103 : : static void popFunction (void);
104 : : static void checkFunction (void);
105 : : EXTERN void m2flex_M2Error (const char *);
106 : : EXTERN location_t m2flex_GetLocation (void);
107 : : EXTERN int m2flex_GetColumnNo (void);
108 : : EXTERN bool m2flex_OpenSource (char *s);
109 : : EXTERN int m2flex_GetLineNo (void);
110 : : EXTERN void m2flex_CloseSource (void);
111 : : EXTERN char *m2flex_GetToken (void);
112 : : EXTERN void _M2_m2flex_init (void);
113 : : EXTERN int m2flex_GetTotalLines (void);
114 : : extern void yylex (void);
115 : :
116 : : #define YY_DECL void yylex (void)
117 : : %}
118 : :
119 : : %option nounput
120 : : %x COMMENT COMMENT1 COMMENTC LINE0 LINE1 LINE2
121 : :
122 : : %%
123 : :
124 : 3055226 : "(*" { updatepos();
125 : 3055226 : commentLevel=1; pushLine(); skippos();
126 : 3055226 : BEGIN COMMENT; }
127 : 6247347 : <COMMENT>"*)" { endOfComment(); }
128 : 3329028 : <COMMENT>"(*" { commentLevel++; pushLine(); updatepos(); skippos(); }
129 : 3208030 : <COMMENT>"<*" { if (commentLevel == 1) {
130 : 152810 : updatepos();
131 : 31812 : pushLine();
132 : 15903 : skippos();
133 : 15903 : BEGIN COMMENT1;
134 : : } else {
135 : 6 : updatepos(); skippos();
136 : : }
137 : : }
138 : 13536285 : <COMMENT>\n.* { consumeLine(); }
139 : 575806003 : <COMMENT>. { updatepos(); skippos(); }
140 : 159030 : <COMMENT1>. { updatepos(); skippos(); }
141 : 575821906 : <COMMENT1>"*>" { updatepos(); skippos(); finishedLine(); BEGIN COMMENT; }
142 : 159030 : <COMMENT1>\n.* { consumeLine(); }
143 : 15903 : <COMMENT1>"*)" { poperrorskip("unterminated source code directive, missing *>");
144 : 0 : endOfComment(); }
145 : 0 : <COMMENT1><<EOF>> { poperrorskip("unterminated source code directive, missing *>"); BEGIN COMMENT; }
146 : 0 : <COMMENT><<EOF>> { poperrorskip("unterminated comment found at the end of the file, missing *)"); BEGIN INITIAL; }
147 : 12 :
148 : 0 : "/*" { /* Possibly handle C preprocessor comment. */
149 : 0 : if (cpreprocessor)
150 : : {
151 : 0 : updatepos ();
152 : 0 : commentCLevel++;
153 : 0 : if (commentCLevel == 1)
154 : : {
155 : 0 : pushLine ();
156 : 0 : skippos ();
157 : : }
158 : 0 : BEGIN COMMENTC;
159 : : }
160 : : else
161 : 0 : splitSlashStar ();
162 : : }
163 : 0 : <COMMENTC>. { updatepos(); skippos(); }
164 : 0 : <COMMENTC>\n.* { consumeLine(); }
165 : 0 : <COMMENTC>"*/" { endOfCComment(); }
166 : 15408 : ^\#.* { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */
167 : 15408 : if (M2Options_GetLineDirectives ())
168 : 30816 : BEGIN LINE0;
169 : : }
170 : 12328 : \n\#.* { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */
171 : 12328 : if (M2Options_GetLineDirectives ())
172 : 12328 : BEGIN LINE0;
173 : 12328 : }
174 : 12328 : <LINE0>\#[ \t]* { updatepos(); }
175 : 40064 : <LINE0>[0-9]+[ \t]*\" { updatepos(); lineno=atoi(yytext); BEGIN LINE1; }
176 : 40064 : <LINE0>\n { m2flex_M2Error("missing initial quote after #line directive"); resetpos(); BEGIN INITIAL; }
177 : 27736 : <LINE0>[^\n]
178 : 0 : <LINE1>[^\"\n]+ { m2flex_M2Error("missing final quote after #line directive"); resetpos(); BEGIN INITIAL; }
179 : 43144 : <LINE1>.*\" { updatepos();
180 : 27736 : filename = (char *)xrealloc(filename, yyleng+1);
181 : 27736 : strcpy(filename, yytext);
182 : 27736 : filename[yyleng-1] = (char)0; /* remove trailing quote */
183 : 27736 : START_FILE (filename, lineno);
184 : 27736 : BEGIN LINE2;
185 : : }
186 : 27736 : <LINE2>[ \t]* { updatepos(); }
187 : 27736 : <LINE2>\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
188 : 30604 : <LINE2>2[ \t]*\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
189 : 2868 : <LINE2>1[ \t]*\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
190 : 16264 : <LINE2>1[ \t]*.*\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
191 : 5736 : <LINE2>2[ \t]*.*\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
192 : 8604 : <LINE2>3[ \t]*.*\n { M2LexBuf_SetFile(filename); updatepos(); BEGIN INITIAL; }
193 : 11472 :
194 : 0 : \n[^\#].* { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */ }
195 : 30095714 : \n { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */ }
196 : 30279649 :
197 : 315919 : \"[^\"\n]*\" { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_stringtok, yytext); return; }
198 : 508458 : \"[^\"\n]*$ { updatepos();
199 : 0 : m2flex_M2Error("missing terminating quote, \"");
200 : 0 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, yytext);
201 : 0 : resetpos(); return;
202 : 0 : }
203 : 0 :
204 : 466454 : '[^'\n]*' { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_stringtok, yytext); return; }
205 : 466460 : '[^'\n]*$ { updatepos();
206 : 6 : m2flex_M2Error("missing terminating quote, '");
207 : 6 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, yytext);
208 : 12 : resetpos(); return;
209 : 6 : }
210 : 6 :
211 : 192988 : <<EOF>> { updatepos(); M2LexBuf_AddTok(M2Reserved_eoftok); return; }
212 : 189068 : \+ { updatepos(); M2LexBuf_AddTok(M2Reserved_plustok); return; }
213 : 188736 : - { updatepos(); M2LexBuf_AddTok(M2Reserved_minustok); return; }
214 : 261012 : "*" { updatepos(); M2LexBuf_AddTok(M2Reserved_timestok); return; }
215 : 382704 : \/ { updatepos(); M2LexBuf_AddTok(M2Reserved_dividetok); return; }
216 : 2210876 : := { updatepos(); M2LexBuf_AddTok(M2Reserved_becomestok); return; }
217 : 980 : \& { updatepos(); M2LexBuf_AddTok(M2Reserved_ambersandtok); return; }
218 : 3499603 : \. { updatepos(); M2LexBuf_AddTok(M2Reserved_periodtok); return; }
219 : 7861875 : \, { updatepos(); M2LexBuf_AddTok(M2Reserved_commatok); return; }
220 : 13379354 : \; { updatepos(); M2LexBuf_AddTok(M2Reserved_semicolontok); return; }
221 : 15815777 : \( { updatepos(); M2LexBuf_AddTok(M2Reserved_lparatok); return; }
222 : 19972591 : \) { updatepos(); M2LexBuf_AddTok(M2Reserved_rparatok); return; }
223 : 8804271 : \[ { updatepos(); M2LexBuf_AddTok(M2Reserved_lsbratok); return; }
224 : 8804251 : \] { updatepos(); M2LexBuf_AddTok(M2Reserved_rsbratok); return; }
225 : 850369 : \(\! { updatepos(); M2LexBuf_AddTok(M2Reserved_lsbratok); return; }
226 : 850343 : \!\) { updatepos(); M2LexBuf_AddTok(M2Reserved_rsbratok); return; }
227 : 763924 : \^ { updatepos(); M2LexBuf_AddTok(M2Reserved_uparrowtok); return; }
228 : 0 : \@ { updatepos(); M2LexBuf_AddTok(M2Reserved_uparrowtok); return; }
229 : 786414 : \{ { updatepos(); M2LexBuf_AddTok(M2Reserved_lcbratok); return; }
230 : 22490 : \} { updatepos(); M2LexBuf_AddTok(M2Reserved_rcbratok); return; }
231 : 22490 : \(\: { updatepos(); M2LexBuf_AddTok(M2Reserved_lcbratok); return; }
232 : 22490 : \:\) { updatepos(); M2LexBuf_AddTok(M2Reserved_rcbratok); return; }
233 : 0 : \' { updatepos(); M2LexBuf_AddTok(M2Reserved_singlequotetok); return; }
234 : 971815 : \= { updatepos(); M2LexBuf_AddTok(M2Reserved_equaltok); return; }
235 : 372360 : \# { updatepos(); M2LexBuf_AddTok(M2Reserved_hashtok); return; }
236 : 1182781 : \< { updatepos(); M2LexBuf_AddTok(M2Reserved_lesstok); return; }
237 : 528926 : \> { updatepos(); M2LexBuf_AddTok(M2Reserved_greatertok); return; }
238 : 211050 : \<\> { updatepos(); M2LexBuf_AddTok(M2Reserved_lessgreatertok); return; }
239 : 310488 : \<\= { updatepos(); M2LexBuf_AddTok(M2Reserved_lessequaltok); return; }
240 : 56842 : \>\= { updatepos(); M2LexBuf_AddTok(M2Reserved_greaterequaltok); return; }
241 : 656448 : "<*" { updatepos(); M2LexBuf_AddTok(M2Reserved_ldirectivetok); return; }
242 : 559284 : "*>" { updatepos(); M2LexBuf_AddTok(M2Reserved_rdirectivetok); return; }
243 : 589090 : \.\. { updatepos(); M2LexBuf_AddTok(M2Reserved_periodperiodtok); return; }
244 : 513726 : \.\.\. { updatepos(); M2LexBuf_AddTok(M2Reserved_periodperiodperiodtok); return; }
245 : 7673586 : \: { updatepos(); M2LexBuf_AddTok(M2Reserved_colontok); return; }
246 : 11200 : \" { updatepos(); M2LexBuf_AddTok(M2Reserved_doublequotestok); return; }
247 : 7597280 : \| { updatepos(); M2LexBuf_AddTok(M2Reserved_bartok); return; }
248 : 0 : \! { updatepos(); M2LexBuf_AddTok(M2Reserved_bartok); return; }
249 : 10258 : \~ { updatepos(); M2LexBuf_AddTok(M2Reserved_nottok); return; }
250 : 261390 : AND { updatepos(); M2LexBuf_AddTok(M2Reserved_andtok); return; }
251 : 625839 : ARRAY { updatepos(); M2LexBuf_AddTok(M2Reserved_arraytok); return; }
252 : 1284241 : BEGIN { updatepos(); M2LexBuf_AddTok(M2Reserved_begintok); return; }
253 : 626211 : BY { updatepos(); M2LexBuf_AddTok(M2Reserved_bytok); return; }
254 : 1027793 : CASE { updatepos(); M2LexBuf_AddTok(M2Reserved_casetok); return; }
255 : 57421 : CONST { updatepos(); M2LexBuf_AddTok(M2Reserved_consttok); return; }
256 : 130609 : DEFINITION { updatepos(); isDefinitionModule = true;
257 : 182716 : M2LexBuf_AddTok(M2Reserved_definitiontok); return; }
258 : 168599 : DIV { updatepos(); M2LexBuf_AddTok(M2Reserved_divtok); return; }
259 : 344438 : DO { updatepos(); M2LexBuf_AddTok(M2Reserved_dotok); return; }
260 : 487752 : ELSE { updatepos(); M2LexBuf_AddTok(M2Reserved_elsetok); return; }
261 : 440040 : ELSIF { updatepos(); M2LexBuf_AddTok(M2Reserved_elsiftok); return; }
262 : 3114274 : END { updatepos(); seenEnd=true;
263 : 2765056 : M2LexBuf_AddTok(M2Reserved_endtok); return; }
264 : 2669688 : EXCEPT { updatepos(); M2LexBuf_AddTok(M2Reserved_excepttok); return; }
265 : 106 : EXIT { updatepos(); M2LexBuf_AddTok(M2Reserved_exittok); return; }
266 : 73799 : EXPORT { updatepos(); M2LexBuf_AddTok(M2Reserved_exporttok); return; }
267 : 5940 : FINALLY { updatepos(); M2LexBuf_AddTok(M2Reserved_finallytok); return; }
268 : 95109 : FOR { updatepos(); M2LexBuf_AddTok(M2Reserved_fortok); return; }
269 : 5894 : FORWARD { updatepos(); M2LexBuf_AddTok(M2Reserved_forwardtok); return; }
270 : 282181 : FROM { updatepos(); M2LexBuf_AddTok(M2Reserved_fromtok); return; }
271 : 1078627 : IF { updatepos(); M2LexBuf_AddTok(M2Reserved_iftok); return; }
272 : 320521 : IMPLEMENTATION { updatepos(); M2LexBuf_AddTok(M2Reserved_implementationtok); return; }
273 : 1374546 : IMPORT { updatepos(); M2LexBuf_AddTok(M2Reserved_importtok); return; }
274 : 71858 : IN { updatepos(); M2LexBuf_AddTok(M2Reserved_intok); return; }
275 : 304525 : LOOP { updatepos(); M2LexBuf_AddTok(M2Reserved_looptok); return; }
276 : 79430 : MOD { updatepos(); M2LexBuf_AddTok(M2Reserved_modtok); return; }
277 : 217887 : MODULE { updatepos(); seenModuleStart=true;
278 : 276797 : M2LexBuf_AddTok(M2Reserved_moduletok); return; }
279 : 284783 : NOT { updatepos(); M2LexBuf_AddTok(M2Reserved_nottok); return; }
280 : 632777 : OF { updatepos(); M2LexBuf_AddTok(M2Reserved_oftok); return; }
281 : 181936 : OR { updatepos(); M2LexBuf_AddTok(M2Reserved_ortok); return; }
282 : 632891 : PACKEDSET { updatepos(); M2LexBuf_AddTok(M2Reserved_packedsettok); return; }
283 : 186468 : POINTER { updatepos(); M2LexBuf_AddTok(M2Reserved_pointertok); return; }
284 : 3150738 : PROCEDURE { updatepos(); seenFunctionStart=true;
285 : 3230598 : M2LexBuf_AddTok(M2Reserved_proceduretok); return; }
286 : 3217239 : QUALIFIED { updatepos(); M2LexBuf_AddTok(M2Reserved_qualifiedtok); return; }
287 : 6656 : UNQUALIFIED { updatepos(); M2LexBuf_AddTok(M2Reserved_unqualifiedtok); return; }
288 : 117610 : RECORD { updatepos(); M2LexBuf_AddTok(M2Reserved_recordtok); return; }
289 : 6752 : REM { updatepos(); M2LexBuf_AddTok(M2Reserved_remtok); return; }
290 : 106975 : REPEAT { updatepos(); M2LexBuf_AddTok(M2Reserved_repeattok); return; }
291 : 270 : RETRY { updatepos(); M2LexBuf_AddTok(M2Reserved_retrytok); return; }
292 : 609591 : RETURN { updatepos(); M2LexBuf_AddTok(M2Reserved_returntok); return; }
293 : 2050 : SET { updatepos(); M2LexBuf_AddTok(M2Reserved_settok); return; }
294 : 1727780 : THEN { updatepos(); M2LexBuf_AddTok(M2Reserved_thentok); return; }
295 : 95248 : TO { updatepos(); M2LexBuf_AddTok(M2Reserved_totok); return; }
296 : 1271109 : TYPE { updatepos(); M2LexBuf_AddTok(M2Reserved_typetok); return; }
297 : 149352 : UNTIL { updatepos(); M2LexBuf_AddTok(M2Reserved_untiltok); return; }
298 : 1042076 : VAR { updatepos(); M2LexBuf_AddTok(M2Reserved_vartok); return; }
299 : 249140 : WHILE { updatepos(); M2LexBuf_AddTok(M2Reserved_whiletok); return; }
300 : 1083010 : WITH { updatepos(); M2LexBuf_AddTok(M2Reserved_withtok); return; }
301 : 193187 : ASM { updatepos(); M2LexBuf_AddTok(M2Reserved_asmtok); return; }
302 : 137889 : VOLATILE { updatepos(); M2LexBuf_AddTok(M2Reserved_volatiletok); return; }
303 : 27 : \_\_DATE\_\_ { updatepos(); handleDate(); return; }
304 : 83929 : \_\_LINE\_\_ { updatepos(); handleLine(); return; }
305 : 80362 : \_\_FILE\_\_ { updatepos(); handleFile(); return; }
306 : 162518 : \_\_FUNCTION\_\_ { updatepos(); handleFunction(); return; }
307 : 133866 : \_\_COLUMN\_\_ { updatepos(); handleColumn(); return; }
308 : 164434 : \_\_ATTRIBUTE\_\_ { updatepos(); M2LexBuf_AddTok(M2Reserved_attributetok); return; }
309 : 192998 : \_\_BUILTIN\_\_ { updatepos(); M2LexBuf_AddTok(M2Reserved_builtintok); return; }
310 : 85830 : \_\_INLINE\_\_ { updatepos(); M2LexBuf_AddTok(M2Reserved_inlinetok); return; }
311 : 139494 :
312 : 0 :
313 : 9346 : (([0-9]*\.[0-9]+)(E[+-]?[0-9]+)?) { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_realtok, yytext); return; }
314 : 6 : [0-9]*\.E[+-]?[0-9]+ { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_realtok, yytext); return; }
315 : 42326545 : [a-zA-Z_][a-zA-Z0-9_]* { checkFunction(); updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_identtok, yytext); return; }
316 : 1193882 : [0-9]+ { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_integertok, yytext); return; }
317 : 42326569 : [0-1]+A { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_integertok, yytext); return; }
318 : 1196562 : [0-9]+B { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_integertok, yytext); return; }
319 : 132492 : [0-9]+C { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_integertok, yytext); return; }
320 : 13960 : [0-9A-F]+H { updatepos(); M2LexBuf_AddTokCharStar(M2Reserved_integertok, yytext); return; }
321 : 132468 : [\t\r ]+ { currentLine->tokenpos += yyleng; /* Ignore space. */; }
322 : 64870129 : . { updatepos(); m2flex_M2Error("unrecognised symbol"); skippos(); }
323 : 64858855 :
324 : 0 : %%
325 : 0 :
326 : : /* have removed the -? from the beginning of the real/integer constant literal rules */
327 : :
328 : : /*
329 : : * hand built routines
330 : : */
331 : :
332 : : /*
333 : : * handleFile - handles the __FILE__ construct by wraping it in double quotes and putting
334 : : * it into the token buffer as a string.
335 : : */
336 : :
337 : 80362 : static void handleFile (void)
338 : : {
339 : 80362 : char *s = (char *)alloca(strlen(filename)+2+1);
340 : :
341 : 80362 : strcpy(s, "\"");
342 : 80362 : strcat(s, filename);
343 : 80362 : strcat(s, "\"");
344 : 80362 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, s);
345 : 80362 : }
346 : :
347 : : /*
348 : : * handleLine - handles the __LINE__ construct by passing an integer to
349 : : * the token buffer.
350 : : */
351 : :
352 : 83914 : static void handleLine (void)
353 : : {
354 : 83914 : M2LexBuf_AddTokInteger(M2Reserved_integertok, lineno);
355 : 83914 : }
356 : :
357 : : /*
358 : : * handleColumn - handles the __COLUMN__ construct by passing an integer to
359 : : * the token buffer.
360 : : */
361 : :
362 : 53504 : static void handleColumn (void)
363 : : {
364 : 53504 : M2LexBuf_AddTokInteger(M2Reserved_integertok, m2flex_GetColumnNo());
365 : 53504 : }
366 : :
367 : : /*
368 : : * handleDate - handles the __DATE__ construct by passing the date
369 : : * as a string to the token buffer.
370 : : */
371 : :
372 : 0 : static void handleDate (void)
373 : : {
374 : 0 : time_t clock = time ((time_t *)0);
375 : 0 : char *sdate = ctime (&clock);
376 : 0 : char *s = (char *) alloca (strlen (sdate) + 2 + 1);
377 : 0 : char *p = index (sdate, '\n');
378 : :
379 : 0 : if (p != NULL) {
380 : 0 : *p = (char) 0;
381 : : }
382 : 0 : strcpy(s, "\"");
383 : 0 : strcat(s, sdate);
384 : 0 : strcat(s, "\"");
385 : 0 : M2LexBuf_AddTokCharStar (M2Reserved_stringtok, s);
386 : 0 : }
387 : :
388 : : /*
389 : : * handleFunction - handles the __FUNCTION__ construct by wrapping
390 : : * it in double quotes and putting it into the token
391 : : * buffer as a string.
392 : : */
393 : :
394 : 78604 : static void handleFunction (void)
395 : : {
396 : 78604 : if (currentFunction == NULL)
397 : 0 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, const_cast<char *>("\"\""));
398 : 78604 : else if (currentFunction->module) {
399 : 6 : char *s = (char *) alloca(strlen(yytext) +
400 : : strlen("\"module initialization\"") + 1);
401 : 6 : strcpy(s, "\"module ");
402 : 6 : strcat(s, currentFunction->name);
403 : 6 : strcat(s, " initialization\"");
404 : 6 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, s);
405 : : } else {
406 : 78598 : char *function = currentFunction->name;
407 : 78598 : char *s = (char *)alloca(strlen(function)+2+1);
408 : 78598 : strcpy(s, "\"");
409 : 78598 : strcat(s, function);
410 : 78598 : strcat(s, "\"");
411 : 78598 : M2LexBuf_AddTokCharStar(M2Reserved_stringtok, s);
412 : : }
413 : 78604 : }
414 : :
415 : : /*
416 : : * pushFunction - pushes the function name onto the stack.
417 : : */
418 : :
419 : 1018206 : static void pushFunction (char *function, bool module)
420 : : {
421 : 1018206 : if (currentFunction == NULL) {
422 : 83248 : currentFunction = (struct functionInfo *)xmalloc (sizeof (struct functionInfo));
423 : 83248 : currentFunction->name = xstrdup(function);
424 : 83248 : currentFunction->next = NULL;
425 : 83248 : currentFunction->module = module;
426 : : } else {
427 : 934958 : struct functionInfo *f = (struct functionInfo *)xmalloc (sizeof (struct functionInfo));
428 : 934958 : f->name = xstrdup(function);
429 : 934958 : f->next = currentFunction;
430 : 934958 : f->module = module;
431 : 934958 : currentFunction = f;
432 : : }
433 : 1018206 : }
434 : :
435 : : /*
436 : : * popFunction - pops the current function.
437 : : */
438 : :
439 : 1002111 : static void popFunction (void)
440 : : {
441 : 1002111 : if (currentFunction != NULL && currentFunction->next != NULL) {
442 : 934880 : struct functionInfo *f = currentFunction;
443 : :
444 : 934880 : currentFunction = currentFunction->next;
445 : 934880 : if (f->name != NULL)
446 : 934880 : free(f->name);
447 : 934880 : free(f);
448 : : }
449 : 1002111 : }
450 : :
451 : : /*
452 : : * endOfComment - handles the end of comment
453 : : */
454 : :
455 : 3192121 : static void endOfComment (void)
456 : : {
457 : 3192121 : commentLevel--;
458 : 3192121 : updatepos();
459 : 3192121 : skippos();
460 : 3192121 : if (commentLevel==0) {
461 : 3055214 : BEGIN INITIAL;
462 : 3055214 : finishedLine();
463 : : } else
464 : 136907 : popLine();
465 : 3192121 : }
466 : :
467 : : /*
468 : : * endOfCComment - handles the end of C comment.
469 : : */
470 : :
471 : 0 : static void endOfCComment (void)
472 : : {
473 : 0 : commentCLevel = 0;
474 : 0 : updatepos();
475 : 0 : skippos();
476 : 0 : BEGIN INITIAL;
477 : 0 : finishedLine();
478 : 0 : }
479 : :
480 : : /*
481 : : * m2flex_M2Error - displays the error message, s, after the code line and pointer
482 : : * to the erroneous token.
483 : : */
484 : :
485 : 24 : EXTERN void m2flex_M2Error (const char *s)
486 : : {
487 : 24 : if (currentLine->linebuf != NULL) {
488 : 12 : int i=1;
489 : :
490 : 12 : printf("%s:%d:%s\n", filename, currentLine->lineno, currentLine->linebuf);
491 : 12 : printf("%s:%d:%*s", filename, currentLine->lineno, 1+currentLine->tokenpos, "^");
492 : 60 : while (i<currentLine->toklen) {
493 : 36 : putchar('^');
494 : 36 : i++;
495 : : }
496 : 12 : putchar('\n');
497 : : }
498 : 24 : if (s == NULL)
499 : 0 : printf("%s:%d\n", filename, currentLine->lineno);
500 : : else
501 : 24 : printf("%s:%d:%s\n", filename, currentLine->lineno, s);
502 : 24 : }
503 : :
504 : 12 : static void poperrorskip (const char *s)
505 : : {
506 : 12 : int nextpos =currentLine->nextpos;
507 : 12 : int tokenpos=currentLine->tokenpos;
508 : :
509 : 12 : popLine();
510 : 12 : m2flex_M2Error(s);
511 : 12 : if (currentLine != NULL) {
512 : 12 : currentLine->nextpos = nextpos;
513 : 12 : currentLine->tokenpos = tokenpos;
514 : : }
515 : 12 : }
516 : :
517 : : /* skipnewline skips all '\n' at the start of the line and returns
518 : : the new position. */
519 : :
520 : : static
521 : : char *
522 : 0 : skipnewline (char *line)
523 : : {
524 : 0 : while (((*line) != (char)0) && ((*line) == '\n'))
525 : 0 : line++;
526 : 0 : return line;
527 : : }
528 : :
529 : : /* traceLine display the source line providing -fdebug-trace-line was
530 : : enabled. */
531 : :
532 : : static
533 : : void
534 : 43843670 : traceLine (void)
535 : : {
536 : 43843670 : if (M2Options_GetDebugTraceLine ())
537 : : {
538 : 0 : char *line = skipnewline (currentLine->linebuf);
539 : 0 : if (filename == NULL)
540 : 0 : printf("<stdin>:%d:%s\n", currentLine->lineno, line);
541 : : else
542 : 0 : printf("%s:%d:%s\n", filename, currentLine->lineno, line);
543 : : }
544 : 43843670 : }
545 : :
546 : : /*
547 : : * consumeLine - reads a line into a buffer, it then pushes back the whole
548 : : * line except the initial \n.
549 : : */
550 : :
551 : 43843670 : static void consumeLine (void)
552 : : {
553 : 43843670 : if (currentLine->linelen<yyleng) {
554 : 294048 : currentLine->linebuf = (char *)xrealloc (currentLine->linebuf, yyleng);
555 : 294048 : currentLine->linelen = yyleng;
556 : : }
557 : 43843670 : strcpy(currentLine->linebuf, yytext+1); /* copy all except the initial \n */
558 : 43843670 : lineno++;
559 : 43843670 : totalLines++;
560 : 43843670 : currentLine->lineno = lineno;
561 : 43843670 : currentLine->tokenpos=0;
562 : 43843670 : currentLine->nextpos=0;
563 : 43843670 : currentLine->column=FIRST_COLUMN;
564 : 43843670 : START_LINE (lineno, yyleng);
565 : 43843670 : yyless(1); /* push back all but the \n */
566 : 43843670 : traceLine ();
567 : 43843670 : }
568 : :
569 : 0 : static void assert_location (location_t location ATTRIBUTE_UNUSED)
570 : : {
571 : : #if 0
572 : : if ((location != BUILTINS_LOCATION) && (location != UNKNOWN_LOCATION) && (! M2Options_GetCpp ())) {
573 : : expanded_location xl = expand_location (location);
574 : : if (xl.line != currentLine->lineno) {
575 : : m2flex_M2Error ("mismatched gcc location and front end token number");
576 : : }
577 : : }
578 : : #endif
579 : 0 : }
580 : :
581 : : /*
582 : : * splitSlashStar - called if we are not tokenizing source code after it
583 : : * has been preprocessed by cpp. It is only called
584 : : * if the current token was a / immediately followed by * and
585 : : * therefore it will be split into two m2 tokens: / and *.
586 : : */
587 : :
588 : 0 : static void splitSlashStar (void)
589 : : {
590 : 0 : seenFunctionStart = false;
591 : 0 : seenEnd = false;
592 : 0 : seenModuleStart = false;
593 : 0 : currentLine->nextpos = currentLine->tokenpos+1; /* "/". */
594 : 0 : currentLine->toklen = 1;
595 : 0 : currentLine->column = currentLine->tokenpos+1;
596 : 0 : currentLine->location =
597 : 0 : M2Options_OverrideLocation (GET_LOCATION (currentLine->column,
598 : : currentLine->column+currentLine->toklen-1));
599 : 0 : assert_location (GET_LOCATION (currentLine->column,
600 : : currentLine->column+currentLine->toklen-1));
601 : 0 : M2LexBuf_AddTok (M2Reserved_dividetok);
602 : 0 : currentLine->nextpos = currentLine->tokenpos+1; /* "*". */
603 : 0 : currentLine->toklen = 1;
604 : 0 : currentLine->column = currentLine->tokenpos+1;
605 : 0 : currentLine->location =
606 : 0 : M2Options_OverrideLocation (GET_LOCATION (currentLine->column,
607 : : currentLine->column+currentLine->toklen-1));
608 : 0 : assert_location (GET_LOCATION (currentLine->column,
609 : : currentLine->column+currentLine->toklen-1));
610 : 0 : M2LexBuf_AddTok (M2Reserved_timestok);
611 : 0 : }
612 : :
613 : :
614 : : /*
615 : : * updatepos - updates the current token position.
616 : : * Should be used when a rule matches a token.
617 : : */
618 : :
619 : 682459056 : static void updatepos (void)
620 : : {
621 : 682459056 : seenFunctionStart = false;
622 : 682459056 : seenEnd = false;
623 : 682459056 : seenModuleStart = false;
624 : 682459056 : currentLine->nextpos = currentLine->tokenpos+yyleng;
625 : 682459056 : currentLine->toklen = yyleng;
626 : 682459056 : currentLine->column = currentLine->tokenpos+1;
627 : 2047377168 : currentLine->location =
628 : 682459056 : M2Options_OverrideLocation (GET_LOCATION (currentLine->column,
629 : : currentLine->column+currentLine->toklen-1));
630 : 682459056 : assert_location (GET_LOCATION (currentLine->column,
631 : : currentLine->column+currentLine->toklen-1));
632 : 682459056 : }
633 : :
634 : : /*
635 : : * checkFunction - checks to see whether we have seen the start
636 : : * or end of a function.
637 : : */
638 : :
639 : 42326545 : static void checkFunction (void)
640 : : {
641 : 42326545 : if (! isDefinitionModule) {
642 : 26715755 : if (seenModuleStart)
643 : 83674 : pushFunction(yytext, 1);
644 : 26715755 : if (seenFunctionStart)
645 : 934532 : pushFunction(yytext, 0);
646 : 26715755 : if (seenEnd && currentFunction != NULL &&
647 : 1056299 : (strcmp(currentFunction->name, yytext) == 0))
648 : 1002111 : popFunction();
649 : : }
650 : 42326545 : seenFunctionStart = false;
651 : 42326545 : seenEnd = false;
652 : 42326545 : seenModuleStart = false;
653 : 42326545 : }
654 : :
655 : : /*
656 : : * skippos - skips over this token. This function should be called
657 : : * if we are not returning and thus not calling getToken.
658 : : */
659 : :
660 : 568844814 : static void skippos (void)
661 : : {
662 : 6263250 : currentLine->tokenpos = currentLine->nextpos;
663 : 562565661 : }
664 : :
665 : : /*
666 : : * initLine - initializes a currentLine
667 : : */
668 : :
669 : 15927 : static void initLine (void)
670 : : {
671 : 15927 : currentLine = (struct lineInfo *)xmalloc (sizeof(struct lineInfo));
672 : :
673 : 15927 : if (currentLine == NULL)
674 : : perror("xmalloc");
675 : 15927 : currentLine->linebuf = NULL;
676 : 15927 : currentLine->linelen = 0;
677 : 15927 : currentLine->tokenpos = 0;
678 : 15927 : currentLine->toklen = 0;
679 : 15927 : currentLine->nextpos = 0;
680 : 15927 : currentLine->lineno = lineno;
681 : 15927 : currentLine->column = FIRST_COLUMN;
682 : 15927 : currentLine->inuse = true;
683 : 15927 : currentLine->next = NULL;
684 : 15927 : }
685 : :
686 : : /*
687 : : * pushLine - pushes a new line structure.
688 : : */
689 : :
690 : 3223963 : static void pushLine (void)
691 : : {
692 : 3223963 : if (currentLine == NULL)
693 : 15927 : initLine();
694 : 3208036 : else if (currentLine->inuse) {
695 : 152834 : struct lineInfo *l = (struct lineInfo *)xmalloc (sizeof(struct lineInfo));
696 : :
697 : 152834 : if (currentLine->linebuf == NULL) {
698 : 15391 : l->linebuf = NULL;
699 : 15391 : l->linelen = 0;
700 : : } else {
701 : 137443 : l->linebuf = (char *)xstrdup (currentLine->linebuf);
702 : 137443 : l->linelen = strlen (l->linebuf)+1;
703 : : }
704 : 152834 : l->tokenpos = currentLine->tokenpos;
705 : 152834 : l->toklen = currentLine->toklen;
706 : 152834 : l->nextpos = currentLine->nextpos;
707 : 152834 : l->lineno = currentLine->lineno;
708 : 152834 : l->column = currentLine->column;
709 : 152834 : l->next = currentLine;
710 : 152834 : currentLine = l;
711 : : }
712 : 3223963 : currentLine->inuse = true;
713 : 3223963 : }
714 : :
715 : : /*
716 : : * popLine - pops a line structure.
717 : : */
718 : :
719 : 136919 : static void popLine (void)
720 : : {
721 : 136919 : if (currentLine != NULL) {
722 : 136919 : struct lineInfo *l = currentLine;
723 : :
724 : 136919 : if (currentLine->linebuf != NULL)
725 : 136919 : free(currentLine->linebuf);
726 : 136919 : currentLine = l->next;
727 : 136919 : free(l);
728 : : }
729 : 136919 : }
730 : :
731 : : /*
732 : : * resetpos - resets the position of the next token to the start of the line.
733 : : */
734 : :
735 : 208927 : static void resetpos (void)
736 : : {
737 : 6 : if (currentLine != NULL)
738 : 208927 : currentLine->nextpos = 0;
739 : 0 : }
740 : :
741 : : /*
742 : : * finishedLine - indicates that the current line does not need to be
743 : : * preserved when a pushLine occurs.
744 : : */
745 : :
746 : 3071117 : static void finishedLine (void)
747 : : {
748 : 15903 : currentLine->inuse = false;
749 : 3055214 : }
750 : :
751 : : /*
752 : : * m2flex_GetToken - returns a new token.
753 : : */
754 : :
755 : 113311366 : EXTERN char *m2flex_GetToken (void)
756 : : {
757 : 113311366 : TIMEVAR_PUSH_LEX;
758 : 113311366 : if (currentLine == NULL)
759 : 0 : initLine();
760 : 113311366 : currentLine->tokenpos = currentLine->nextpos;
761 : 113311366 : yylex();
762 : 113311366 : TIMEVAR_POP_LEX;
763 : 113311366 : return yytext;
764 : : }
765 : :
766 : : /*
767 : : * CloseSource - provided for semantic sugar
768 : : */
769 : :
770 : 0 : EXTERN void m2flex_CloseSource (void)
771 : : {
772 : 0 : END_FILE ();
773 : 0 : }
774 : :
775 : : /*
776 : : * OpenSource - returns true if file s can be opened and
777 : : * all tokens are taken from this file.
778 : : */
779 : :
780 : 208922 : EXTERN bool m2flex_OpenSource (char *s)
781 : : {
782 : 208922 : FILE *f = fopen(s, "r");
783 : :
784 : 208922 : if (f == NULL)
785 : : return( false );
786 : : else {
787 : 208921 : isDefinitionModule = false;
788 : 283659 : while (currentFunction != NULL)
789 : : {
790 : 74738 : struct functionInfo *f = currentFunction;
791 : 74738 : currentFunction = f->next;
792 : 74738 : if (f->name != NULL)
793 : 74738 : free(f->name);
794 : 74738 : free(f);
795 : : }
796 : 208921 : yy_delete_buffer (YY_CURRENT_BUFFER);
797 : 208921 : yy_switch_to_buffer (yy_create_buffer(f, YY_BUF_SIZE));
798 : 208921 : filename = xstrdup (s);
799 : 208921 : lineno = 1;
800 : 208921 : if (currentLine == NULL)
801 : 15927 : pushLine ();
802 : : else
803 : 192994 : currentLine->lineno = lineno;
804 : 208921 : START_FILE (filename, lineno);
805 : 208921 : BEGIN INITIAL; resetpos ();
806 : 208921 : return true;
807 : : }
808 : : }
809 : :
810 : : /*
811 : : * m2flex_GetLineNo - returns the current line number.
812 : : */
813 : :
814 : 113548023 : EXTERN int m2flex_GetLineNo (void)
815 : : {
816 : 113548023 : if (currentLine == NULL)
817 : : return 0;
818 : : else
819 : 113548023 : return currentLine->lineno;
820 : : }
821 : :
822 : : /*
823 : : * m2flex_GetColumnNo - returns the column where the current
824 : : * token starts.
825 : : */
826 : :
827 : 113601527 : EXTERN int m2flex_GetColumnNo (void)
828 : : {
829 : 113601527 : if (currentLine == NULL)
830 : : return FIRST_COLUMN;
831 : : else
832 : 113601527 : return currentLine->column;
833 : : }
834 : :
835 : : /*
836 : : * m2flex_GetLocation - returns the gcc location_t of the current token.
837 : : */
838 : :
839 : 113311366 : EXTERN location_t m2flex_GetLocation (void)
840 : : {
841 : 113311366 : if (currentLine == NULL)
842 : : return 0;
843 : : else
844 : 113311366 : return currentLine->location;
845 : : }
846 : :
847 : : /*
848 : : * GetTotalLines - returns the total number of lines parsed.
849 : : */
850 : :
851 : 0 : EXTERN int m2flex_GetTotalLines (void)
852 : : {
853 : 0 : return totalLines;
854 : : }
855 : :
856 : : /*
857 : : * yywrap is called when end of file is seen. We push an eof token
858 : : * and tell the lexical analysis to stop.
859 : : */
860 : :
861 : 193000 : int yywrap (void)
862 : : {
863 : 193000 : updatepos(); M2LexBuf_AddTok(M2Reserved_eoftok); return 1;
864 : : }
865 : :
866 : 0 : EXTERN void _M2_m2flex_init (void) {}
867 : 0 : EXTERN void _M2_m2flex_fini (void) {}
|
