home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.2 (Developer) / NS_dev_3.2.iso / NextDeveloper / Source / GNU / cc / bison / bison.simple < prev    next >
Text File  |  1992-06-24  |  12KB  |  477 lines
  1. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  2. #line 3 "bison.simple"
  3.  
  4. /* Skeleton output parser for bison,
  5.    Copyright (C) 1984 Bob Corbett and Richard Stallman
  6.  
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 1, or (at your option)
  10.    any later version.
  11.  
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  23. #include <alloca.h>
  24. #endif
  25.  
  26. /* This is the parser code that is written into each bison parser
  27.   when the %semantic_parser declaration is not specified in the grammar.
  28.   It was written by Richard Stallman by simplifying the hairy parser
  29.   used when %semantic_parser is specified.  */
  30.  
  31. /* Note: there must be only one dollar sign in this file.
  32.    It is replaced by the list of actions, each action
  33.    as one case of the switch.  */
  34.  
  35. #define yyerrok        (yyerrstatus = 0)
  36. #define yyclearin    (yychar = YYEMPTY)
  37. #define YYEMPTY        -2
  38. #define YYEOF        0
  39. #define YYFAIL        goto yyerrlab;
  40. #define YYACCEPT    return(0)
  41. #define YYABORT     return(1)
  42. #define YYERROR        goto yyerrlab
  43.  
  44. #define YYTERROR    1
  45. #define YYERRCODE    256
  46.  
  47. #ifndef YYIMPURE
  48. #define YYLEX        yylex()
  49. #endif
  50.  
  51. #ifndef YYPURE
  52. #define YYLEX        yylex(&yylval, &yylloc)
  53. #endif
  54.  
  55. /* If nonreentrant, generate the variables here */
  56.  
  57. #ifndef YYIMPURE
  58.  
  59. int    yychar;            /*  the lookahead symbol        */
  60. YYSTYPE    yylval;            /*  the semantic value of the        */
  61.                 /*  lookahead symbol            */
  62.  
  63. YYLTYPE yylloc;            /*  location data for the lookahead    */
  64.                 /*  symbol                */
  65.  
  66. int yynerrs;            /*  number of parse errors so far       */
  67. #endif  /* YYIMPURE */
  68.  
  69. #if YYDEBUG != 0
  70. int yydebug;            /*  nonzero means print parse trace    */
  71. /* Since this is uninitialized, it does not stop multiple parsers
  72.    from coexisting.  */
  73. #endif
  74.  
  75. /*  YYMAXDEPTH indicates the initial size of the parser's stacks    */
  76.  
  77. #ifndef    YYMAXDEPTH
  78. #define YYMAXDEPTH 200
  79. #endif
  80.  
  81. /*  YYMAXLIMIT is the maximum size the stacks can grow to
  82.     (effective only if the built-in stack extension method is used).  */
  83.  
  84. #ifndef YYMAXLIMIT
  85. #define YYMAXLIMIT 10000
  86. #endif
  87.  
  88.  
  89. #line 90 "bison.simple"
  90. int
  91. yyparse()
  92. {
  93.   register int yystate;
  94.   register int yyn;
  95.   register short *yyssp;
  96.   register YYSTYPE *yyvsp;
  97.   YYLTYPE *yylsp;
  98.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  99.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  100.  
  101.   short    yyssa[YYMAXDEPTH];    /*  the state stack            */
  102.   YYSTYPE yyvsa[YYMAXDEPTH];    /*  the semantic value stack        */
  103.   YYLTYPE yylsa[YYMAXDEPTH];    /*  the location stack            */
  104.  
  105.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  106.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  107.   YYLTYPE *yyls = yylsa;
  108.  
  109.   int yymaxdepth = YYMAXDEPTH;
  110.  
  111. #ifndef YYPURE
  112.   int yychar;
  113.   YYSTYPE yylval;
  114.   YYLTYPE yylloc;
  115.   int yynerrs;
  116. #endif
  117.  
  118.   YYSTYPE yyval;        /*  the variable used to return        */
  119.                 /*  semantic values from the action    */
  120.                 /*  routines                */
  121.  
  122.   int yylen;
  123.  
  124. #if YYDEBUG != 0
  125.   if (yydebug)
  126.     fprintf(stderr, "Starting parse\n");
  127. #endif
  128.  
  129.   yystate = 0;
  130.   yyerrstatus = 0;
  131.   yynerrs = 0;
  132.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  133.  
  134.   /* Initialize stack pointers.
  135.      Waste one element of value and location stack
  136.      so that they stay on the same level as the state stack.  */
  137.  
  138.   yyssp = yyss - 1;
  139.   yyvsp = yyvs;
  140.   yylsp = yyls;
  141.  
  142. /* Push a new state, which is found in  yystate  .  */
  143. /* In all cases, when you get here, the value and location stacks
  144.    have just been pushed. so pushing a state here evens the stacks.  */
  145. yynewstate:
  146.  
  147.   *++yyssp = yystate;
  148.  
  149.   if (yyssp >= yyss + yymaxdepth - 1)
  150.     {
  151.       /* Give user a chance to reallocate the stack */
  152.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  153.       YYSTYPE *yyvs1 = yyvs;
  154.       YYLTYPE *yyls1 = yyls;
  155.       short *yyss1 = yyss;
  156.  
  157.       /* Get the current used size of the three stacks, in elements.  */
  158.       int size = yyssp - yyss + 1;
  159.  
  160. #ifdef yyoverflow
  161.       /* Each stack pointer address is followed by the size of
  162.      the data in use in that stack, in bytes.  */
  163.       yyoverflow("parser stack overflow",
  164.          &yyss1, size * sizeof (*yyssp),
  165.          &yyvs1, size * sizeof (*yyvsp),
  166.          &yyls1, size * sizeof (*yylsp),
  167.          &yymaxdepth);
  168.  
  169.       yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
  170. #else /* no yyoverflow */
  171.       /* Extend the stack our own way.  */
  172.       if (yymaxdepth >= YYMAXLIMIT)
  173.     yyerror("parser stack overflow");
  174.       yymaxdepth *= 2;
  175.       if (yymaxdepth > YYMAXLIMIT)
  176.     yymaxdepth = YYMAXLIMIT;
  177.       yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
  178.       bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  179.       yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
  180.       bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  181. #ifdef YYLSP_NEEDED
  182.       yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
  183.       bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  184. #endif
  185. #endif /* no yyoverflow */
  186.  
  187.       yyssp = yyss + size - 1;
  188.       yyvsp = yyvs + size - 1;
  189. #ifdef YYLSP_NEEDED
  190.       yylsp = yyls + size - 1;
  191. #endif
  192.  
  193. #if YYDEBUG != 0
  194.       if (yydebug)
  195.     fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
  196. #endif
  197.  
  198.       if (yyssp >= yyss + yymaxdepth - 1)
  199.     YYABORT;
  200.     }
  201.  
  202. #if YYDEBUG != 0
  203.   if (yydebug)
  204.     fprintf(stderr, "Entering state %d\n", yystate);
  205. #endif
  206.  
  207. /* Do appropriate processing given the current state.  */
  208. /* Read a lookahead token if we need one and don't already have one.  */
  209. yyresume:
  210.  
  211.   /* First try to decide what to do without reference to lookahead token.  */
  212.  
  213.   yyn = yypact[yystate];
  214.   if (yyn == YYFLAG)
  215.     goto yydefault;
  216.  
  217.   /* Not known => get a lookahead token if don't already have one.  */
  218.  
  219.   /* yychar is either YYEMPTY or YYEOF
  220.      or a valid token in external form.  */
  221.  
  222.   if (yychar == YYEMPTY)
  223.     {
  224. #if YYDEBUG != 0
  225.       if (yydebug)
  226.     fprintf(stderr, "Reading a token: ");
  227. #endif
  228.       yychar = YYLEX;
  229.     }
  230.  
  231.   /* Convert token to internal form (in yychar1) for indexing tables with */
  232.  
  233.   if (yychar <= 0)        /* This means end of input. */
  234.     {
  235.       yychar1 = 0;
  236.       yychar = YYEOF;        /* Don't call YYLEX any more */
  237.  
  238. #if YYDEBUG != 0
  239.       if (yydebug)
  240.     fprintf(stderr, "Now at end of input.\n");
  241. #endif
  242.     }
  243.   else
  244.     {
  245.       yychar1 = YYTRANSLATE(yychar);
  246.  
  247. #if YYDEBUG != 0
  248.       if (yydebug)
  249.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  250. #endif
  251.     }
  252.  
  253.   yyn += yychar1;
  254.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  255.     goto yydefault;
  256.  
  257.   yyn = yytable[yyn];
  258.  
  259.   /* yyn is what to do for this token type in this state.
  260.      Negative => reduce, -yyn is rule number.
  261.      Positive => shift, yyn is new state.
  262.        New state is final state => don't bother to shift,
  263.        just return success.
  264.      0, or most negative number => error.  */
  265.  
  266.   if (yyn < 0)
  267.     {
  268.       if (yyn == YYFLAG)
  269.     goto yyerrlab;
  270.       yyn = -yyn;
  271.       goto yyreduce;
  272.     }
  273.   else if (yyn == 0)
  274.     goto yyerrlab;
  275.  
  276.   if (yyn == YYFINAL)
  277.     YYACCEPT;
  278.  
  279.   /* Shift the lookahead token.  */
  280.  
  281. #if YYDEBUG != 0
  282.   if (yydebug)
  283.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  284. #endif
  285.  
  286.   /* Discard the token being shifted unless it is eof.  */
  287.   if (yychar != YYEOF)
  288.     yychar = YYEMPTY;
  289.  
  290.   *++yyvsp = yylval;
  291. #ifdef YYLSP_NEEDED
  292.   *++yylsp = yylloc;
  293. #endif
  294.  
  295.   /* count tokens shifted since error; after three, turn off error status.  */
  296.   if (yyerrstatus) yyerrstatus--;
  297.  
  298.   yystate = yyn;
  299.   goto yynewstate;
  300.  
  301. /* Do the default action for the current state.  */
  302. yydefault:
  303.  
  304.   yyn = yydefact[yystate];
  305.   if (yyn == 0)
  306.     goto yyerrlab;
  307.  
  308. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  309. yyreduce:
  310.   yylen = yyr2[yyn];
  311.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  312.  
  313. #if YYDEBUG != 0
  314.   if (yydebug)
  315.     {
  316.       if (yylen == 1)
  317.     fprintf (stderr, "Reducing 1 value via line %d, ",
  318.          yyrline[yyn]);
  319.       else
  320.     fprintf (stderr, "Reducing %d values via line %d, ",
  321.          yylen, yyrline[yyn]);
  322.     }
  323. #endif
  324.  
  325. $   /* the action file gets copied in in place of this dollarsign */
  326. #line 327 "bison.simple"
  327.  
  328.   yyvsp -= yylen;
  329.   yyssp -= yylen;
  330. #ifdef YYLSP_NEEDED
  331.   yylsp -= yylen;
  332. #endif
  333.  
  334. #if YYDEBUG != 0
  335.   if (yydebug)
  336.     {
  337.       short *ssp1 = yyss - 1;
  338.       fprintf (stderr, "state stack now");
  339.       while (ssp1 != yyssp)
  340.     fprintf (stderr, " %d", *++ssp1);
  341.       fprintf (stderr, "\n");
  342.     }
  343. #endif
  344.  
  345.   *++yyvsp = yyval;
  346.  
  347. #ifdef YYLSP_NEEDED
  348.   yylsp++;
  349.   if (yylen == 0)
  350.     {
  351.       yylsp->first_line = yylloc.first_line;
  352.       yylsp->first_column = yylloc.first_column;
  353.       yylsp->last_line = (yylsp-1)->last_line;
  354.       yylsp->last_column = (yylsp-1)->last_column;
  355.       yylsp->text = 0;
  356.     }
  357.   else
  358.     {
  359.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  360.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  361.     }
  362. #endif
  363.  
  364.   /* Now "shift" the result of the reduction.
  365.      Determine what state that goes to,
  366.      based on the state we popped back to
  367.      and the rule number reduced by.  */
  368.  
  369.   yyn = yyr1[yyn];
  370.  
  371.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  372.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  373.     yystate = yytable[yystate];
  374.   else
  375.     yystate = yydefgoto[yyn - YYNTBASE];
  376.  
  377.   goto yynewstate;
  378.  
  379. yyerrlab:   /* here on detecting error */
  380.  
  381.   if (! yyerrstatus)
  382.     /* If not already recovering from an error, report this error.  */
  383.     {
  384.       ++yynerrs;
  385.       yyerror("parse error");
  386.     }
  387.  
  388.   if (yyerrstatus == 3)
  389.     {
  390.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  391.  
  392.       /* return failure if at end of input */
  393.       if (yychar == YYEOF)
  394.     YYABORT;
  395.  
  396. #if YYDEBUG != 0
  397.       if (yydebug)
  398.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  399. #endif
  400.  
  401.       yychar = YYEMPTY;
  402.     }
  403.  
  404.   /* Else will try to reuse lookahead token
  405.      after shifting the error token.  */
  406.  
  407.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  408.  
  409.   goto yyerrhandle;
  410.  
  411. yyerrdefault:  /* current state does not do anything special for the error token. */
  412.  
  413. #if 0
  414.   /* This is wrong; only states that explicitly want error tokens
  415.      should shift them.  */
  416.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  417.   if (yyn) goto yydefault;
  418. #endif
  419.  
  420. yyerrpop:   /* pop the current state because it cannot handle the error token */
  421.  
  422.   if (yyssp == yyss) YYABORT;
  423.   yyvsp--;
  424.   yystate = *--yyssp;
  425. #ifdef YYLSP_NEEDED
  426.   yylsp--;
  427. #endif
  428.  
  429. #if YYDEBUG != 0
  430.   if (yydebug)
  431.     {
  432.       short *ssp1 = yyss - 1;
  433.       fprintf (stderr, "Error: state stack now");
  434.       while (ssp1 != yyssp)
  435.     fprintf (stderr, " %d", *++ssp1);
  436.       fprintf (stderr, "\n");
  437.     }
  438. #endif
  439.  
  440. yyerrhandle:
  441.  
  442.   yyn = yypact[yystate];
  443.   if (yyn == YYFLAG)
  444.     goto yyerrdefault;
  445.  
  446.   yyn += YYTERROR;
  447.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  448.     goto yyerrdefault;
  449.  
  450.   yyn = yytable[yyn];
  451.   if (yyn < 0)
  452.     {
  453.       if (yyn == YYFLAG)
  454.     goto yyerrpop;
  455.       yyn = -yyn;
  456.       goto yyreduce;
  457.     }
  458.   else if (yyn == 0)
  459.     goto yyerrpop;
  460.  
  461.   if (yyn == YYFINAL)
  462.     YYACCEPT;
  463.  
  464. #if YYDEBUG != 0
  465.   if (yydebug)
  466.     fprintf(stderr, "Shifting error token, ");
  467. #endif
  468.  
  469.   *++yyvsp = yylval;
  470. #ifdef YYLSP_NEEDED
  471.   *++yylsp = yylloc;
  472. #endif
  473.  
  474.   yystate = yyn;
  475.   goto yynewstate;
  476. }
  477.