home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / uccs / root.13 / usr / ccs / lib / yaccpar < prev   
Encoding:
Text File  |  1998-08-19  |  10.7 KB  |  490 lines
  1. #ident    "@(#)yacc:common/yaccpar    1.28"
  2.  
  3. /*
  4. ** Skeleton parser driver for yacc output
  5. */
  6.  
  7. #include <unistd.h>     /* to get a definition for gettxt so C++ doesn't
  8.                 complain */
  9.  
  10. /*
  11. ** yacc user known macros and defines
  12. */
  13. #define YYERROR        goto $Perrlab
  14. #define YYACCEPT    return(0)
  15. #define YYABORT        return(1)
  16. #define YYBACKUP( newtoken, newvalue )\
  17. {\
  18.     if ( $Pchar >= 0 || ( $Pr2[ $Ptmp ] >> 1 ) != 1 )\
  19.     {\
  20.         $Perror( gettxt("uxlibc:78", "Syntax error - cannot backup") );\
  21.         goto $Perrlab;\
  22.     }\
  23.     $Pchar = newtoken;\
  24.     $Pstate = *$Pps;\
  25.     $Plval = newvalue;\
  26.     goto $Pnewstate;\
  27. }
  28. #define YYRECOVERING()    (!!$Perrflag)
  29. #define YYNEW(type)    (char *) malloc(sizeof(type) * $Pnewmax)
  30. #define YYCOPY(to, from, type) \
  31.     (type *) memcpy(to, (char *) from, $Pnewmax * sizeof(type))
  32. #define YYENLARGE( from, type) \
  33.     (type *) realloc((char *) from, $Pnewmax * sizeof(type))
  34. #ifndef YYDEBUG
  35. #    define YYDEBUG    1    /* make debugging available */
  36. #endif
  37.  
  38. /*
  39. ** user known globals
  40. */
  41. int $Pdebug;            /* set to 1 to get debugging */
  42.  
  43. /*
  44. ** driver internal defines
  45. */
  46. #define YYFLAG        (-10000000)
  47.  
  48. /*
  49. ** global variables used by the parser
  50. */
  51. YYSTYPE *$Ppv;            /* top of value stack */
  52. int *$Pps;            /* top of state stack */
  53.  
  54. int $Pstate;            /* current state */
  55. int $Ptmp;            /* extra var (lasts between blocks) */
  56.  
  57. int $Pnerrs;            /* number of errors */
  58. int $Perrflag;            /* error recovery flag */
  59. int $Pchar;            /* current input token number */
  60.  
  61.  
  62.  
  63. /*
  64. ** $Pparse - return 0 if worked, 1 if syntax error not recovered from
  65. */
  66. #if defined(__STDC__) || defined(__cplusplus)
  67. int $Pparse(void)
  68. #else
  69. int $Pparse()
  70. #endif
  71. {
  72.     register YYSTYPE *$Ppvt;    /* top of value stack for $vars */
  73.     int *$Ps_end;
  74.  
  75.     /*
  76.     ** Initialize externals - $Pparse may be called more than once
  77.     */
  78.     $Ppv = &$Pv[-1];
  79.     $Pps = &$Ps[-1];
  80.     $Pstate = 0;
  81.     $Ptmp = 0;
  82.     $Pnerrs = 0;
  83.     $Perrflag = 0;
  84.     $Pchar = -1;
  85.  
  86. #if YYMAXDEPTH <= 0
  87.     if ($Pmaxdepth <= 0)
  88.     {
  89.         if (($Pmaxdepth = YYEXPAND(0)) <= 0)
  90.         {
  91.             $Perror(gettxt("uxlibc:79", "Yacc initialization error"));
  92.             YYABORT;
  93.         }
  94.     }
  95. #endif
  96.     $Ps_end = &$Ps[$Pmaxdepth];
  97.  
  98.     goto $Pstack;
  99.     {
  100.         register YYSTYPE *$P_pv;    /* top of value stack */
  101.         register int *$P_ps;        /* top of state stack */
  102.         register int $P_state;        /* current state */
  103.         register int  $P_n;        /* internal state number info */
  104.  
  105.         /*
  106.         ** get globals into registers.
  107.         ** branch to here only if YYBACKUP was called.
  108.         */
  109.     $Pnewstate:
  110.         $P_pv = $Ppv;
  111.         $P_ps = $Pps;
  112.         $P_state = $Pstate;
  113.         goto $P_newstate;
  114.  
  115.         /*
  116.         ** get globals into registers.
  117.         ** either we just started, or we just finished a reduction
  118.         */
  119.     $Pstack:
  120.         $P_pv = $Ppv;
  121.         $P_ps = $Pps;
  122.         $P_state = $Pstate;
  123.  
  124.         /*
  125.         ** top of for (;;) loop while no reductions done
  126.         */
  127.     $P_stack:
  128.         /*
  129.         ** put a state and value onto the stacks
  130.         */
  131. #if YYDEBUG
  132.         /*
  133.         ** if debugging, look up token value in list of value vs.
  134.         ** name pairs.  0 and negative (-1) are special values.
  135.         ** Note: linear search is used since time is not a real
  136.         ** consideration while debugging.
  137.         */
  138.         if ( $Pdebug )
  139.         {
  140.             register int $P_i;
  141.  
  142.             printf( "State %d, token ", $P_state );
  143.             if ( $Pchar == 0 )
  144.                 printf( "end-of-file\n" );
  145.             else if ( $Pchar < 0 )
  146.                 printf( "-none-\n" );
  147.             else
  148.             {
  149.                 for ( $P_i = 0; $Ptoks[$P_i].t_val >= 0;
  150.                     $P_i++ )
  151.                 {
  152.                     if ( $Ptoks[$P_i].t_val == $Pchar )
  153.                         break;
  154.                 }
  155.                 printf( "%s\n", $Ptoks[$P_i].t_name );
  156.             }
  157.         }
  158. #endif /* YYDEBUG */
  159.         if ( ++$P_ps >= $Ps_end )    /* room on stack? */
  160.         {
  161.             int $Pnewmax;
  162.             long byte_offset;
  163.             int *$Ps_base = $Ps;
  164.             YYSTYPE *$Pv_base = $Pv;
  165. #ifdef YYEXPAND
  166.             $Pnewmax = YYEXPAND($Pmaxdepth);
  167. #else
  168.             $Pnewmax = 2 * $Pmaxdepth;    /* double table size */
  169.             if ($Pmaxdepth == YYMAXDEPTH)    /* first time growth */
  170.             {
  171.                 char *new$Ps = YYNEW(int);
  172.                 char *new$Pv = YYNEW(YYSTYPE);
  173.                 if (new$Ps != 0 && new$Pv != 0)
  174.                 {
  175.                     $Ps = YYCOPY(new$Ps, $Ps, int);
  176.                     $Pv = YYCOPY(new$Pv, $Pv, YYSTYPE);
  177.                 }
  178.                 else
  179.                     $Pnewmax = 0;    /* failed */
  180.             }
  181.             else                /* not first time */
  182.             {
  183.                 $Ps = YYENLARGE($Ps, int);
  184.                 $Pv = YYENLARGE($Pv, YYSTYPE);
  185.                 if ($Ps == 0 || $Pv == 0)
  186.                     $Pnewmax = 0;    /* failed */
  187.             }
  188. #endif
  189.             if ($Pnewmax <= $Pmaxdepth)    /* tables not expanded */
  190.             {
  191.                 $Perror( gettxt("uxlibc:80", "Yacc stack overflow") );
  192.                 YYABORT;
  193.             }
  194.             $Pmaxdepth = $Pnewmax;
  195.             $Ps_end = &$Ps[$Pmaxdepth];
  196.  
  197.             /* reset pointers into $Ps */
  198.             byte_offset = (char *)$Ps - (char *)$Ps_base;
  199.             /*LINTED*/
  200.             $P_ps = (int *)(byte_offset + (char *)$P_ps);
  201.             /*LINTED*/
  202.             $Pps = (int *)(byte_offset + (char *)$Pps);
  203.  
  204.             /* reset pointers into $Pv */
  205.             byte_offset = (char *)$Pv - (char *)$Pv_base;
  206.             /*LINTED*/
  207.             $Ppvt = (YYSTYPE *)(byte_offset + (char *)$Ppvt);
  208.             /*LINTED*/
  209.             $P_pv = (YYSTYPE *)(byte_offset + (char *)$P_pv);
  210.             /*LINTED*/
  211.             $Ppv = (YYSTYPE *)(byte_offset + (char *)$Ppv);
  212.         }
  213.         *$P_ps = $P_state;
  214.         *++$P_pv = $Pval;
  215.  
  216.         /*
  217.         ** we have a new state - find out what to do
  218.         */
  219.     $P_newstate:
  220.         if ( ( $P_n = $Ppact[ $P_state ] ) <= YYFLAG )
  221.             goto $Pdefault;        /* simple state */
  222. #if YYDEBUG
  223.         /*
  224.         ** if debugging, need to mark whether new token grabbed
  225.         */
  226.         $Ptmp = $Pchar < 0;
  227. #endif
  228.         if ( ( $Pchar < 0 ) && ( ( $Pchar = $Plex() ) < 0 ) )
  229.             $Pchar = 0;        /* reached EOF */
  230. #if YYDEBUG
  231.         if ( $Pdebug && $Ptmp )
  232.         {
  233.             register int $P_i;
  234.  
  235.             printf( "Received token " );
  236.             if ( $Pchar == 0 )
  237.                 printf( "end-of-file\n" );
  238.             else if ( $Pchar < 0 )
  239.                 printf( "-none-\n" );
  240.             else
  241.             {
  242.                 for ( $P_i = 0; $Ptoks[$P_i].t_val >= 0;
  243.                     $P_i++ )
  244.                 {
  245.                     if ( $Ptoks[$P_i].t_val == $Pchar )
  246.                         break;
  247.                 }
  248.                 printf( "%s\n", $Ptoks[$P_i].t_name );
  249.             }
  250.         }
  251. #endif /* YYDEBUG */
  252.         if ( ( ( $P_n += $Pchar ) < 0 ) || ( $P_n >= YYLAST ) )
  253.             goto $Pdefault;
  254.         if ( $Pchk[ $P_n = $Pact[ $P_n ] ] == $Pchar )    /*valid shift*/
  255.         {
  256.             $Pchar = -1;
  257.             $Pval = $Plval;
  258.             $P_state = $P_n;
  259.             if ( $Perrflag > 0 )
  260.                 $Perrflag--;
  261.             goto $P_stack;
  262.         }
  263.  
  264.     $Pdefault:
  265.         if ( ( $P_n = $Pdef[ $P_state ] ) == -2 )
  266.         {
  267. #if YYDEBUG
  268.             $Ptmp = $Pchar < 0;
  269. #endif
  270.             if ( ( $Pchar < 0 ) && ( ( $Pchar = $Plex() ) < 0 ) )
  271.                 $Pchar = 0;        /* reached EOF */
  272. #if YYDEBUG
  273.             if ( $Pdebug && $Ptmp )
  274.             {
  275.                 register int $P_i;
  276.  
  277.                 printf( "Received token " );
  278.                 if ( $Pchar == 0 )
  279.                     printf( "end-of-file\n" );
  280.                 else if ( $Pchar < 0 )
  281.                     printf( "-none-\n" );
  282.                 else
  283.                 {
  284.                     for ( $P_i = 0;
  285.                         $Ptoks[$P_i].t_val >= 0;
  286.                         $P_i++ )
  287.                     {
  288.                         if ( $Ptoks[$P_i].t_val
  289.                             == $Pchar )
  290.                         {
  291.                             break;
  292.                         }
  293.                     }
  294.                     printf( "%s\n", $Ptoks[$P_i].t_name );
  295.                 }
  296.             }
  297. #endif /* YYDEBUG */
  298.             /*
  299.             ** look through exception table
  300.             */
  301.             {
  302.                 register $Ptabelem *$Pxi = ($Ptabelem *)$Pexca;
  303.  
  304.                 while ( ( *$Pxi != -1 ) ||
  305.                     ( $Pxi[1] != $P_state ) )
  306.                 {
  307.                     $Pxi += 2;
  308.                 }
  309.                 while ( ( *($Pxi += 2) >= 0 ) &&
  310.                     ( *$Pxi != $Pchar ) )
  311.                     ;
  312.                 if ( ( $P_n = $Pxi[1] ) < 0 )
  313.                     YYACCEPT;
  314.             }
  315.         }
  316.  
  317.         /*
  318.         ** check for syntax error
  319.         */
  320.         if ( $P_n == 0 )    /* have an error */
  321.         {
  322.             /* no worry about speed here! */
  323.             switch ( $Perrflag )
  324.             {
  325.             case 0:        /* new error */
  326.                 $Perror( gettxt("uxlibc:81", "Syntax error") );
  327.                 goto skip_init;
  328.             $Perrlab:
  329.                 /*
  330.                 ** get globals into registers.
  331.                 ** we have a user generated syntax type error
  332.                 */
  333.                 $P_pv = $Ppv;
  334.                 $P_ps = $Pps;
  335.                 $P_state = $Pstate;
  336.                 $Pnerrs++;
  337.                 /* FALLTHRU */
  338.             skip_init:
  339.             case 1:
  340.             case 2:        /* incompletely recovered error */
  341.                     /* try again... */
  342.                 $Perrflag = 3;
  343.                 /*
  344.                 ** find state where "error" is a legal
  345.                 ** shift action
  346.                 */
  347.                 while ( $P_ps >= $Ps )
  348.                 {
  349.                     $P_n = $Ppact[ *$P_ps ] + YYERRCODE;
  350.                     if ( $P_n >= 0 && $P_n < YYLAST &&
  351.                         $Pchk[$Pact[$P_n]] == YYERRCODE)                    {
  352.                         /*
  353.                         ** simulate shift of "error"
  354.                         */
  355.                         $P_state = $Pact[ $P_n ];
  356.                         goto $P_stack;
  357.                     }
  358.                     /*
  359.                     ** current state has no shift on
  360.                     ** "error", pop stack
  361.                     */
  362. #if YYDEBUG
  363. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  364.                     if ( $Pdebug )
  365.                         printf( _POP_, *$P_ps,
  366.                             $P_ps[-1] );
  367. #    undef _POP_
  368. #endif
  369.                     $P_ps--;
  370.                     $P_pv--;
  371.                 }
  372.                 /*
  373.                 ** there is no state on stack with "error" as
  374.                 ** a valid shift.  give up.
  375.                 */
  376.                 YYABORT;
  377.             case 3:        /* no shift yet; eat a token */
  378. #if YYDEBUG
  379.                 /*
  380.                 ** if debugging, look up token in list of
  381.                 ** pairs.  0 and negative shouldn't occur,
  382.                 ** but since timing doesn't matter when
  383.                 ** debugging, it doesn't hurt to leave the
  384.                 ** tests here.
  385.                 */
  386.                 if ( $Pdebug )
  387.                 {
  388.                     register int $P_i;
  389.  
  390.                     printf( "Error recovery discards " );
  391.                     if ( $Pchar == 0 )
  392.                         printf( "token end-of-file\n" );
  393.                     else if ( $Pchar < 0 )
  394.                         printf( "token -none-\n" );
  395.                     else
  396.                     {
  397.                         for ( $P_i = 0;
  398.                             $Ptoks[$P_i].t_val >= 0;
  399.                             $P_i++ )
  400.                         {
  401.                             if ( $Ptoks[$P_i].t_val
  402.                                 == $Pchar )
  403.                             {
  404.                                 break;
  405.                             }
  406.                         }
  407.                         printf( "token %s\n",
  408.                             $Ptoks[$P_i].t_name );
  409.                     }
  410.                 }
  411. #endif /* YYDEBUG */
  412.                 if ( $Pchar == 0 )    /* reached EOF. quit */
  413.                     YYABORT;
  414.                 $Pchar = -1;
  415.                 goto $P_newstate;
  416.             }
  417.         }/* end if ( $P_n == 0 ) */
  418.         /*
  419.         ** reduction by production $P_n
  420.         ** put stack tops, etc. so things right after switch
  421.         */
  422. #if YYDEBUG
  423.         /*
  424.         ** if debugging, print the string that is the user's
  425.         ** specification of the reduction which is just about
  426.         ** to be done.
  427.         */
  428.         if ( $Pdebug )
  429.             printf( "Reduce by (%d) \"%s\"\n",
  430.                 $P_n, $Preds[ $P_n ] );
  431. #endif
  432.         $Ptmp = $P_n;            /* value to switch over */
  433.         $Ppvt = $P_pv;            /* $vars top of value stack */
  434.         /*
  435.         ** Look in goto table for next state
  436.         ** Sorry about using $P_state here as temporary
  437.         ** register variable, but why not, if it works...
  438.         ** If $Pr2[ $P_n ] doesn't have the low order bit
  439.         ** set, then there is no action to be done for
  440.         ** this reduction.  So, no saving & unsaving of
  441.         ** registers done.  The only difference between the
  442.         ** code just after the if and the body of the if is
  443.         ** the goto $P_stack in the body.  This way the test
  444.         ** can be made before the choice of what to do is needed.
  445.         */
  446.         {
  447.             /* length of production doubled with extra bit */
  448.             register int $P_len = $Pr2[ $P_n ];
  449.  
  450.             if ( !( $P_len & 01 ) )
  451.             {
  452.                 $P_len >>= 1;
  453.                 $Pval = ( $P_pv -= $P_len )[1];    /* $$ = $1 */
  454.                 $P_state = $Ppgo[ $P_n = $Pr1[ $P_n ] ] +
  455.                     *( $P_ps -= $P_len ) + 1;
  456.                 if ( $P_state >= YYLAST ||
  457.                     $Pchk[ $P_state =
  458.                     $Pact[ $P_state ] ] != -$P_n )
  459.                 {
  460.                     $P_state = $Pact[ $Ppgo[ $P_n ] ];
  461.                 }
  462.                 goto $P_stack;
  463.             }
  464.             $P_len >>= 1;
  465.             $Pval = ( $P_pv -= $P_len )[1];    /* $$ = $1 */
  466.             $P_state = $Ppgo[ $P_n = $Pr1[ $P_n ] ] +
  467.                 *( $P_ps -= $P_len ) + 1;
  468.             if ( $P_state >= YYLAST ||
  469.                 $Pchk[ $P_state = $Pact[ $P_state ] ] != -$P_n )
  470.             {
  471.                 $P_state = $Pact[ $Ppgo[ $P_n ] ];
  472.             }
  473.         }
  474.                     /* save until reenter driver code */
  475.         $Pstate = $P_state;
  476.         $Pps = $P_ps;
  477.         $Ppv = $P_pv;
  478.     }
  479.     /*
  480.     ** code supplied by user is placed in this switch
  481.     */
  482.     switch( $Ptmp )
  483.     {
  484.         $A
  485.     }
  486.     goto $Pstack;        /* reset registers in driver code */
  487. }
  488.  
  489. #undef YYCONST
  490.