]> git.saurik.com Git - wxWidgets.git/blob - src/os2/y_tab.i
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't use \u escapes, VC6 doesn't understand them
[wxWidgets.git] / src / os2 / y_tab.i
1 static char yysccsid[] = "@(#)yaccpar 1.7 (Berkeley) 09/09/90";
2 #line 2 "parser.y"
3 #pragma info( none )
4 #pragma info( none )
5 #pragma info( restore )
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 typedef unsigned int size_t;
22
23
24 char * _Builtin __strcat( char *, const char * );
25 char * _Builtin __strchr( const char *, int );
26 int _Builtin __strcmp( const char *, const char * );
27 char * _Builtin __strcpy( char*, const char * );
28 size_t _Builtin __strlen( const char * );
29 char * _Builtin __strncat( char *, const char *, size_t );
30 int _Builtin __strncmp( const char *, const char *, size_t );
31 char * _Builtin __strncpy( char *, const char *, size_t );
32 char * _Builtin __strrchr( const char *, int );
33
34 int _Import _Optlink strcoll( const char *, const char * );
35 size_t _Import _Optlink strcspn( const char *, const char * );
36 char * _Import _Optlink strerror( int );
37 char * _Import _Optlink strpbrk( const char *, const char * );
38 size_t _Import _Optlink strspn( const char *, const char * );
39 char * _Import _Optlink strstr( const char *, const char * );
40 char * _Import _Optlink strtok( char*, const char * );
41 size_t _Import _Optlink strxfrm( char *, const char *, size_t );
42
43 char * _Import _Optlink strcat( char *, const char * );
44 char * _Import _Optlink strchr( const char *, int );
45 int _Import _Optlink strcmp( const char *, const char * );
46 char * _Import _Optlink strcpy( char *, const char * );
47 size_t _Import _Optlink strlen( const char * );
48 char * _Import _Optlink strncat( char *, const char *, size_t );
49 int _Import _Optlink strncmp( const char *, const char *, size_t );
50 char * _Import _Optlink strncpy( char *, const char *, size_t );
51 char * _Import _Optlink strrchr( const char *, int );
52
53 #pragma info( none )
54 #pragma info( restore )
55
56
57
58 void * _Builtin __memcpy( void *, const void *, size_t );
59 void * _Builtin __memchr( const void *, int, size_t );
60 int _Builtin __memcmp( const void *, const void *, size_t );
61 void * _Builtin __memset( void *, int, size_t );
62 void * _Builtin __memmove( void *, const void *, size_t );
63
64 void * _Import _Optlink memcpy( void *, const void *, size_t );
65 void * _Import _Optlink memchr( const void *, int, size_t );
66 int _Import _Optlink memcmp( const void *, const void *, size_t );
67 void * _Import _Optlink memset( void *, int, size_t );
68 void * _Import _Optlink memmove( void *, const void *, size_t );
69
70 #pragma info( none )
71 #pragma info( restore )
72
73
74
75 void * _Import _Optlink memccpy( void *, void *, int, unsigned int );
76 int _Import _Optlink memicmp( void *, void *, unsigned int );
77
78
79
80
81
82 char * _Import _Optlink strdup( const char * );
83 int _Import _Optlink stricmp( const char *, const char * );
84 char * _Import _Optlink strlwr( char * );
85 int _Import _Optlink strnicmp( const char *, const char *, size_t );
86 char * _Import _Optlink strupr( char * );
87
88 int _Import _Optlink strcmpi( const char *, const char * );
89 char * _Import _Optlink strrev( char * );
90 char * _Import _Optlink strset( char *, int );
91 char * _Import _Optlink strnset( char *, int, size_t );
92 char * _Import _Optlink _strerror( char * );
93
94
95 size_t _Import _Optlink _fstrcspn( const char *, const char * );
96 char * _Import _Optlink _fstrdup( const char * );
97 char * _Import _Optlink _nstrdup( const char * );
98 int _Import _Optlink _fstricmp( const char *, const char * );
99 char * _Import _Optlink _fstrlwr( char * );
100 int _Import _Optlink _fstrnicmp( const char *, const char *, size_t );
101 char * _Import _Optlink _fstrnset( char *, int, size_t );
102 char * _Import _Optlink _fstrpbrk( const char *, const char * );
103 char * _Import _Optlink _fstrrev( char * );
104 char * _Import _Optlink _fstrset( char *, int );
105 size_t _Import _Optlink _fstrspn( const char *, const char * );
106 char * _Import _Optlink _fstrstr( const char *, const char * );
107 char * _Import _Optlink _fstrtok( char*, const char * );
108 char * _Import _Optlink _fstrupr( char * );
109
110 #pragma map( _fstrcspn , "strcspn" )
111 #pragma map( _fstrdup , "strdup" )
112 #pragma map( _nstrdup , "strdup" )
113 #pragma map( _fstricmp , "stricmp" )
114 #pragma map( _fstrlwr , "strlwr" )
115 #pragma map( _fstrnicmp, "strnicmp" )
116 #pragma map( _fstrnset , "strnset" )
117 #pragma map( _fstrpbrk , "strpbrk" )
118 #pragma map( _fstrrev , "strrev" )
119 #pragma map( _fstrset , "strset" )
120 #pragma map( _fstrspn , "strspn" )
121 #pragma map( _fstrstr , "strstr" )
122 #pragma map( _fstrtok , "strtok" )
123 #pragma map( _fstrupr , "strupr" )
124
125
126
127
128 #pragma info( none )
129 #pragma info( restore )
130 #pragma info( restore )
131 #pragma info( none )
132 #pragma info( none )
133 #pragma info( restore )
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150 int _Import _Optlink _access( const char *, int );
151 int _Import _Optlink _chmod( const char *, int );
152 int _Import _Optlink _chsize( int, long );
153 int _Import _Optlink _close( int );
154 int _Import _Optlink _creat( const char *, int );
155 int _Import _Optlink _dup( int );
156 int _Import _Optlink _dup2( int, int );
157 int _Import _Optlink __eof( int );
158 long _Import _Optlink _filelength( int );
159 int _Import _Optlink _isatty( int );
160 long _Import _Optlink _lseek( int, long, int );
161 int _Import _Optlink _open( const char *, int, ... );
162 int _Import _Optlink _read( int, void *, unsigned int );
163 int _Import _Optlink remove( const char * );
164 int _Import _Optlink rename( const char *, const char * );
165 int _Import _Optlink _sopen( const char *, int, int, ... );
166 long _Import _Optlink _tell( int );
167 int _Import _Optlink _umask( int );
168 int _Import _Optlink _unlink( const char * );
169 int _Import _Optlink _write( int, const void *, unsigned int );
170 int _Import _Optlink _setmode(int handle, int mode);
171
172 int _Import _Optlink access( const char *, int );
173 int _Import _Optlink chmod( const char *, int );
174 int _Import _Optlink chsize( int, long );
175 int _Import _Optlink close( int );
176 int _Import _Optlink creat( const char *, int );
177 int _Import _Optlink dup( int );
178 int _Import _Optlink dup2( int, int );
179 int _Import _Optlink eof( int );
180 long _Import _Optlink filelength( int );
181 int _Import _Optlink isatty( int );
182 long _Import _Optlink lseek( int, long, int );
183 int _Import _Optlink open( const char *, int, ... );
184 int _Import _Optlink read( int, void *, unsigned int );
185 int _Import _Optlink sopen( const char *, int, int, ... );
186 long _Import _Optlink tell( int );
187 int _Import _Optlink umask( int );
188 int _Import _Optlink unlink( const char * );
189 int _Import _Optlink write( int, const void *, unsigned int );
190 int _Import _Optlink setmode(int handle, int mode);
191
192 #pragma map( access , "_access" )
193 #pragma map( chmod , "_chmod" )
194 #pragma map( chsize , "_chsize" )
195 #pragma map( close , "_close" )
196 #pragma map( creat , "_creat" )
197 #pragma map( dup , "_dup" )
198 #pragma map( dup2 , "_dup2" )
199 #pragma map( eof , "__eof" )
200 #pragma map( filelength, "_filelength" )
201 #pragma map( isatty , "_isatty" )
202 #pragma map( lseek , "_lseek" )
203 #pragma map( open , "_open" )
204 #pragma map( read , "_read" )
205 #pragma map( sopen , "_sopen" )
206 #pragma map( tell , "_tell" )
207 #pragma map( umask , "_umask" )
208 #pragma map( unlink , "_unlink" )
209 #pragma map( write , "_write" )
210 #pragma map( setmode , "_setmode" )
211
212
213
214
215 #pragma info( none )
216 #pragma info( restore )
217 #pragma info( restore )
218
219
220
221
222 #pragma info( none )
223 #pragma info( none )
224 #pragma info( restore )
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240 extern const double _infinity;
241
242
243
244 double _Builtin __fabs( double );
245 double _Import _Optlink fabs( double );
246 #pragma info( none )
247 #pragma info( restore )
248
249 double _Import _Optlink atan2( double, double );
250 double _Import _Optlink ceil( double );
251 double _Import _Optlink cosh( double );
252 double _Import _Optlink exp( double );
253 double _Import _Optlink floor( double );
254 double _Import _Optlink fmod( double, double );
255 double _Import _Optlink frexp( double, int * );
256 double _Import _Optlink ldexp( double, int );
257 double _Import _Optlink log( double );
258 double _Import _Optlink log10( double );
259 double _Import _Optlink modf( double, double * );
260 double _Import _Optlink pow( double, double );
261 double _Import _Optlink sinh( double );
262 double _Import _Optlink tanh( double );
263
264 double _Import _Optlink asin( double );
265 double _Import _Optlink acos( double );
266 double _Import _Optlink atan( double );
267 double _Import _Optlink sin( double );
268 double _Import _Optlink cos( double );
269 double _Import _Optlink tan( double );
270 double _Import _Optlink sqrt( double );
271
272 double _Import _Optlink _erf( double );
273 double _Import _Optlink _erfc( double );
274 double _Import _Optlink _gamma( double );
275 double _Import _Optlink _hypot( double, double );
276 double _Import _Optlink _j0( double );
277 double _Import _Optlink _j1( double );
278 double _Import _Optlink _jn( int, double );
279 double _Import _Optlink _y0( double );
280 double _Import _Optlink _y1( double );
281 double _Import _Optlink _yn( int, double );
282 double _Import _Optlink erf( double );
283 double _Import _Optlink erfc( double );
284 double _Import _Optlink gamma( double );
285 double _Import _Optlink hypot( double, double );
286 double _Import _Optlink j0( double );
287 double _Import _Optlink j1( double );
288 double _Import _Optlink jn( int, double );
289 double _Import _Optlink y0( double );
290 double _Import _Optlink y1( double );
291 double _Import _Optlink yn( int, double );
292
293 #pragma map( erf, "_erf" )
294 #pragma map( erfc, "_erfc" )
295 #pragma map( gamma, "_gamma" )
296 #pragma map( hypot, "_hypot" )
297 #pragma map( j0, "_j0" )
298 #pragma map( j1, "_j1" )
299 #pragma map( jn, "_jn" )
300 #pragma map( y0, "_y0" )
301 #pragma map( y1, "_y1" )
302 #pragma map( yn, "_yn" )
303
304 extern const long double _LHUGE_VAL;
305
306
307
308
309
310 struct complex
311 {
312 double x,y;
313 };
314
315 double _Import _Optlink _cabs( struct complex );
316
317 #pragma info( none )
318 #pragma info( restore )
319
320 struct exception
321 {
322 int type;
323 char *name;
324 double arg1;
325 double arg2;
326 double retval;
327 };
328
329
330
331 int _matherr( struct exception * );
332 int matherr( struct exception * );
333
334 #pragma map( matherr, "_matherr" )
335
336 long double _Optlink _atold( const char * );
337
338
339
340
341
342 #pragma info( none )
343 #pragma info( restore )
344 #pragma info( restore )
345
346
347 #pragma info( none )
348 #pragma info( none )
349 #pragma info( restore )
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366 typedef unsigned short wchar_t;
367
368 typedef struct _div_t
369 {
370 int quot;
371 int rem;
372 } div_t;
373
374 typedef struct _ldiv_t
375 {
376 long int quot;
377 long int rem;
378 } ldiv_t;
379
380
381
382 typedef unsigned long _System _EH_RTN(void *,void *,void *,void *);
383
384 extern int _Import _Optlink _eh_del(_EH_RTN *);
385 extern int _Import _Optlink _eh_add(_EH_RTN *);
386 extern int _Import _mb_cur_max;
387
388
389
390 int _Builtin __abs( int );
391 long int _Builtin __labs( long int );
392
393 double _Import _Optlink atof( const char * );
394 int _Import _Optlink atoi( const char * );
395 long int _Import _Optlink atol( const char * );
396 double _Import _Optlink strtod( const char *, char ** );
397 long int _Import _Optlink strtol( const char *, char **, int );
398 unsigned long int _Import _Optlink strtoul( const char *, char **, int );
399 int _Import _Optlink rand( void );
400 void _Import _Optlink srand( unsigned int );
401 void * (_Import _Optlink calloc)( size_t, size_t );
402 void (_Import _Optlink free)( void * );
403 void * (_Import _Optlink malloc)( size_t );
404 void * (_Import _Optlink realloc)( void *, size_t );
405 void _Import _Optlink abort( void );
406 int _Import _Optlink atexit( void ( * )( void ) );
407 void _Import _Optlink exit( int );
408 char * _Import _Optlink getenv( const char * );
409 int _Import _Optlink system( const char * );
410 void * _Import _Optlink bsearch( const void *, const void *, size_t, size_t,
411 int ( * _Optlink __compare )( const void *, const void * ) );
412 void _Import _Optlink qsort( void *, size_t, size_t,
413 int ( * _Optlink __compare )( const void *, const void * ) );
414 div_t _Import _Optlink div( int, int );
415 ldiv_t _Import _Optlink ldiv( long int, long int );
416 int _Import _Optlink mblen( const char *, size_t );
417 int _Import _Optlink mbtowc( wchar_t *, const char *, size_t );
418 int _Import _Optlink wctomb( char *, wchar_t );
419 size_t _Import _Optlink mbstowcs( wchar_t *, const char *, size_t );
420 size_t _Import _Optlink wcstombs( char *, const wchar_t *, size_t );
421
422 int _Import _Optlink abs ( int );
423 long int _Import _Optlink labs( long int );
424
425 #pragma info( none )
426 #pragma info( restore )
427
428
429
430
431 void * _Builtin __alloca( size_t );
432 #pragma info( none )
433 #pragma info( restore )
434
435 unsigned char _Builtin __parmdwords( void );
436
437 long double _Import _Optlink _atold( const char * );
438 char * _Import _Optlink ecvt( double, int, int *, int * );
439 char * _Import _Optlink _ecvt( double, int, int *, int * );
440 char * _Import _Optlink fcvt( double, int, int *, int * );
441 char * _Import _Optlink _fcvt( double, int, int *, int * );
442 int _Import _Optlink _freemod( unsigned long );
443 char * _Import _Optlink _fullpath(char *, char *, size_t);
444 char * _Import _Optlink gcvt( double, int, char * );
445 char * _Import _Optlink _gcvt( double, int, char * );
446 int (_Import _Optlink _heapmin)( void );
447 char * _Import _Optlink itoa( int, char *, int );
448 char * _Import _Optlink _itoa( int, char *, int );
449 int _Import _Optlink _loadmod( char *, unsigned long * );
450 char * _Import _Optlink ltoa( long, char *, int );
451 char * _Import _Optlink _ltoa( long, char *, int );
452 size_t _Import _Optlink _msize(void *);
453 int _Import _Optlink putenv( const char * );
454 int _Import _Optlink _putenv( const char * );
455 long double _Import _Optlink strtold( const char *, char ** );
456 long double _Import _Optlink _strtold( const char *, char ** );
457 char * _Import _Optlink ultoa( unsigned long, char *, int );
458 char * _Import _Optlink _ultoa( unsigned long, char *, int );
459
460 #pragma map( ecvt , "_ecvt" )
461 #pragma map( fcvt , "_fcvt" )
462 #pragma map( gcvt , "_gcvt" )
463 #pragma map( itoa , "_itoa" )
464 #pragma map( ltoa , "_ltoa" )
465 #pragma map( ultoa , "_ultoa" )
466 #pragma map( putenv , "_putenv" )
467 #pragma map( _strtold, "strtold" )
468
469
470
471
472
473 int _Import _Optlink _beginthread( void ( * _Optlink thread )( void * ), void *, unsigned, void * );
474 void _Import _Optlink _endthread( void );
475 void ** _Import _Optlink _threadstore( void );
476
477 #pragma map( atof , "_atofieee" )
478 #pragma map( strtod, "_strtodieee" )
479
480
481 void _Builtin __enable( void );
482 void _Builtin __disable( void );
483
484
485 int * _Import _Optlink _errno( void );
486 #pragma info( none )
487 #pragma info( restore )
488
489 int * _Import _Optlink __doserrno(void);
490 #pragma info( none )
491 #pragma info( restore )
492
493 extern char ** _Import _environ;
494 extern unsigned char _Import _osmajor;
495 extern unsigned char _Import _osminor;
496 extern unsigned char _Import _osmode;
497
498
499
500 typedef int ( __onexit_t )( void );
501 typedef __onexit_t * onexit_t;
502
503
504
505
506
507 void _Import _Optlink _exit( int );
508 onexit_t _Import _Optlink onexit( onexit_t );
509 onexit_t _Import _Optlink _onexit( onexit_t );
510
511 unsigned long _Builtin __lrotl(unsigned long, int);
512 unsigned long _Builtin __lrotr(unsigned long, int);
513 unsigned short _Builtin __srotl(unsigned short, int);
514 unsigned short _Builtin __srotr(unsigned short, int);
515 unsigned char _Builtin __crotl(unsigned char, int);
516 unsigned char _Builtin __crotr(unsigned char, int);
517
518 void _Import _Optlink _makepath( char *, char *, char *, char *, char * );
519 void _Import _Optlink _splitpath( char *, char *, char *, char *, char * );
520 void _Import _Optlink _searchenv( char *, char *, char *);
521 void _Import _Optlink swab( char *, char *, int );
522 void _Import _Optlink _swab( char *, char *, int );
523
524 #pragma map( onexit , "_onexit" )
525 #pragma map( swab , "_swab" )
526
527 int _Import _Optlink rpmatch(const char *);
528 int _Import _Optlink csid(const char *);
529 int _Import _Optlink wcsid(const wchar_t);
530
531 #pragma map( rpmatch, "_rpmatch" )
532 #pragma map( csid , "_csid" )
533 #pragma map( wcsid , "_wcsid" )
534
535
536
537
538
539
540
541
542
543 #pragma info( none )
544 #pragma info( restore )
545 #pragma info( restore )
546
547
548
549
550
551
552
553
554
555
556
557 char *proio_cons();
558 char * wxmake_integer();
559 char * wxmake_word();
560 char * wxmake_string();
561 char * wxmake_real();
562 char * wxmake_exp();
563 char * wxmake_exp2();
564
565 void add_expr();
566 void process_command();
567 void syntax_error();
568
569
570
571
572
573 int PROIO_yylex(void);
574 int PROIO_yylook(void);
575 int PROIO_yywrap(void);
576 int PROIO_yyback(int *, int);
577
578
579 void PROIO_yyoutput(int);
580
581 #line 36 "parser.y"
582 typedef union {
583 char *s;
584
585 } YYSTYPE;
586 #line 44 "y_tab.c"
587 short PROIO_yylhs[] = { -1,
588 0, 0, 1, 1, 1, 2, 2, 2, 3, 3,
589 3, 4, 4, 5, 5, 5, 5, 5, 5, 5,
590 };
591 short PROIO_yylen[] = { 2,
592 0, 2, 2, 2, 2, 4, 2, 3, 0, 1,
593 3, 3, 1, 1, 1, 1, 3, 3, 5, 1,
594 };
595 short PROIO_yydefred[] = { 1,
596 0, 0, 0, 0, 2, 0, 5, 3, 0, 0,
597 0, 15, 7, 20, 0, 0, 13, 4, 0, 0,
598 0, 0, 8, 0, 6, 0, 18, 0, 12, 11,
599 0, 19,
600 };
601 short PROIO_yydgoto[] = { 1,
602 5, 14, 15, 16, 17,
603 };
604 short PROIO_yysindex[] = { 0,
605 -2, 9, 2, 1, 0, 10, 0, 0, 11, -5,
606 17, 0, 0, 0, 14, -1, 0, 0, 33, 38,
607 41, 16, 0, 11, 0, 29, 0, 40, 0, 0,
608 44, 0,
609 };
610 short PROIO_yyrindex[] = { 0,
611 0, 0, 0, 0, 0, 0, 0, 0, 42, 21,
612 24, 0, 0, 0, 0, 30, 0, 0, 0, 0,
613 0, 0, 0, 31, 0, 27, 0, 24, 0, 0,
614 0, 0,
615 };
616 short PROIO_yygindex[] = { 0,
617 0, 45, -8, 0, 26,
618 };
619 short PROIO_yytable[] = { 3,
620 19, 10, 11, 12, 24, 9, 4, 20, 21, 4,
621 13, 10, 11, 12, 8, 30, 10, 28, 12, 4,
622 9, 7, 18, 23, 4, 16, 16, 22, 14, 14,
623 16, 17, 17, 14, 10, 9, 17, 25, 26, 10,
624 9, 27, 31, 9, 32, 6, 9, 29, 0, 0,
625 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
626 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
627 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
630 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
631 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
635 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
637 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
641 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
642 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
643 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
645 0, 0, 0, 2,
646 };
647 short PROIO_yycheck[] = { 2,
648 9, 1, 2, 3, 6, 4, 9, 13, 14, 9,
649 10, 1, 2, 3, 13, 24, 1, 2, 3, 9,
650 4, 13, 13, 10, 9, 5, 6, 11, 5, 6,
651 10, 5, 6, 10, 5, 5, 10, 5, 1, 10,
652 10, 1, 14, 4, 1, 1, 5, 22, -1, -1,
653 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
654 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
655 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
656 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
657 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
658 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
659 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
660 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
661 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
662 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
663 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
664 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
665 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
666 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
667 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
668 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
669 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
670 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
671 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
672 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
673 -1, -1, -1, 256,
674 };
675 int PROIO_yydebug;
676 int PROIO_yynerrs;
677 int PROIO_yyerrflag;
678 int PROIO_yychar;
679 short *PROIO_yyssp;
680 YYSTYPE *PROIO_yyvsp;
681 YYSTYPE PROIO_yyval;
682 YYSTYPE PROIO_yylval;
683 short PROIO_yyss[600];
684 YYSTYPE PROIO_yyvs[600];
685 #line 118 "parser.y"
686
687
688
689
690
691
692 #pragma info( none )
693 #pragma info( none )
694 #pragma info( restore )
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711 enum _OPERATIONS { _IOINIT, _IOREAD, _IOWRITE, _IOREPOSITION,
712 _IOFLUSH, _IOUNDEFOP };
713
714
715 #pragma pack( 1 )
716 typedef struct __file
717 {
718 unsigned char *_bufPtr;
719 unsigned long int _count;
720 unsigned long int _userFlags;
721 unsigned long int _bufLen;
722 unsigned long int _ungetCount;
723 int _tempStore;
724 unsigned char _ungetBuf[2];
725 enum _OPERATIONS _lastOp;
726 char _filler;
727 } FILE;
728 #pragma pack( )
729
730 typedef struct __fpos_t
731 {
732 long int __fpos_elem[2];
733 } fpos_t;
734
735
736
737
738 typedef char *__va_list;
739
740
741
742
743 extern FILE * const _Import stdin;
744 extern FILE * const _Import stdout;
745 extern FILE * const _Import stderr;
746
747
748
749
750 int _Import _Optlink fprintf( FILE *, const char *, ... );
751 int _Import _Optlink fscanf( FILE *, const char *, ... );
752 int _Import _Optlink printf( const char *, ... );
753 int _Import _Optlink scanf( const char *, ... );
754 int _Import _Optlink sprintf( char *, const char *, ... );
755 int _Import _Optlink sscanf( const char *, const char *, ... );
756 void _Import _Optlink clearerr( FILE * );
757 int _Import _Optlink fclose( FILE * );
758 int _Import _Optlink feof( FILE * );
759 int _Import _Optlink ferror( FILE * );
760 int _Import _Optlink fflush( FILE * );
761 int _Import _Optlink fgetc( FILE * );
762 int _Import _Optlink fgetpos( FILE *, fpos_t * );
763 char * _Import _Optlink fgets( char *, int, FILE * );
764 FILE * _Import _Optlink fopen( const char *, const char * );
765 int _Import _Optlink fputc( int, FILE * );
766 int _Import _Optlink fputs( const char *, FILE * );
767 size_t _Import _Optlink fread( void *, size_t, size_t, FILE * );
768 FILE * _Import _Optlink freopen( const char *, const char *, FILE * );
769 int _Import _Optlink fseek( FILE *, long int, int );
770 int _Import _Optlink fsetpos( FILE *, const fpos_t * );
771 long int _Import _Optlink ftell( FILE * );
772 size_t _Import _Optlink fwrite( const void *, size_t, size_t, FILE * );
773 int _Optlink getc( FILE * );
774 int _Optlink getchar( void );
775 char * _Import _Optlink gets( char * );
776 void _Import _Optlink perror( const char * );
777 int _Optlink putc( int, FILE * );
778 int _Optlink putchar( int );
779 int _Import _Optlink puts( const char * );
780 int _Import _Optlink remove( const char * );
781 int _Import _Optlink rename( const char *, const char * );
782 void _Import _Optlink rewind( FILE * );
783 void _Import _Optlink setbuf( FILE *, char * );
784 int _Import _Optlink setvbuf( FILE *, char *, int, size_t );
785 FILE * _Import _Optlink tmpfile( void );
786 char * _Import _Optlink tmpnam( char * );
787 int _Import _Optlink ungetc( int, FILE * );
788 int _Import _Optlink vfprintf( FILE *, const char *, __va_list );
789 int _Import _Optlink vprintf( const char *, __va_list );
790 int _Import _Optlink vsprintf( char *, const char *, __va_list );
791
792
793
794
795
796
797
798
799
800
801 #pragma map( fprintf, "_fprintfieee" )
802 #pragma map( printf , "_printfieee" )
803 #pragma map( sprintf, "_sprintfieee" )
804 #pragma map( fscanf , "_fscanfieee" )
805 #pragma map( scanf , "_scanfieee" )
806 #pragma map( sscanf , "_sscanfieee" )
807
808 #pragma map( vfprintf, "_vfprintfieee" )
809 #pragma map( vprintf , "_vprintfieee" )
810 #pragma map( vsprintf, "_vsprintfieee" )
811
812 int _Optlink _fcloseall( void );
813 int _Optlink _rmtmp( void );
814
815 FILE * _Optlink fdopen( int, const char *);
816 int _Optlink fgetchar( void );
817 int _Optlink fileno( FILE * );
818 int _Optlink flushall( void );
819 int _Optlink fputchar( int );
820 char * _Optlink tempnam( char *, char * );
821 int _Optlink unlink( const char * );
822
823 FILE * _Optlink _fdopen( int, const char *);
824 int _Optlink _fgetchar( void );
825 int _Optlink _fileno( FILE * );
826 int _Optlink _flushall( void );
827 int _Optlink _fputchar( int );
828 char * _Optlink _tempnam( char *, char * );
829 int _Optlink _unlink( const char * );
830
831 int _Optlink _set_crt_msg_handle( int );
832
833 #pragma map( fdopen , "_fdopen" )
834 #pragma map( fgetchar, "_fgetchar" )
835 #pragma map( fileno , "_fileno" )
836 #pragma map( flushall, "_flushall" )
837 #pragma map( fputchar, "_fputchar" )
838 #pragma map( tempnam , "_tempnam" )
839
840
841
842
843 #pragma info( none )
844 #pragma info( restore )
845 #pragma info( restore )
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861 int read();
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883 int PROIO_yywrap(void) { return 1; }
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898 typedef struct yy_buffer_state *YY_BUFFER_STATE;
899
900 # line 1 "lexer.l"
901 # line 9 "lexer.l"
902
903 #pragma info( none )
904 #pragma info( none )
905 #pragma info( restore )
906
907
908 #pragma info( none )
909 #pragma info( restore )
910 #pragma info( restore )
911
912
913
914
915
916
917
918
919
920
921 static size_t lex_buffer_length = 0;
922 static char *lex_buffer = 0;
923 static size_t lex_string_ptr = 0;
924 static int lex_read_from_string = 0;
925
926 static int my_input(void);
927 static int my_unput(char);
928
929
930 # line 58 "lexer.l"
931
932
933
934
935
936
937
938
939 struct yy_buffer_state
940 {
941 FILE *yy_input_file;
942
943 unsigned char *yy_ch_buf;
944 unsigned char *yy_buf_pos;
945
946
947 int yy_buf_size;
948
949
950 int yy_n_chars;
951
952 int yy_eof_status;
953
954 };
955
956 static YY_BUFFER_STATE yy_current_buffer;
957
958
959
960
961
962 static unsigned char yy_hold_char;
963
964 static int yy_n_chars;
965
966
967
968
969
970 extern unsigned char *PROIO_yytext;
971 extern int PROIO_yyleng;
972 extern FILE *PROIO_yyin, *PROIO_yyout;
973
974 unsigned char *PROIO_yytext;
975 int PROIO_yyleng;
976
977 FILE *PROIO_yyin = (FILE *) 0, *PROIO_yyout = (FILE *) 0;
978
979 typedef int yy_state_type;
980 static short int yy_accept[34] =
981 { 0,
982 0, 0, 18, 16, 13, 14, 16, 16, 6, 7,
983 16, 8, 12, 16, 1, 11, 3, 9, 10, 2,
984 0, 5, 0, 0, 0, 4, 1, 15, 3, 5,
985 0, 0, 0
986 } ;
987
988 static unsigned char yy_ec[256] =
989 { 0,
990 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
991 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
992 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
993 1, 2, 1, 4, 1, 1, 1, 1, 5, 6,
994 7, 8, 9, 10, 9, 11, 12, 13, 13, 13,
995 13, 13, 13, 13, 13, 13, 13, 1, 1, 1,
996 14, 1, 1, 1, 15, 15, 15, 15, 15, 15,
997 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
998 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
999 16, 17, 18, 1, 15, 1, 15, 15, 15, 15,
1000
1001 19, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1002 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1003 15, 15, 1, 20, 1, 1, 1, 1, 1, 1,
1004 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1005 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1006 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1007 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1008 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1009 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1010 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1011
1012 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1013 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1014 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1015 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1016 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1017 1, 1, 1, 1, 1
1018 } ;
1019
1020 static unsigned char yy_meta[21] =
1021 { 0,
1022 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1023 1, 1, 2, 1, 2, 1, 3, 1, 2, 1
1024 } ;
1025
1026 static short int yy_base[37] =
1027 { 0,
1028 0, 0, 48, 55, 55, 55, 17, 42, 55, 55,
1029 19, 55, 55, 23, 17, 55, 0, 55, 55, 0,
1030 18, 55, 19, 23, 21, 55, 12, 55, 0, 24,
1031 25, 29, 55, 49, 52, 22
1032 } ;
1033
1034 static short int yy_def[37] =
1035 { 0,
1036 33, 1, 33, 33, 33, 33, 34, 35, 33, 33,
1037 33, 33, 33, 33, 33, 33, 36, 33, 33, 36,
1038 34, 33, 34, 34, 35, 33, 33, 33, 36, 34,
1039 34, 34, 0, 33, 33, 33
1040 } ;
1041
1042 static short int yy_nxt[76] =
1043 { 0,
1044 4, 5, 6, 7, 8, 9, 10, 4, 11, 12,
1045 13, 14, 15, 16, 17, 18, 4, 19, 20, 4,
1046 22, 22, 30, 29, 27, 26, 22, 22, 30, 27,
1047 28, 27, 30, 23, 23, 23, 24, 24, 24, 31,
1048 23, 32, 24, 24, 24, 23, 26, 33, 24, 21,
1049 21, 21, 25, 25, 3, 33, 33, 33, 33, 33,
1050 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1051 33, 33, 33, 33, 33
1052 } ;
1053
1054 static short int yy_chk[76] =
1055 { 0,
1056 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1057 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1058 7, 21, 23, 36, 27, 25, 24, 30, 31, 15,
1059 14, 11, 32, 7, 21, 23, 7, 21, 23, 24,
1060 30, 31, 24, 30, 31, 32, 8, 3, 32, 34,
1061 34, 34, 35, 35, 33, 33, 33, 33, 33, 33,
1062 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1063 33, 33, 33, 33, 33
1064 } ;
1065
1066 static yy_state_type yy_last_accepting_state;
1067 static unsigned char *yy_last_accepting_cpos;
1068
1069
1070
1071
1072
1073 static unsigned char *yy_c_buf_p = (unsigned char *) 0;
1074 static int yy_init = 1;
1075 static int yy_start = 0;
1076
1077
1078 static int yy_did_buffer_switch_on_eof;
1079
1080 static yy_state_type yy_get_previous_state ();
1081 static yy_state_type yy_try_NUL_trans ();
1082 static int yy_get_next_buffer ();
1083 static void yyunput ();
1084 void PROIO_yyrestart ();
1085 void PROIO_yy_switch_to_buffer ();
1086 void PROIO_yy_load_buffer_state ();
1087 YY_BUFFER_STATE PROIO_yy_create_buffer ();
1088 void PROIO_yy_delete_buffer ();
1089 void PROIO_yy_init_buffer ();
1090
1091
1092 static int input ();
1093
1094 int PROIO_yylex ()
1095 {
1096 register yy_state_type yy_current_state;
1097 register unsigned char *yy_cp, *yy_bp;
1098 register int yy_act;
1099
1100
1101
1102
1103 if ( yy_init )
1104 {
1105 ;
1106
1107 if ( ! yy_start )
1108 yy_start = 1;
1109
1110 if ( ! PROIO_yyin )
1111 PROIO_yyin = stdin;
1112
1113 if ( ! PROIO_yyout )
1114 PROIO_yyout = stdout;
1115
1116 if ( yy_current_buffer )
1117 PROIO_yy_init_buffer( yy_current_buffer, PROIO_yyin );
1118 else
1119 yy_current_buffer = PROIO_yy_create_buffer( PROIO_yyin, (8192 * 2) );
1120
1121 PROIO_yy_load_buffer_state();
1122
1123 yy_init = 0;
1124 }
1125
1126 while ( 1 )
1127 {
1128 yy_cp = yy_c_buf_p;
1129
1130
1131 *yy_cp = yy_hold_char;
1132
1133
1134 yy_bp = yy_cp;
1135
1136 yy_current_state = yy_start;
1137 yy_match:
1138 do
1139 {
1140 register unsigned char yy_c = yy_ec[*yy_cp];
1141 if ( yy_accept[yy_current_state] )
1142 {
1143 yy_last_accepting_state = yy_current_state;
1144 yy_last_accepting_cpos = yy_cp;
1145 }
1146 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1147 {
1148 yy_current_state = yy_def[yy_current_state];
1149 if ( yy_current_state >= 34 )
1150 yy_c = yy_meta[yy_c];
1151 }
1152 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1153 ++yy_cp;
1154 }
1155 while ( yy_current_state != 33 );
1156 yy_cp = yy_last_accepting_cpos;
1157 yy_current_state = yy_last_accepting_state;
1158
1159 yy_find_action:
1160 yy_act = yy_accept[yy_current_state];
1161
1162 PROIO_yytext = yy_bp; PROIO_yyleng = yy_cp - yy_bp; yy_hold_char = *yy_cp; *yy_cp = '\0'; yy_c_buf_p = yy_cp;;
1163 ;
1164
1165 do_action:
1166
1167
1168 switch ( yy_act )
1169 {
1170 case 0:
1171
1172 *yy_cp = yy_hold_char;
1173 yy_cp = yy_last_accepting_cpos;
1174 yy_current_state = yy_last_accepting_state;
1175 goto yy_find_action;
1176
1177 case 1:
1178 # line 60 "lexer.l"
1179 {PROIO_yylval.s = strdup(( char*) PROIO_yytext); return 1;;}
1180 break;
1181 case 2:
1182 # line 62 "lexer.l"
1183 return 14;;
1184 break;
1185 case 3:
1186 # line 64 "lexer.l"
1187 {PROIO_yylval.s = strdup(( char*) PROIO_yytext); return 2;;}
1188 break;
1189 case 4:
1190 # line 66 "lexer.l"
1191 {int len = __strlen( (( char*) PROIO_yytext) );
1192 PROIO_yytext[len-1] = 0;
1193 PROIO_yylval.s = strdup(( char*) (PROIO_yytext+1));
1194 return 2;;}
1195 break;
1196 case 5:
1197 # line 71 "lexer.l"
1198 {PROIO_yylval.s = strdup(( char*) PROIO_yytext); return 3;;}
1199 break;
1200 case 6:
1201 # line 73 "lexer.l"
1202 return 4;;
1203 break;
1204 case 7:
1205 # line 75 "lexer.l"
1206 return 5;;
1207 break;
1208 case 8:
1209 # line 77 "lexer.l"
1210 return 6;;
1211 break;
1212 case 9:
1213 # line 79 "lexer.l"
1214 return 9;;
1215 break;
1216 case 10:
1217 # line 81 "lexer.l"
1218 return 10;;
1219 break;
1220 case 11:
1221 # line 83 "lexer.l"
1222 return 11;;
1223 break;
1224 case 12:
1225 # line 85 "lexer.l"
1226 return 13;;
1227 break;
1228 case 13:
1229 # line 87 "lexer.l"
1230 ;
1231 break;
1232 case 14:
1233 # line 89 "lexer.l"
1234 ;
1235 break;
1236 case 15:
1237 # line 91 "lexer.l"
1238 { loop:
1239 while (input() != '*');
1240 switch (input())
1241 {
1242 case '/': break;
1243 case '*': yyunput( '*', PROIO_yytext );
1244 default: goto loop;
1245 }
1246 }
1247 break;
1248 case 16:
1249 # line 106 "lexer.l"
1250 return 8;;
1251 break;
1252 case 17:
1253 # line 108 "lexer.l"
1254 (void) fwrite( (char *) PROIO_yytext, PROIO_yyleng, 1, PROIO_yyout );
1255 break;
1256 case (18 + 0 + 1):
1257 return ( 0 );
1258
1259 case 18:
1260 {
1261
1262 int yy_amount_of_matched_text = yy_cp - PROIO_yytext - 1;
1263
1264
1265 *yy_cp = yy_hold_char;
1266
1267
1268 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1269
1270 {
1271 yy_state_type yy_next_state;
1272
1273 yy_c_buf_p = PROIO_yytext + yy_amount_of_matched_text;
1274
1275 yy_current_state = yy_get_previous_state();
1276
1277
1278
1279 yy_next_state = yy_try_NUL_trans( yy_current_state );
1280
1281 yy_bp = PROIO_yytext + 0;
1282
1283 if ( yy_next_state )
1284 {
1285
1286 yy_cp = ++yy_c_buf_p;
1287 yy_current_state = yy_next_state;
1288 goto yy_match;
1289 }
1290
1291 else
1292 {
1293 yy_cp = yy_last_accepting_cpos;
1294 yy_current_state = yy_last_accepting_state;
1295 goto yy_find_action;
1296 }
1297 }
1298
1299 else switch ( yy_get_next_buffer() )
1300 {
1301 case 1:
1302 {
1303 yy_did_buffer_switch_on_eof = 0;
1304
1305 if ( PROIO_yywrap() )
1306 {
1307
1308 yy_c_buf_p = PROIO_yytext + 0;
1309
1310 yy_act = (18 + (yy_start - 1) / 2 + 1);
1311 goto do_action;
1312 }
1313
1314 else
1315 {
1316 if ( ! yy_did_buffer_switch_on_eof )
1317 do { PROIO_yy_init_buffer( yy_current_buffer, PROIO_yyin ); PROIO_yy_load_buffer_state(); } while ( 0 );
1318 }
1319 }
1320 break;
1321
1322 case 0:
1323 yy_c_buf_p = PROIO_yytext + yy_amount_of_matched_text;
1324
1325 yy_current_state = yy_get_previous_state();
1326
1327 yy_cp = yy_c_buf_p;
1328 yy_bp = PROIO_yytext + 0;
1329 goto yy_match;
1330
1331 case 2:
1332 yy_c_buf_p =
1333 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1334
1335 yy_current_state = yy_get_previous_state();
1336
1337 yy_cp = yy_c_buf_p;
1338 yy_bp = PROIO_yytext + 0;
1339 goto yy_find_action;
1340 }
1341 break;
1342 }
1343
1344 default:
1345 do { (void) fputs( "fatal flex scanner internal error--no action found", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1346 }
1347 }
1348 }
1349
1350
1351
1352
1353 static int yy_get_next_buffer()
1354
1355 {
1356 register unsigned char *dest = yy_current_buffer->yy_ch_buf;
1357 register unsigned char *source = PROIO_yytext - 1;
1358 register int number_to_move, i;
1359 int ret_val;
1360
1361 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1362 do { (void) fputs( "fatal flex scanner internal error--end of buffer missed", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1363
1364
1365
1366
1367 number_to_move = yy_c_buf_p - PROIO_yytext;
1368
1369 for ( i = 0; i < number_to_move; ++i )
1370 *(dest++) = *(source++);
1371
1372 if ( yy_current_buffer->yy_eof_status != 0 )
1373
1374 yy_n_chars = 0;
1375
1376 else
1377 {
1378 int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
1379
1380 if ( num_to_read > 8192 )
1381 num_to_read = 8192;
1382
1383 else if ( num_to_read <= 0 )
1384 do { (void) fputs( "fatal error - scanner input buffer overflow", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1385
1386
1387 if (lex_read_from_string) { int c = my_input(); yy_n_chars = (c == 0) ? 0 : (((&yy_current_buffer->yy_ch_buf[number_to_move]))[0]=(c), 1); } else if ( (yy_n_chars = read( fileno(PROIO_yyin), (char *) (&yy_current_buffer->yy_ch_buf[number_to_move]), num_to_read )) < 0 ) do { (void) fputs( "read() in flex scanner failed", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );;
1388 }
1389
1390 if ( yy_n_chars == 0 )
1391 {
1392 if ( number_to_move == 1 )
1393 {
1394 ret_val = 1;
1395 yy_current_buffer->yy_eof_status = 2;
1396 }
1397
1398 else
1399 {
1400 ret_val = 2;
1401 yy_current_buffer->yy_eof_status = 1;
1402 }
1403 }
1404
1405 else
1406 ret_val = 0;
1407
1408 yy_n_chars += number_to_move;
1409 yy_current_buffer->yy_ch_buf[yy_n_chars] = 0;
1410 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = 0;
1411
1412
1413
1414 PROIO_yytext = &yy_current_buffer->yy_ch_buf[1];
1415
1416 return ( ret_val );
1417 }
1418
1419
1420
1421
1422 static yy_state_type yy_get_previous_state()
1423
1424 {
1425 register yy_state_type yy_current_state;
1426 register unsigned char *yy_cp;
1427
1428 yy_current_state = yy_start;
1429
1430 for ( yy_cp = PROIO_yytext + 0; yy_cp < yy_c_buf_p; ++yy_cp )
1431 {
1432 register unsigned char yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
1433 if ( yy_accept[yy_current_state] )
1434 {
1435 yy_last_accepting_state = yy_current_state;
1436 yy_last_accepting_cpos = yy_cp;
1437 }
1438 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1439 {
1440 yy_current_state = yy_def[yy_current_state];
1441 if ( yy_current_state >= 34 )
1442 yy_c = yy_meta[yy_c];
1443 }
1444 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1445 }
1446
1447 return ( yy_current_state );
1448 }
1449
1450
1451
1452
1453 static yy_state_type yy_try_NUL_trans( yy_current_state )
1454 register yy_state_type yy_current_state;
1455
1456 {
1457 register int yy_is_jam;
1458 register unsigned char *yy_cp = yy_c_buf_p;
1459
1460 register unsigned char yy_c = 1;
1461 if ( yy_accept[yy_current_state] )
1462 {
1463 yy_last_accepting_state = yy_current_state;
1464 yy_last_accepting_cpos = yy_cp;
1465 }
1466 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1467 {
1468 yy_current_state = yy_def[yy_current_state];
1469 if ( yy_current_state >= 34 )
1470 yy_c = yy_meta[yy_c];
1471 }
1472 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1473 yy_is_jam = (yy_current_state == 33);
1474
1475 return ( yy_is_jam ? 0 : yy_current_state );
1476 }
1477
1478
1479 static void yyunput( c, yy_bp )
1480 unsigned char c;
1481 register unsigned char *yy_bp;
1482
1483 {
1484 register unsigned char *yy_cp = yy_c_buf_p;
1485
1486
1487 *yy_cp = yy_hold_char;
1488
1489 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1490 {
1491 register int number_to_move = yy_n_chars + 2;
1492 register unsigned char *dest =
1493 &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
1494 register unsigned char *source =
1495 &yy_current_buffer->yy_ch_buf[number_to_move];
1496
1497 while ( source > yy_current_buffer->yy_ch_buf )
1498 *--dest = *--source;
1499
1500 yy_cp += dest - source;
1501 yy_bp += dest - source;
1502 yy_n_chars = yy_current_buffer->yy_buf_size;
1503
1504 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1505 do { (void) fputs( "flex scanner push-back overflow", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1506 }
1507
1508 if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
1509 yy_cp[-2] = '\n';
1510
1511 *--yy_cp = c;
1512
1513
1514 PROIO_yytext = yy_bp; PROIO_yyleng = yy_cp - yy_bp; yy_hold_char = *yy_cp; *yy_cp = '\0'; yy_c_buf_p = yy_cp;;
1515 }
1516
1517
1518 static int input()
1519
1520 {
1521 int c;
1522 unsigned char *yy_cp = yy_c_buf_p;
1523
1524 *yy_cp = yy_hold_char;
1525
1526 if ( *yy_c_buf_p == 0 )
1527 {
1528
1529 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1530
1531 *yy_c_buf_p = '\0';
1532
1533 else
1534 {
1535 PROIO_yytext = yy_c_buf_p;
1536 ++yy_c_buf_p;
1537
1538 switch ( yy_get_next_buffer() )
1539 {
1540 case 1:
1541 {
1542 if ( PROIO_yywrap() )
1543 {
1544 yy_c_buf_p = PROIO_yytext + 0;
1545 return ( (-1) );
1546 }
1547
1548 do { PROIO_yy_init_buffer( yy_current_buffer, PROIO_yyin ); PROIO_yy_load_buffer_state(); } while ( 0 );
1549
1550 return ( input() );
1551 }
1552 break;
1553
1554 case 0:
1555 yy_c_buf_p = PROIO_yytext + 0;
1556 break;
1557
1558 case 2:
1559 do { (void) fputs( "unexpected last match in input()", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1560 }
1561 }
1562 }
1563
1564 c = *yy_c_buf_p;
1565 yy_hold_char = *++yy_c_buf_p;
1566
1567 return ( c );
1568 }
1569
1570
1571 void PROIO_yyrestart( input_file )
1572 FILE *input_file;
1573
1574 {
1575 PROIO_yy_init_buffer( yy_current_buffer, input_file );
1576 PROIO_yy_load_buffer_state();
1577 }
1578
1579
1580 void PROIO_yy_switch_to_buffer( new_buffer )
1581 YY_BUFFER_STATE new_buffer;
1582
1583 {
1584 if ( yy_current_buffer == new_buffer )
1585 return;
1586
1587 if ( yy_current_buffer )
1588 {
1589
1590 *yy_c_buf_p = yy_hold_char;
1591 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1592 yy_current_buffer->yy_n_chars = yy_n_chars;
1593 }
1594
1595 yy_current_buffer = new_buffer;
1596 PROIO_yy_load_buffer_state();
1597
1598
1599 yy_did_buffer_switch_on_eof = 1;
1600 }
1601
1602
1603 void PROIO_yy_load_buffer_state()
1604
1605 {
1606 yy_n_chars = yy_current_buffer->yy_n_chars;
1607 PROIO_yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1608 PROIO_yyin = yy_current_buffer->yy_input_file;
1609 yy_hold_char = *yy_c_buf_p;
1610 }
1611
1612
1613 YY_BUFFER_STATE PROIO_yy_create_buffer( file, size )
1614 FILE *file;
1615 int size;
1616
1617 {
1618 YY_BUFFER_STATE b;
1619
1620 b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
1621
1622 if ( ! b )
1623 do { (void) fputs( "out of dynamic memory in yy_create_buffer()", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1624
1625 b->yy_buf_size = size;
1626
1627
1628 b->yy_ch_buf = (unsigned char *) malloc( (unsigned) (b->yy_buf_size + 2) );
1629
1630 if ( ! b->yy_ch_buf )
1631 do { (void) fputs( "out of dynamic memory in yy_create_buffer()", stderr ); (void) fputc( ('\n'), (stderr) ); exit( 1 ); } while ( 0 );
1632
1633 PROIO_yy_init_buffer( b, file );
1634
1635 return ( b );
1636 }
1637
1638
1639 void PROIO_yy_delete_buffer( b )
1640 YY_BUFFER_STATE b;
1641
1642 {
1643 if ( b == yy_current_buffer )
1644 yy_current_buffer = (YY_BUFFER_STATE) 0;
1645
1646 free( (char *) b->yy_ch_buf );
1647 free( (char *) b );
1648 }
1649
1650
1651 void PROIO_yy_init_buffer( b, file )
1652 YY_BUFFER_STATE b;
1653 FILE *file;
1654
1655 {
1656 b->yy_input_file = file;
1657
1658
1659
1660 b->yy_ch_buf[0] = '\n';
1661 b->yy_n_chars = 1;
1662
1663
1664 b->yy_ch_buf[1] = 0;
1665 b->yy_ch_buf[2] = 0;
1666
1667 b->yy_buf_pos = &b->yy_ch_buf[1];
1668
1669 b->yy_eof_status = 0;
1670 }
1671 # line 108 "lexer.l"
1672
1673
1674
1675 static int lex_input() {
1676 return input();
1677 }
1678
1679
1680 void LexFromFile(FILE *fd)
1681 {
1682 lex_read_from_string = 0;
1683 PROIO_yyin = fd;
1684
1685 yy_init = 1;
1686 }
1687
1688 void LexFromString(char *buffer)
1689 {
1690 lex_read_from_string = 1;
1691 lex_buffer = buffer;
1692 lex_buffer_length = __strlen( (( char*) buffer) );
1693 lex_string_ptr = 0;
1694
1695 yy_init = 1;
1696 }
1697
1698 static int my_input( void )
1699 {
1700 if (lex_read_from_string) {
1701 if (lex_string_ptr == lex_buffer_length)
1702 return 0;
1703 else {
1704 char c = lex_buffer[lex_string_ptr++];
1705 return c;
1706 }
1707 } else {
1708 return lex_input();
1709 }
1710 }
1711
1712 void wxExprCleanUp()
1713 {
1714 if (yy_current_buffer)
1715 PROIO_yy_delete_buffer(yy_current_buffer);
1716 }
1717
1718
1719
1720
1721
1722 void PROIO_yyerror(char *s)
1723 {
1724 syntax_error(s);
1725 }
1726
1727
1728
1729
1730
1731 int PROIO_yywrap() { return 1; }
1732 #line 247 "y_tab.c"
1733 int
1734 PROIO_yyparse()
1735 {
1736 register int yym, yyn, yystate;
1737
1738 PROIO_yynerrs = 0;
1739 PROIO_yyerrflag = 0;
1740 PROIO_yychar = (-1);
1741
1742 PROIO_yyssp = PROIO_yyss;
1743 PROIO_yyvsp = PROIO_yyvs;
1744 *PROIO_yyssp = yystate = 0;
1745
1746 yyloop:
1747 if (yyn = PROIO_yydefred[yystate]) goto yyreduce;
1748 if (PROIO_yychar < 0)
1749 {
1750 if ((PROIO_yychar = PROIO_yylex()) < 0) PROIO_yychar = 0;
1751 }
1752 if ((yyn = PROIO_yysindex[yystate]) && (yyn += PROIO_yychar) >= 0 &&
1753 yyn <= 254 && PROIO_yycheck[yyn] == PROIO_yychar)
1754 {
1755 if (PROIO_yyssp >= PROIO_yyss + 600 - 1)
1756 {
1757 goto yyoverflow;
1758 }
1759 *++PROIO_yyssp = yystate = PROIO_yytable[yyn];
1760 *++PROIO_yyvsp = PROIO_yylval;
1761 PROIO_yychar = (-1);
1762 if (PROIO_yyerrflag > 0) --PROIO_yyerrflag;
1763 goto yyloop;
1764 }
1765 if ((yyn = PROIO_yyrindex[yystate]) && (yyn += PROIO_yychar) >= 0 &&
1766 yyn <= 254 && PROIO_yycheck[yyn] == PROIO_yychar)
1767 {
1768 yyn = PROIO_yytable[yyn];
1769 goto yyreduce;
1770 }
1771 if (PROIO_yyerrflag) goto yyinrecovery;
1772 yynewerror:
1773 PROIO_yyerror("syntax error");
1774 yyerrlab:
1775 ++PROIO_yynerrs;
1776 yyinrecovery:
1777 if (PROIO_yyerrflag < 3)
1778 {
1779 PROIO_yyerrflag = 3;
1780 for (;;)
1781 {
1782 if ((yyn = PROIO_yysindex[*PROIO_yyssp]) && (yyn += 256) >= 0 &&
1783 yyn <= 254 && PROIO_yycheck[yyn] == 256)
1784 {
1785 if (PROIO_yyssp >= PROIO_yyss + 600 - 1)
1786 {
1787 goto yyoverflow;
1788 }
1789 *++PROIO_yyssp = yystate = PROIO_yytable[yyn];
1790 *++PROIO_yyvsp = PROIO_yylval;
1791 goto yyloop;
1792 }
1793 else
1794 {
1795 if (PROIO_yyssp <= PROIO_yyss) goto yyabort;
1796 --PROIO_yyssp;
1797 --PROIO_yyvsp;
1798 }
1799 }
1800 }
1801 else
1802 {
1803 if (PROIO_yychar == 0) goto yyabort;
1804 PROIO_yychar = (-1);
1805 goto yyloop;
1806 }
1807 yyreduce:
1808 yym = PROIO_yylen[yyn];
1809 PROIO_yyval = PROIO_yyvsp[1-yym];
1810 switch (yyn)
1811 {
1812 case 3:
1813 #line 68 "parser.y"
1814 {process_command(proio_cons(wxmake_word(PROIO_yyvsp[-1].s), 0)); free(PROIO_yyvsp[-1].s);}
1815 break;
1816 case 4:
1817 #line 70 "parser.y"
1818 {process_command(PROIO_yyvsp[-1].s);}
1819 break;
1820 case 5:
1821 #line 72 "parser.y"
1822 {syntax_error("Unrecognized command.");}
1823 break;
1824 case 6:
1825 #line 76 "parser.y"
1826 {PROIO_yyval.s = proio_cons(wxmake_word(PROIO_yyvsp[-3].s), PROIO_yyvsp[-1].s); free(PROIO_yyvsp[-3].s);}
1827 break;
1828 case 7:
1829 #line 78 "parser.y"
1830 {PROIO_yyval.s = proio_cons(0, 0);}
1831 break;
1832 case 8:
1833 #line 80 "parser.y"
1834 {PROIO_yyval.s = PROIO_yyvsp[-1].s; }
1835 break;
1836 case 9:
1837 #line 84 "parser.y"
1838 {PROIO_yyval.s = 0;}
1839 break;
1840 case 10:
1841 #line 86 "parser.y"
1842 {PROIO_yyval.s = proio_cons(PROIO_yyvsp[0].s, 0);}
1843 break;
1844 case 11:
1845 #line 89 "parser.y"
1846 {PROIO_yyval.s = proio_cons(PROIO_yyvsp[-2].s, PROIO_yyvsp[0].s);}
1847 break;
1848 case 12:
1849 #line 93 "parser.y"
1850 {PROIO_yyval.s = proio_cons(wxmake_word("="), proio_cons(wxmake_word(PROIO_yyvsp[-2].s), proio_cons(PROIO_yyvsp[0].s, 0)));
1851 free(PROIO_yyvsp[-2].s); }
1852 break;
1853 case 13:
1854 #line 96 "parser.y"
1855 {PROIO_yyval.s = PROIO_yyvsp[0].s; }
1856 break;
1857 case 14:
1858 #line 99 "parser.y"
1859 {PROIO_yyval.s = wxmake_word(PROIO_yyvsp[0].s); free(PROIO_yyvsp[0].s);}
1860 break;
1861 case 15:
1862 #line 101 "parser.y"
1863 {PROIO_yyval.s = wxmake_string(PROIO_yyvsp[0].s); free(PROIO_yyvsp[0].s);}
1864 break;
1865 case 16:
1866 #line 103 "parser.y"
1867 {PROIO_yyval.s = wxmake_integer(PROIO_yyvsp[0].s); free(PROIO_yyvsp[0].s);}
1868 break;
1869 case 17:
1870 #line 105 "parser.y"
1871 {PROIO_yyval.s = wxmake_real(PROIO_yyvsp[-2].s, PROIO_yyvsp[0].s); free(PROIO_yyvsp[-2].s); free(PROIO_yyvsp[0].s); }
1872 break;
1873 case 18:
1874 #line 107 "parser.y"
1875 {PROIO_yyval.s = wxmake_exp(PROIO_yyvsp[-2].s, PROIO_yyvsp[0].s); free(PROIO_yyvsp[-2].s); free(PROIO_yyvsp[0].s); }
1876 break;
1877 case 19:
1878 #line 110 "parser.y"
1879 {PROIO_yyval.s = wxmake_exp2(PROIO_yyvsp[-4].s, PROIO_yyvsp[-2].s, PROIO_yyvsp[0].s); free(PROIO_yyvsp[-4].s); free(PROIO_yyvsp[-2].s);
1880 free(PROIO_yyvsp[0].s); }
1881 break;
1882 case 20:
1883 #line 114 "parser.y"
1884 {PROIO_yyval.s = PROIO_yyvsp[0].s;}
1885 break;
1886 #line 461 "y_tab.c"
1887 }
1888 PROIO_yyssp -= yym;
1889 yystate = *PROIO_yyssp;
1890 PROIO_yyvsp -= yym;
1891 yym = PROIO_yylhs[yyn];
1892 if (yystate == 0 && yym == 0)
1893 {
1894 yystate = 1;
1895 *++PROIO_yyssp = 1;
1896 *++PROIO_yyvsp = PROIO_yyval;
1897 if (PROIO_yychar < 0)
1898 {
1899 if ((PROIO_yychar = PROIO_yylex()) < 0) PROIO_yychar = 0;
1900 }
1901 if (PROIO_yychar == 0) goto yyaccept;
1902 goto yyloop;
1903 }
1904 if ((yyn = PROIO_yygindex[yym]) && (yyn += yystate) >= 0 &&
1905 yyn <= 254 && PROIO_yycheck[yyn] == yystate)
1906 yystate = PROIO_yytable[yyn];
1907 else
1908 yystate = PROIO_yydgoto[yym];
1909 if (PROIO_yyssp >= PROIO_yyss + 600 - 1)
1910 {
1911 goto yyoverflow;
1912 }
1913 *++PROIO_yyssp = yystate;
1914 *++PROIO_yyvsp = PROIO_yyval;
1915 goto yyloop;
1916 yyoverflow:
1917 PROIO_yyerror("yacc stack overflow");
1918 yyabort:
1919 return (1);
1920 yyaccept:
1921 return (0);
1922 }
wxWidgets (Impactor)