lincity: intl/plural.c File Reference

00549 {
00550   register int yystate;
00551   register int yyn;
00552   register short *yyssp;
00553   register YYSTYPE *yyvsp;
00554   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
00555   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
00556 
00557   short yyssa[YYINITDEPTH];     /*  the state stack                     */
00558   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
00559 
00560   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
00561   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
00562 
00563 #ifdef YYLSP_NEEDED
00564   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
00565   YYLTYPE *yyls = yylsa;
00566   YYLTYPE *yylsp;
00567 
00568 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
00569 #else
00570 #define YYPOPSTACK   (yyvsp--, yyssp--)
00571 #endif
00572 
00573   int yystacksize = YYINITDEPTH;
00574   int yyfree_stacks = 0;
00575 
00576 #ifdef YYPURE
00577   int yychar;
00578   YYSTYPE yylval;
00579   int yynerrs;
00580 #ifdef YYLSP_NEEDED
00581   YYLTYPE yylloc;
00582 #endif
00583 #endif
00584 
00585   YYSTYPE yyval;                /*  the variable used to return         */
00586                                 /*  semantic values from the action     */
00587                                 /*  routines                            */
00588 
00589   int yylen;
00590 
00591 #if YYDEBUG != 0
00592   if (yydebug)
00593     fprintf(stderr, "Starting parse\n");
00594 #endif
00595 
00596   yystate = 0;
00597   yyerrstatus = 0;
00598   yynerrs = 0;
00599   yychar = YYEMPTY;             /* Cause a token to be read.  */
00600 
00601   /* Initialize stack pointers.
00602      Waste one element of value and location stack
00603      so that they stay on the same level as the state stack.
00604      The wasted elements are never initialized.  */
00605 
00606   yyssp = yyss - 1;
00607   yyvsp = yyvs;
00608 #ifdef YYLSP_NEEDED
00609   yylsp = yyls;
00610 #endif
00611 
00612 /* Push a new state, which is found in  yystate  .  */
00613 /* In all cases, when you get here, the value and location stacks
00614    have just been pushed. so pushing a state here evens the stacks.  */
00615 yynewstate:
00616 
00617   *++yyssp = yystate;
00618 
00619   if (yyssp >= yyss + yystacksize - 1)
00620     {
00621       /* Give user a chance to reallocate the stack */
00622       /* Use copies of these so that the &'s don't force the real ones into memory. */
00623       YYSTYPE *yyvs1 = yyvs;
00624       short *yyss1 = yyss;
00625 #ifdef YYLSP_NEEDED
00626       YYLTYPE *yyls1 = yyls;
00627 #endif
00628 
00629       /* Get the current used size of the three stacks, in elements.  */
00630       int size = yyssp - yyss + 1;
00631 
00632 #ifdef yyoverflow
00633       /* Each stack pointer address is followed by the size of
00634          the data in use in that stack, in bytes.  */
00635 #ifdef YYLSP_NEEDED
00636       /* This used to be a conditional around just the two extra args,
00637          but that might be undefined if yyoverflow is a macro.  */
00638       yyoverflow("parser stack overflow",
00639                  &yyss1, size * sizeof (*yyssp),
00640                  &yyvs1, size * sizeof (*yyvsp),
00641                  &yyls1, size * sizeof (*yylsp),
00642                  &yystacksize);
00643 #else
00644       yyoverflow("parser stack overflow",
00645                  &yyss1, size * sizeof (*yyssp),
00646                  &yyvs1, size * sizeof (*yyvsp),
00647                  &yystacksize);
00648 #endif
00649 
00650       yyss = yyss1; yyvs = yyvs1;
00651 #ifdef YYLSP_NEEDED
00652       yyls = yyls1;
00653 #endif
00654 #else /* no yyoverflow */
00655       /* Extend the stack our own way.  */
00656       if (yystacksize >= YYMAXDEPTH)
00657         {
00658           yyerror("parser stack overflow");
00659           if (yyfree_stacks)
00660             {
00661               free (yyss);
00662               free (yyvs);
00663 #ifdef YYLSP_NEEDED
00664               free (yyls);
00665 #endif
00666             }
00667           return 2;
00668         }
00669       yystacksize *= 2;
00670       if (yystacksize > YYMAXDEPTH)
00671         yystacksize = YYMAXDEPTH;
00672 #ifndef YYSTACK_USE_ALLOCA
00673       yyfree_stacks = 1;
00674 #endif
00675       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
00676       __yy_memcpy ((char *)yyss, (char *)yyss1,
00677                    size * (unsigned int) sizeof (*yyssp));
00678       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
00679       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
00680                    size * (unsigned int) sizeof (*yyvsp));
00681 #ifdef YYLSP_NEEDED
00682       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
00683       __yy_memcpy ((char *)yyls, (char *)yyls1,
00684                    size * (unsigned int) sizeof (*yylsp));
00685 #endif
00686 #endif /* no yyoverflow */
00687 
00688       yyssp = yyss + size - 1;
00689       yyvsp = yyvs + size - 1;
00690 #ifdef YYLSP_NEEDED
00691       yylsp = yyls + size - 1;
00692 #endif
00693 
00694 #if YYDEBUG != 0
00695       if (yydebug)
00696         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
00697 #endif
00698 
00699       if (yyssp >= yyss + yystacksize - 1)
00700         YYABORT;
00701     }
00702 
00703 #if YYDEBUG != 0
00704   if (yydebug)
00705     fprintf(stderr, "Entering state %d\n", yystate);
00706 #endif
00707 
00708   goto yybackup;
00709  yybackup:
00710 
00711 /* Do appropriate processing given the current state.  */
00712 /* Read a lookahead token if we need one and don't already have one.  */
00713 /* yyresume: */
00714 
00715   /* First try to decide what to do without reference to lookahead token.  */
00716 
00717   yyn = yypact[yystate];
00718   if (yyn == YYFLAG)
00719     goto yydefault;
00720 
00721   /* Not known => get a lookahead token if don't already have one.  */
00722 
00723   /* yychar is either YYEMPTY or YYEOF
00724      or a valid token in external form.  */
00725 
00726   if (yychar == YYEMPTY)
00727     {
00728 #if YYDEBUG != 0
00729       if (yydebug)
00730         fprintf(stderr, "Reading a token: ");
00731 #endif
00732       yychar = YYLEX;
00733     }
00734 
00735   /* Convert token to internal form (in yychar1) for indexing tables with */
00736 
00737   if (yychar <= 0)              /* This means end of input. */
00738     {
00739       yychar1 = 0;
00740       yychar = YYEOF;           /* Don't call YYLEX any more */
00741 
00742 #if YYDEBUG != 0
00743       if (yydebug)
00744         fprintf(stderr, "Now at end of input.\n");
00745 #endif
00746     }
00747   else
00748     {
00749       yychar1 = YYTRANSLATE(yychar);
00750 
00751 #if YYDEBUG != 0
00752       if (yydebug)
00753         {
00754           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
00755           /* Give the individual parser a way to print the precise meaning
00756              of a token, for further debugging info.  */
00757 #ifdef YYPRINT
00758           YYPRINT (stderr, yychar, yylval);
00759 #endif
00760           fprintf (stderr, ")\n");
00761         }
00762 #endif
00763     }
00764 
00765   yyn += yychar1;
00766   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
00767     goto yydefault;
00768 
00769   yyn = yytable[yyn];
00770 
00771   /* yyn is what to do for this token type in this state.
00772      Negative => reduce, -yyn is rule number.
00773      Positive => shift, yyn is new state.
00774        New state is final state => don't bother to shift,
00775        just return success.
00776      0, or most negative number => error.  */
00777 
00778   if (yyn < 0)
00779     {
00780       if (yyn == YYFLAG)
00781         goto yyerrlab;
00782       yyn = -yyn;
00783       goto yyreduce;
00784     }
00785   else if (yyn == 0)
00786     goto yyerrlab;
00787 
00788   if (yyn == YYFINAL)
00789     YYACCEPT;
00790 
00791   /* Shift the lookahead token.  */
00792 
00793 #if YYDEBUG != 0
00794   if (yydebug)
00795     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
00796 #endif
00797 
00798   /* Discard the token being shifted unless it is eof.  */
00799   if (yychar != YYEOF)
00800     yychar = YYEMPTY;
00801 
00802   *++yyvsp = yylval;
00803 #ifdef YYLSP_NEEDED
00804   *++yylsp = yylloc;
00805 #endif
00806 
00807   /* count tokens shifted since error; after three, turn off error status.  */
00808   if (yyerrstatus) yyerrstatus--;
00809 
00810   yystate = yyn;
00811   goto yynewstate;
00812 
00813 /* Do the default action for the current state.  */
00814 yydefault:
00815 
00816   yyn = yydefact[yystate];
00817   if (yyn == 0)
00818     goto yyerrlab;
00819 
00820 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
00821 yyreduce:
00822   yylen = yyr2[yyn];
00823   if (yylen > 0)
00824     yyval = yyvsp[1-yylen]; /* implement default value of the action */
00825 
00826 #if YYDEBUG != 0
00827   if (yydebug)
00828     {
00829       int i;
00830 
00831       fprintf (stderr, "Reducing via rule %d (line %d), ",
00832                yyn, yyrline[yyn]);
00833 
00834       /* Print the symbols being reduced, and their result.  */
00835       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
00836         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
00837       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
00838     }
00839 #endif
00840 
00841 
00842   switch (yyn) {
00843 
00844 case 1:
00845 #line 175 "plural.y"
00846 {
00847             if (yyvsp[0].exp == NULL)
00848               YYABORT;
00849             ((struct parse_args *) arg)->res = yyvsp[0].exp;
00850           ;
00851     break;}
00852 case 2:
00853 #line 183 "plural.y"
00854 {
00855             yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
00856           ;
00857     break;}
00858 case 3:
00859 #line 187 "plural.y"
00860 {
00861             yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
00862           ;
00863     break;}
00864 case 4:
00865 #line 191 "plural.y"
00866 {
00867             yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
00868           ;
00869     break;}
00870 case 5:
00871 #line 195 "plural.y"
00872 {
00873             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
00874           ;
00875     break;}
00876 case 6:
00877 #line 199 "plural.y"
00878 {
00879             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
00880           ;
00881     break;}
00882 case 7:
00883 #line 203 "plural.y"
00884 {
00885             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
00886           ;
00887     break;}
00888 case 8:
00889 #line 207 "plural.y"
00890 {
00891             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
00892           ;
00893     break;}
00894 case 9:
00895 #line 211 "plural.y"
00896 {
00897             yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
00898           ;
00899     break;}
00900 case 10:
00901 #line 215 "plural.y"
00902 {
00903             yyval.exp = new_exp_0 (var);
00904           ;
00905     break;}
00906 case 11:
00907 #line 219 "plural.y"
00908 {
00909             if ((yyval.exp = new_exp_0 (num)) != NULL)
00910               yyval.exp->val.num = yyvsp[0].num;
00911           ;
00912     break;}
00913 case 12:
00914 #line 224 "plural.y"
00915 {
00916             yyval.exp = yyvsp[-1].exp;
00917           ;
00918     break;}
00919 }
00920    /* the action file gets copied in in place of this dollarsign */
00921 #line 543 "/usr/local/share/bison.simple"
00922 
00923   yyvsp -= yylen;
00924   yyssp -= yylen;
00925 #ifdef YYLSP_NEEDED
00926   yylsp -= yylen;
00927 #endif
00928 
00929 #if YYDEBUG != 0
00930   if (yydebug)
00931     {
00932       short *ssp1 = yyss - 1;
00933       fprintf (stderr, "state stack now");
00934       while (ssp1 != yyssp)
00935         fprintf (stderr, " %d", *++ssp1);
00936       fprintf (stderr, "\n");
00937     }
00938 #endif
00939 
00940   *++yyvsp = yyval;
00941 
00942 #ifdef YYLSP_NEEDED
00943   yylsp++;
00944   if (yylen == 0)
00945     {
00946       yylsp->first_line = yylloc.first_line;
00947       yylsp->first_column = yylloc.first_column;
00948       yylsp->last_line = (yylsp-1)->last_line;
00949       yylsp->last_column = (yylsp-1)->last_column;
00950       yylsp->text = 0;
00951     }
00952   else
00953     {
00954       yylsp->last_line = (yylsp+yylen-1)->last_line;
00955       yylsp->last_column = (yylsp+yylen-1)->last_column;
00956     }
00957 #endif
00958 
00959   /* Now "shift" the result of the reduction.
00960      Determine what state that goes to,
00961      based on the state we popped back to
00962      and the rule number reduced by.  */
00963 
00964   yyn = yyr1[yyn];
00965 
00966   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
00967   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
00968     yystate = yytable[yystate];
00969   else
00970     yystate = yydefgoto[yyn - YYNTBASE];
00971 
00972   goto yynewstate;
00973 
00974 yyerrlab:   /* here on detecting error */
00975 
00976   if (! yyerrstatus)
00977     /* If not already recovering from an error, report this error.  */
00978     {
00979       ++yynerrs;
00980 
00981 #ifdef YYERROR_VERBOSE
00982       yyn = yypact[yystate];
00983 
00984       if (yyn > YYFLAG && yyn < YYLAST)
00985         {
00986           int size = 0;
00987           char *msg;
00988           int x, count;
00989 
00990           count = 0;
00991           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
00992           for (x = (yyn < 0 ? -yyn : 0);
00993                x < (sizeof(yytname) / sizeof(char *)); x++)
00994             if (yycheck[x + yyn] == x)
00995               size += strlen(yytname[x]) + 15, count++;
00996           msg = (char *) malloc(size + 15);
00997           if (msg != 0)
00998             {
00999               strcpy(msg, "parse error");
01000 
01001               if (count < 5)
01002                 {
01003                   count = 0;
01004                   for (x = (yyn < 0 ? -yyn : 0);
01005                        x < (sizeof(yytname) / sizeof(char *)); x++)
01006                     if (yycheck[x + yyn] == x)
01007                       {
01008                         strcat(msg, count == 0 ? ", expecting `" : " or `");
01009                         strcat(msg, yytname[x]);
01010                         strcat(msg, "'");
01011                         count++;
01012                       }
01013                 }
01014               yyerror(msg);
01015               free(msg);
01016             }
01017           else
01018             yyerror ("parse error; also virtual memory exceeded");
01019         }
01020       else
01021 #endif /* YYERROR_VERBOSE */
01022         yyerror("parse error");
01023     }
01024 
01025   goto yyerrlab1;
01026 yyerrlab1:   /* here on error raised explicitly by an action */
01027 
01028   if (yyerrstatus == 3)
01029     {
01030       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
01031 
01032       /* return failure if at end of input */
01033       if (yychar == YYEOF)
01034         YYABORT;
01035 
01036 #if YYDEBUG != 0
01037       if (yydebug)
01038         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
01039 #endif
01040 
01041       yychar = YYEMPTY;
01042     }
01043 
01044   /* Else will try to reuse lookahead token
01045      after shifting the error token.  */
01046 
01047   yyerrstatus = 3;              /* Each real token shifted decrements this */
01048 
01049   goto yyerrhandle;
01050 
01051 yyerrdefault:  /* current state does not do anything special for the error token. */
01052 
01053 #if 0
01054   /* This is wrong; only states that explicitly want error tokens
01055      should shift them.  */
01056   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
01057   if (yyn) goto yydefault;
01058 #endif
01059 
01060 yyerrpop:   /* pop the current state because it cannot handle the error token */
01061 
01062   if (yyssp == yyss) YYABORT;
01063   yyvsp--;
01064   yystate = *--yyssp;
01065 #ifdef YYLSP_NEEDED
01066   yylsp--;
01067 #endif
01068 
01069 #if YYDEBUG != 0
01070   if (yydebug)
01071     {
01072       short *ssp1 = yyss - 1;
01073       fprintf (stderr, "Error: state stack now");
01074       while (ssp1 != yyssp)
01075         fprintf (stderr, " %d", *++ssp1);
01076       fprintf (stderr, "\n");
01077     }
01078 #endif
01079 
01080 yyerrhandle:
01081 
01082   yyn = yypact[yystate];
01083   if (yyn == YYFLAG)
01084     goto yyerrdefault;
01085 
01086   yyn += YYTERROR;
01087   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
01088     goto yyerrdefault;
01089 
01090   yyn = yytable[yyn];
01091   if (yyn < 0)
01092     {
01093       if (yyn == YYFLAG)
01094         goto yyerrpop;
01095       yyn = -yyn;
01096       goto yyreduce;
01097     }
01098   else if (yyn == 0)
01099     goto yyerrpop;
01100 
01101   if (yyn == YYFINAL)
01102     YYACCEPT;
01103 
01104 #if YYDEBUG != 0
01105   if (yydebug)
01106     fprintf(stderr, "Shifting error token, ");
01107 #endif
01108 
01109   *++yyvsp = yylval;
01110 #ifdef YYLSP_NEEDED
01111   *++yylsp = yylloc;
01112 #endif
01113 
01114   yystate = yyn;
01115   goto yynewstate;
01116 
01117  yyacceptlab:
01118   /* YYACCEPT comes here.  */
01119   if (yyfree_stacks)
01120     {
01121       free (yyss);
01122       free (yyvs);
01123 #ifdef YYLSP_NEEDED
01124       free (yyls);
01125 #endif
01126     }
01127   return 0;
01128 
01129  yyabortlab:
01130   /* YYABORT comes here.  */
01131   if (yyfree_stacks)
01132     {
01133       free (yyss);
01134       free (yyvs);
01135 #ifdef YYLSP_NEEDED
01136       free (yyls);
01137 #endif
01138     }
01139   return 1;
01140 }


Data Structures
union	YYSTYPE
Defines
#define	YYBISON 1
#define	yyparse __gettextparse
#define	yylex __gettextlex
#define	yyerror __gettexterror
#define	yylval __gettextlval
#define	yychar __gettextchar
#define	yydebug __gettextdebug
#define	yynerrs __gettextnerrs
#define	EQUOP2 257
#define	CMPOP2 258
#define	ADDOP2 259
#define	MULOP2 260
#define	NUMBER 261
#define	__gettextparse PLURAL_PARSE
#define	YYLEX_PARAM &((struct parse_args *) arg)->cp
#define	YYPARSE_PARAM arg
#define	const
#define	YYFINAL 27
#define	YYFLAG -32768
#define	YYNTBASE 16
#define	YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
#define	YYLAST 53
#define	YYPURE 1
#define	YYSTACK_ALLOC malloc
#define	yyerrok (yyerrstatus = 0)
#define	yyclearin (yychar = YYEMPTY)
#define	YYEMPTY -2
#define	YYEOF 0
#define	YYACCEPT goto yyacceptlab
#define	YYABORT goto yyabortlab
#define	YYERROR goto yyerrlab1
#define	YYFAIL goto yyerrlab
#define	YYRECOVERING() (!!yyerrstatus)
#define	YYBACKUP(token, value)
#define	YYTERROR 1
#define	YYERRCODE 256
#define	YYLEX yylex(&yylval, YYLEX_PARAM)
#define	YYINITDEPTH 200
#define	YYMAXDEPTH 10000
#define	YYPARSE_PARAM_ARG YYPARSE_PARAM
#define	YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#define	YYPOPSTACK (yyvsp--, yyssp--)
Functions
expression *new_exp	PARAMS ((int nargs, enum operator op, struct expression const args))
expression *new_exp_0	PARAMS ((enum operator op))
expression *new_exp_1	PARAMS ((enum operator op, struct expression *right))
expression *new_exp_2	PARAMS ((enum operator op, struct expression left, struct expression right))
expression *new_exp_3	PARAMS ((enum operator op, struct expression bexp, struct expression tbranch, struct expression *fbranch))
int yylex	PARAMS ((YYSTYPE lval, const char *pexp))
void yyerror	PARAMS ((const char *str))
expression *	new_exp (int nargs, enum operator op, struct expression const args)
expression *	new_exp_0 (enum operator op)
expression *	new_exp_1 (enum operator op, struct expression *right)
expression *	new_exp_2 (enum operator op, struct expression left, struct expression right)
expression *	new_exp_3 (enum operator op, struct expression bexp, struct expression tbranch, struct expression *fbranch)
void	__yy_memcpy (char to, char from, unsigned int count)
int	yyparse (YYPARSE_PARAM_ARG)
Variables
const char	yytranslate []
const short	yyr1 []
const short	yyr2 []
const short	yydefact []
const short	yydefgoto []
const short	yypact []
const short	yypgoto []
const short	yytable []
const short	yycheck []
void internal_function struct expression *	exp
const char **	pexp

plural.c File Reference

Data Structures

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation