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 }