mdtools/BASS_parse/BASS.l


/* define some search patterns */

digit                   [0-9]
letter                  [A-Za-z]
natural                 {digit}+
signedNat               ("+"|"-")?{natural}
number                  {signedNat}("."{natural})?([Ee]{signedNat})?
identifier              ("_"|{letter})({letter}|{digit}|"-"|"_")*

/* define start states */

%x PRE_P
%x INCL
%x DEF
%x IFDEF
%x IFNDEF
%x ESCAPE
%x CHECK_ESCAPE

/* what to put at the top of the lex code */

%{
#include <stdio.h>
#include <string.h>
#include "BASS_parse.h"
#include "../headers/simError.h"
#ifdef IS_MPI
#define __is_lex__
#include "../headers/mpiBASS.h"
#endif

typedef unsigned short int r_short;

extern void change_in_file( FILE* in_file );

// the following is used by the include start state

#define MAX_BUFFER_DEPTH 10
YY_BUFFER_STATE buffer_stack[MAX_BUFFER_DEPTH]; // a stack of the include buffers
int buffer_stack_ptr = 0;
struct filename_list{
  char my_name[300];
  struct filename_list* next;
};
struct filename_list* yyfile_name;
struct filename_list* temp_yyfile_name;
int yylineno_stack[MAX_BUFFER_DEPTH];


// the following is a check against the define buffer length

void check_def_buff( char* defined, int index );

//these are used by the ifdef and ifndef statements

int escape_stack_ptr = 0; //keeps track of the escape stack


%}

%option yylineno

%%

{signedNat}                     {
                                  yylval.i_val = atoi( yytext );
                                  return INTEGER;
                                }

{number}                        {
                                  yylval.d_val = atof( yytext );
                                  return DOUBLE;
                                }

{identifier}                    {
                                  int token;
                                  token = res_word( yytext );
                                  
                                  if( token == DEFINED ){
                                  
                                    if( buffer_stack_ptr >= MAX_BUFFER_DEPTH ){
                                      fprintf( stderr,
                                               "Maximum buffer depth exceeded for %s.\n",
                                               yytext );
                                      exit(1);
                                    }
                                    
                                    buffer_stack[buffer_stack_ptr] = YY_CURRENT_BUFFER;
                                    buffer_stack_ptr++;

                                    yy_scan_string( get_definition( yytext ) );
                                  }
                                  else if( token ){
                                    return token;
                                  }
                                  else{
                                    yylval.s_ptr = strdup( yytext );
                                    return IDENTIFIER;
                                  }
                                }

\".*\"                          {
                                  /* little routine to strip off the quotes */
                                  
                                  u_short i;
                                  i = 0; // index
                                  while( yytext[i+1] != '\"' ){

                                    yytext[i] = yytext[i+1];
                                    i++;
                                  }
                                  yytext[i] = '\0';
                                  yylval.s_ptr = strdup( yytext );
                                  return QUOTED_STRING;
                                }

\[{natural}\]                   {
                                  int index;
                                  sscanf(yytext, "[%d]", &index);
                                  yylval.i_val = index;
                                  return ARRAY_INDEX;
                                }

[ \t\n]+                        /* ignore whitespace */;

"/*"                            {
                                  /* ignore comments */
                                  u_short done;
                                  char c;

                                  done = 0;
                                  while( !done ){
                                    
                                    c = input();
                                    while( c != '*' ){
                                      
                                      c = input();
                                    }
                                    while( c == '*' ){
                                      
                                      c = input();
                                    }
                                    if( c == '/' ) done = 1;
                                  }
                                }

"//".*\n                        /* ignore comments */;

"#"                             BEGIN(PRE_P);

.                               {
                                  // pass everything else to yacc
                                  return yytext[0];
                                }

<PRE_P>"include"                BEGIN(INCL);
<PRE_P>"define"                 BEGIN(DEF);
<PRE_P>"ifdef"                  BEGIN(IFDEF);
<PRE_P>"ifndef"                 BEGIN(IFNDEF);
<PRE_P>"endif"                  /* do nothing */;
<PRE_P>\n                       BEGIN(INITIAL);

<INCL>[ \t]*                    /* eat white space */
<INCL>\".*\"                    {
                                  char foo_name[300];
                                  
                                  // little routine to strip off the quotes 

                                  u_short i;
                                  i = 0; // index
                                  while( yytext[i+1] != '\"' ){

                                    yytext[i] = yytext[i+1];
                                    i++;
                                  }
                                  
                                  yytext[i] = '\0';
                                  strcpy( foo_name, yytext );

                                  // now we have the include file name
                                  
                                  if( buffer_stack_ptr >= MAX_BUFFER_DEPTH ){
                                    
                                    fprintf( stderr, "Includes nested too deeply\n" );
                                    exit(1);
                                  }

                                  buffer_stack[buffer_stack_ptr] = YY_CURRENT_BUFFER;
                                  yylineno_stack[buffer_stack_ptr] = yylineno;
                                  buffer_stack_ptr++;

                                  yyin = fopen( yytext, "r" );
                                  if( yyin == NULL ){
                                    fprintf( stderr, "Unable to include file %s\n", yytext );
                                    exit(1);
                                  }

                                  yy_switch_to_buffer( yy_create_buffer( yyin, YY_BUF_SIZE ) );
                                  yylineno = 0;
                                  
                                  temp_yyfile_name = (struct filename_list* )malloc( sizeof( struct filename_list ) );
                                  temp_yyfile_name->next = yyfile_name;
                                  yyfile_name = temp_yyfile_name;
                                  strcpy( yyfile_name->my_name, foo_name );


                                  BEGIN(INITIAL);
                                }
<INCL>\n                        BEGIN(INITIAL);
<INCL>.                         /* ignore everything else */

<DEF>[ \t]*                     /* eat white space */;
<DEF>{identifier}               {
                                  char c;
                                  char definition[ DEFINED_BUFFER_SIZE ];
                                  short int done;
                                  short int c_done; // a done marker for the comments
                                  int def_ptr;
                                  
                                  // initialize the definition buffer

                                  for( def_ptr = 0; def_ptr < DEFINED_BUFFER_SIZE; def_ptr++ ){
                                    definition[def_ptr] = '\0';
                                  }
                                  
                                  def_ptr =0;
                                  done = 0;
                                  c_done = 0;
                                 
                                  while( !done ){
                                    
                                    c = input();
                                    if( c == '\"' ){
                                    
                                      // shove the whole quoted string into the macro
                                    
                                      definition[def_ptr] = c;
                                      //fprintf( stderr, "%c", c );
                                      def_ptr++;
                                      check_def_buff( yytext, def_ptr );
                                      
                                      c = input();
                                      while( c != '\"' ){
                                      
                                        definition[def_ptr] = c;
                                        //fprintf( stderr, "%c", c );
                                        def_ptr++;
                                        check_def_buff( yytext, def_ptr );

                                        c = input();
                                      }
                                      definition[def_ptr] = c;
                                      //fprintf( stderr, "%c", c );
                                      def_ptr++;
                                      check_def_buff( yytext, def_ptr );
                                      c = input();
                                    }
                                    
                                    // handle comments

                                    if( c == '/' ){
                                      c = input();
                                      switch( c ){

                                        case '/':
                                          while( c != '\n' && c != '\\' ){
                                            c = input();
                                          }
                                          break;
                                        
                                        case '*':
                                          c_done = 0;
                                          while( !c_done ){
                                            c = input();
                                            while( c != '*' ){
                                              c = input();
                                            }
                                            while( c == '*' ){
                                              c = input();
                                            }
                                            if( c == '/' ) c_done = 1;
                                          }
                                          c = input();
                                          break;

                                        default:
                                          // the '/' char was a normal symbol
                                          definition[def_ptr] = '/';
                                          //fprintf( stderr, "%c", c );
                                          def_ptr++;
                                          check_def_buff( yytext, def_ptr );
                                          break;
                                      }
                                    }
                                        
                                    
                                    if( c == '\n' ){
                                      done = 1;
                                    }
                                    
                                    else{
                                      
                                      // check for the line wrap character '\'
                                      
                                      if( c == '\\' ){
                                        
                                        // skip the rest of the line until the line return

                                        c = input();
                                        while( c != '\n' ){
                                          c = input();
                                        }
                                      }

                                      else{
                                        
                                        // we now know the character is a good one 

                                        definition[def_ptr] = c;
                                        //fprintf( stderr, "%c", c );
                                        def_ptr++;
                                        check_def_buff( yytext, def_ptr );
                                      }
                                    }
                                  }  
                                  
                                  insert_define( yytext, definition );
                                  BEGIN(INITIAL);
                                }
<DEF>\n                         BEGIN(INITIAL);
<DEF>.                          /* ignore everything else */;

<IFDEF>[ \t]*                   /* eat white space */;
<IFDEF>{identifier}             {
                                  if( !is_defined( yytext ) ){
                                    escape_stack_ptr++;
                                    BEGIN(ESCAPE);
                                  }
                                }
<IFDEF>\n                       BEGIN(INITIAL);
<IFDEF>.                        /* ignore everything else */;

<IFNDEF>[ \t]*                  /* eat the white space */;
<IFNDEF>{identifier}            {
                                  if( is_defined( yytext ) ){
                                    escape_stack_ptr++;
                                    BEGIN(ESCAPE);
                                  }
                                }
<IFNDEF>\n                      BEGIN(INITIAL);
<IFNDEF>.                       /* ignore everything else */;

<ESCAPE>\".*\"                  /* do nothing */;
<ESCAPE>"//".*\n                /* ignore comments */;
<ESCAPE>"/*"                    {
                                  /* ignore comments */
                                  u_short done;
                                  char c;

                                  done = 0;
                                  while( !done ){

                                    c = input();
                                    while( c != '*' ){
                                    
                                      c = input();
                                    }
                                    
                                    while( c == '*' ){
                                    
                                      c = input();
                                    }
                                    
                                    if( c == '/' ) done = 1;
                                  }
                                }
<ESCAPE>"#"                     BEGIN(CHECK_ESCAPE);
<ESCAPE>.                       /* ignore everything else */;

<CHECK_ESCAPE>[ \t]             /* ignore whitespace */;
<CHECK_ESCAPE>"ifdef"           { escape_stack_ptr++; BEGIN(ESCAPE); }
<CHECK_ESCAPE>"ifndef"          { escape_stack_ptr++; BEGIN(ESCAPE); }
<CHECK_ESCAPE>"endif"           {
                                  escape_stack_ptr--;
                                  if( escape_stack_ptr <= 0){
                                    escape_stack_ptr = 0; // just in case something flubbed 
                                    BEGIN(INITIAL);
                                  }
                                }
<CHECK_ESCAPE>\n                BEGIN(ESCAPE);
<CHECK_ESCAPE>.                 /* ignore everything else */;

<<EOF>>                         {
                                  buffer_stack_ptr--;
                                  if( buffer_stack_ptr < 0 ){
                                    
                                    yyterminate();
                                  }
                                  
                                  else{
                                  
                                    yy_delete_buffer( YY_CURRENT_BUFFER );
                                    yy_switch_to_buffer( buffer_stack[buffer_stack_ptr] );
                                    yylineno = yylineno_stack[buffer_stack_ptr];

                                    temp_yyfile_name = yyfile_name;
                                    yyfile_name = temp_yyfile_name->next;
                                    free( temp_yyfile_name );
                                  }
                                }
                                
%%

void check_def_buff( char* defined, int index ){
  
  if( index >= DEFINED_BUFFER_SIZE ){
    
    sprintf( painCave.errMsg, "Define buffer size exceeded for %s\n", defined );
    painCave.isFatal = 1;
    simError();
  }
}

int yywrap(void){
  return 1;
}

void change_in_file( FILE* in_file ){

  yyin = in_file;
}
Revision:	157
Committed:	Tue Oct 29 21:48:25 2002 UTC (21 years, 8 months ago) by mmeineke
File size:	9224 byte(s)
Log Message:	adding in simError
#	User	Rev	Content
1	mmeineke	10
2			/* define some search patterns */
3
4			digit [0-9]
5			letter [A-Za-z]
6			natural {digit}+
7			signedNat ("+"\|"-")?{natural}
8			number {signedNat}("."{natural})?([Ee]{signedNat})?
9			identifier ("_"\|{letter})({letter}\|{digit}\|"-"\|"_")*
10
11			/* define start states */
12
13			%x PRE_P
14			%x INCL
15			%x DEF
16			%x IFDEF
17			%x IFNDEF
18			%x ESCAPE
19			%x CHECK_ESCAPE
20
21			/* what to put at the top of the lex code */
22
23			%{
24			#include <stdio.h>
25			#include <string.h>
26			#include "BASS_parse.h"
27	mmeineke	157	#include "../headers/simError.h"
28	chuckv	131	#ifdef IS_MPI
29			#define __is_lex__
30	chuckv	138	#include "../headers/mpiBASS.h"
31	chuckv	118	#endif
32	mmeineke	10
33			typedef unsigned short int r_short;
34
35			extern void change_in_file( FILE* in_file );
36
37			// the following is used by the include start state
38
39			#define MAX_BUFFER_DEPTH 10
40			YY_BUFFER_STATE buffer_stack[MAX_BUFFER_DEPTH]; // a stack of the include buffers
41			int buffer_stack_ptr = 0;
42			struct filename_list{
43			char my_name[300];
44			struct filename_list* next;
45			};
46			struct filename_list* yyfile_name;
47			struct filename_list* temp_yyfile_name;
48			int yylineno_stack[MAX_BUFFER_DEPTH];
49
50
51			// the following is a check against the define buffer length
52
53			void check_def_buff( char* defined, int index );
54
55			//these are used by the ifdef and ifndef statements
56
57			int escape_stack_ptr = 0; //keeps track of the escape stack
58
59
60			%}
61
62			%option yylineno
63
64			%%
65
66			{signedNat} {
67			yylval.i_val = atoi( yytext );
68			return INTEGER;
69			}
70
71			{number} {
72			yylval.d_val = atof( yytext );
73			return DOUBLE;
74			}
75
76			{identifier} {
77			int token;
78			token = res_word( yytext );
79
80			if( token == DEFINED ){
81
82			if( buffer_stack_ptr >= MAX_BUFFER_DEPTH ){
83			fprintf( stderr,
84			"Maximum buffer depth exceeded for %s.\n",
85			yytext );
86			exit(1);
87			}
88
89			buffer_stack[buffer_stack_ptr] = YY_CURRENT_BUFFER;
90			buffer_stack_ptr++;
91
92			yy_scan_string( get_definition( yytext ) );
93			}
94			else if( token ){
95			return token;
96			}
97			else{
98			yylval.s_ptr = strdup( yytext );
99			return IDENTIFIER;
100			}
101			}
102
103			\".*\" {
104			/* little routine to strip off the quotes */
105
106			u_short i;
107			i = 0; // index
108			while( yytext[i+1] != '\"' ){
109
110			yytext[i] = yytext[i+1];
111			i++;
112			}
113			yytext[i] = '\0';
114			yylval.s_ptr = strdup( yytext );
115			return QUOTED_STRING;
116			}
117
118			\[{natural}\] {
119			int index;
120			sscanf(yytext, "[%d]", &index);
121			yylval.i_val = index;
122			return ARRAY_INDEX;
123			}
124
125			[ \t\n]+ /* ignore whitespace */;
126
127			"/*" {
128			/* ignore comments */
129			u_short done;
130			char c;
131
132			done = 0;
133			while( !done ){
134
135			c = input();
136			while( c != '*' ){
137
138			c = input();
139			}
140			while( c == '*' ){
141
142			c = input();
143			}
144			if( c == '/' ) done = 1;
145			}
146			}
147
148			"//".\n / ignore comments */;
149
150			"#" BEGIN(PRE_P);
151
152			. {
153			// pass everything else to yacc
154			return yytext[0];
155			}
156
157			<PRE_P>"include" BEGIN(INCL);
158			<PRE_P>"define" BEGIN(DEF);
159			<PRE_P>"ifdef" BEGIN(IFDEF);
160			<PRE_P>"ifndef" BEGIN(IFNDEF);
161			<PRE_P>"endif" /* do nothing */;
162			<PRE_P>\n BEGIN(INITIAL);
163
164			<INCL>[ \t]* /* eat white space */
165			<INCL>\".*\" {
166			char foo_name[300];
167
168			// little routine to strip off the quotes
169
170			u_short i;
171			i = 0; // index
172			while( yytext[i+1] != '\"' ){
173
174			yytext[i] = yytext[i+1];
175			i++;
176			}
177
178			yytext[i] = '\0';
179			strcpy( foo_name, yytext );
180
181			// now we have the include file name
182
183			if( buffer_stack_ptr >= MAX_BUFFER_DEPTH ){
184
185			fprintf( stderr, "Includes nested too deeply\n" );
186			exit(1);
187			}
188
189			buffer_stack[buffer_stack_ptr] = YY_CURRENT_BUFFER;
190			yylineno_stack[buffer_stack_ptr] = yylineno;
191			buffer_stack_ptr++;
192
193			yyin = fopen( yytext, "r" );
194			if( yyin == NULL ){
195			fprintf( stderr, "Unable to include file %s\n", yytext );
196			exit(1);
197			}
198
199			yy_switch_to_buffer( yy_create_buffer( yyin, YY_BUF_SIZE ) );
200			yylineno = 0;
201
202			temp_yyfile_name = (struct filename_list* )malloc( sizeof( struct filename_list ) );
203			temp_yyfile_name->next = yyfile_name;
204			yyfile_name = temp_yyfile_name;
205			strcpy( yyfile_name->my_name, foo_name );
206
207
208			BEGIN(INITIAL);
209			}
210			<INCL>\n BEGIN(INITIAL);
211			<INCL>. /* ignore everything else */
212
213			<DEF>[ \t]* /* eat white space */;
214			<DEF>{identifier} {
215			char c;
216			char definition[ DEFINED_BUFFER_SIZE ];
217			short int done;
218			short int c_done; // a done marker for the comments
219			int def_ptr;
220
221			// initialize the definition buffer
222
223			for( def_ptr = 0; def_ptr < DEFINED_BUFFER_SIZE; def_ptr++ ){
224			definition[def_ptr] = '\0';
225			}
226
227			def_ptr =0;
228			done = 0;
229			c_done = 0;
230
231			while( !done ){
232
233			c = input();
234			if( c == '\"' ){
235
236			// shove the whole quoted string into the macro
237
238			definition[def_ptr] = c;
239	mmeineke	157	//fprintf( stderr, "%c", c );
240	mmeineke	10	def_ptr++;
241			check_def_buff( yytext, def_ptr );
242
243			c = input();
244			while( c != '\"' ){
245
246			definition[def_ptr] = c;
247	mmeineke	157	//fprintf( stderr, "%c", c );
248	mmeineke	10	def_ptr++;
249			check_def_buff( yytext, def_ptr );
250
251			c = input();
252			}
253			definition[def_ptr] = c;
254	mmeineke	157	//fprintf( stderr, "%c", c );
255	mmeineke	10	def_ptr++;
256			check_def_buff( yytext, def_ptr );
257			c = input();
258			}
259
260			// handle comments
261
262			if( c == '/' ){
263			c = input();
264			switch( c ){
265
266			case '/':
267			while( c != '\n' && c != '\\' ){
268			c = input();
269			}
270			break;
271
272			case '*':
273			c_done = 0;
274			while( !c_done ){
275			c = input();
276			while( c != '*' ){
277			c = input();
278			}
279			while( c == '*' ){
280			c = input();
281			}
282			if( c == '/' ) c_done = 1;
283			}
284			c = input();
285			break;
286
287			default:
288			// the '/' char was a normal symbol
289			definition[def_ptr] = '/';
290	mmeineke	157	//fprintf( stderr, "%c", c );
291	mmeineke	10	def_ptr++;
292			check_def_buff( yytext, def_ptr );
293			break;
294			}
295			}
296
297
298			if( c == '\n' ){
299			done = 1;
300			}
301
302			else{
303
304			// check for the line wrap character '\'
305
306			if( c == '\\' ){
307
308			// skip the rest of the line until the line return
309
310			c = input();
311			while( c != '\n' ){
312			c = input();
313			}
314			}
315
316			else{
317
318			// we now know the character is a good one
319
320			definition[def_ptr] = c;
321	mmeineke	157	//fprintf( stderr, "%c", c );
322	mmeineke	10	def_ptr++;
323			check_def_buff( yytext, def_ptr );
324			}
325			}
326			}
327
328			insert_define( yytext, definition );
329			BEGIN(INITIAL);
330			}
331			<DEF>\n BEGIN(INITIAL);
332			<DEF>. /* ignore everything else */;
333
334			<IFDEF>[ \t]* /* eat white space */;
335			<IFDEF>{identifier} {
336			if( !is_defined( yytext ) ){
337			escape_stack_ptr++;
338			BEGIN(ESCAPE);
339			}
340			}
341			<IFDEF>\n BEGIN(INITIAL);
342			<IFDEF>. /* ignore everything else */;
343
344			<IFNDEF>[ \t]* /* eat the white space */;
345			<IFNDEF>{identifier} {
346			if( is_defined( yytext ) ){
347			escape_stack_ptr++;
348			BEGIN(ESCAPE);
349			}
350			}
351			<IFNDEF>\n BEGIN(INITIAL);
352			<IFNDEF>. /* ignore everything else */;
353
354			<ESCAPE>\".\" / do nothing */;
355			<ESCAPE>"//".\n / ignore comments */;
356			<ESCAPE>"/*" {
357			/* ignore comments */
358			u_short done;
359			char c;
360
361			done = 0;
362			while( !done ){
363
364			c = input();
365			while( c != '*' ){
366
367			c = input();
368			}
369
370			while( c == '*' ){
371
372			c = input();
373			}
374
375			if( c == '/' ) done = 1;
376			}
377			}
378			<ESCAPE>"#" BEGIN(CHECK_ESCAPE);
379			<ESCAPE>. /* ignore everything else */;
380
381			<CHECK_ESCAPE>[ \t] /* ignore whitespace */;
382			<CHECK_ESCAPE>"ifdef" { escape_stack_ptr++; BEGIN(ESCAPE); }
383			<CHECK_ESCAPE>"ifndef" { escape_stack_ptr++; BEGIN(ESCAPE); }
384			<CHECK_ESCAPE>"endif" {
385			escape_stack_ptr--;
386			if( escape_stack_ptr <= 0){
387			escape_stack_ptr = 0; // just in case something flubbed
388			BEGIN(INITIAL);
389			}
390			}
391			<CHECK_ESCAPE>\n BEGIN(ESCAPE);
392			<CHECK_ESCAPE>. /* ignore everything else */;
393
394			<<EOF>> {
395			buffer_stack_ptr--;
396			if( buffer_stack_ptr < 0 ){
397
398			yyterminate();
399			}
400
401			else{
402
403			yy_delete_buffer( YY_CURRENT_BUFFER );
404			yy_switch_to_buffer( buffer_stack[buffer_stack_ptr] );
405			yylineno = yylineno_stack[buffer_stack_ptr];
406
407			temp_yyfile_name = yyfile_name;
408			yyfile_name = temp_yyfile_name->next;
409			free( temp_yyfile_name );
410			}
411			}
412
413			%%
414
415			void check_def_buff( char* defined, int index ){
416
417			if( index >= DEFINED_BUFFER_SIZE ){
418
419	mmeineke	157	sprintf( painCave.errMsg, "Define buffer size exceeded for %s\n", defined );
420			painCave.isFatal = 1;
421			simError();
422	mmeineke	10	}
423			}
424
425			int yywrap(void){
426			return 1;
427			}
428
429			void change_in_file( FILE* in_file ){
430
431			yyin = in_file;
432			}