1: %{
    2: /* Expression parsing for plural form selection.
    3:    Copyright (C) 2000, 2001 Free Software Foundation, Inc.
    4:    This file is part of the GNU C Library.
    5:    Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
    6: 
    7:    The GNU C Library is free software; you can redistribute it and/or
    8:    modify it under the terms of the GNU Lesser General Public
    9:    License as published by the Free Software Foundation; either
   10:    version 2.1 of the License, or (at your option) any later version.
   11: 
   12:    The GNU C Library 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 GNU
   15:    Lesser General Public License for more details.
   16: 
   17:    You should have received a copy of the GNU Lesser General Public
   18:    License along with the GNU C Library; if not, write to the Free
   19:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   20:    02111-1307 USA.  */
   21: 
   22: /* The bison generated parser uses alloca.  AIX 3 forces us to put this
   23:    declaration at the beginning of the file.  The declaration in bison's
   24:    skeleton file comes too late.  This must come before <config.h>
   25:    because <config.h> may include arbitrary system headers.  */
   26: #if defined _AIX && !defined __GNUC__
   27:  #pragma alloca
   28: #endif
   29: #ifdef HAVE_CONFIG_H
   30: # include <config.h>
   31: #endif
   32: 
   33: #include <stddef.h>
   34: #include <stdlib.h>
   35: #include <string.h>
   36: #include "plural-exp.h"
   37: 
   38: /* The main function generated by the parser is called __gettextparse,
   39:    but we want it to be called PLURAL_PARSE.  */
   40: #ifndef _LIBC
   41: # define __gettextparse PLURAL_PARSE
   42: #endif
   43: 
   44: #define YYLEX_PARAM     &((struct parse_args *) arg)->cp
   45: #define YYPARSE_PARAM   arg
   46: %}
   47: %pure_parser
   48: %expect 7
   49: 
   50: %union {
   51:   unsigned long int num;
   52:   enum operator op;
   53:   struct expression *exp;
   54: }
   55: 
   56: %{
   57: /* Prototypes for local functions.  */
   58: static struct expression *new_exp PARAMS ((int nargs, enum operator op,
   59:                                            struct expression * const *args));
   60: static inline struct expression *new_exp_0 PARAMS ((enum operator op));
   61: static inline struct expression *new_exp_1 PARAMS ((enum operator op,
   62:                                                    struct expression *right));
   63: static struct expression *new_exp_2 PARAMS ((enum operator op,
   64:                                              struct expression *left,
   65:                                              struct expression *right));
   66: static inline struct expression *new_exp_3 PARAMS ((enum operator op,
   67:                                                    struct expression *bexp,
   68:                                                    struct expression *tbranch,
   69:                                                    struct expression *fbranch));
   70: static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
   71: static void yyerror PARAMS ((const char *str));
   72: 
   73: /* Allocation of expressions.  */
   74: 
   75: static struct expression *
   76: new_exp (nargs, op, args)
   77:      int nargs;
   78:      enum operator op;
   79:      struct expression * const *args;
   80: {
   81:   int i;
   82:   struct expression *newp;
   83: 
   84:   /* If any of the argument could not be malloc'ed, just return NULL.  */
   85:   for (i = nargs - 1; i >= 0; i--)
   86:     if (args[i] == NULL)
   87:       goto fail;
   88: 
   89:   /* Allocate a new expression.  */
   90:   newp = (struct expression *) malloc (sizeof (*newp));
   91:   if (newp != NULL)
   92:     {
   93:       newp->nargs = nargs;
   94:       newp->operation = op;
   95:       for (i = nargs - 1; i >= 0; i--)
   96:         newp->val.args[i] = args[i];
   97:       return newp;
   98:     }
   99: 
  100:  fail:
  101:   for (i = nargs - 1; i >= 0; i--)
  102:     FREE_EXPRESSION (args[i]);
  103: 
  104:   return NULL;
  105: }
  106: 
  107: static inline struct expression *
  108: new_exp_0 (op)
  109:      enum operator op;
  110: {
  111:   return new_exp (0, op, NULL);
  112: }
  113: 
  114: static inline struct expression *
  115: new_exp_1 (op, right)
  116:      enum operator op;
  117:      struct expression *right;
  118: {
  119:   struct expression *args[1];
  120: 
  121:   args[0] = right;
  122:   return new_exp (1, op, args);
  123: }
  124: 
  125: static struct expression *
  126: new_exp_2 (op, left, right)
  127:      enum operator op;
  128:      struct expression *left;
  129:      struct expression *right;
  130: {
  131:   struct expression *args[2];
  132: 
  133:   args[0] = left;
  134:   args[1] = right;
  135:   return new_exp (2, op, args);
  136: }
  137: 
  138: static inline struct expression *
  139: new_exp_3 (op, bexp, tbranch, fbranch)
  140:      enum operator op;
  141:      struct expression *bexp;
  142:      struct expression *tbranch;
  143:      struct expression *fbranch;
  144: {
  145:   struct expression *args[3];
  146: 
  147:   args[0] = bexp;
  148:   args[1] = tbranch;
  149:   args[2] = fbranch;
  150:   return new_exp (3, op, args);
  151: }
  152: 
  153: %}
  154: 
  155: /* This declares that all operators have the same associativity and the
  156:    precedence order as in C.  See [Harbison, Steele: C, A Reference Manual].
  157:    There is no unary minus and no bitwise operators.
  158:    Operators with the same syntactic behaviour have been merged into a single
  159:    token, to save space in the array generated by bison.  */
  160: %right '?'              /*   ?              */
  161: %left '|'               /*   ||              */
  162: %left '&'               /*   &&              */
  163: %left EQUOP2            /*   == !=        */
  164: %left CMPOP2            /*   < > <= >=    */
  165: %left ADDOP2            /*   + -  */
  166: %left MULOP2            /*   * / %        */
  167: %right '!'              /*   !              */
  168: 
  169: %token <op> EQUOP2 CMPOP2 ADDOP2 MULOP2
  170: %token <num> NUMBER
  171: %type <exp> exp
  172: 
  173: %%
  174: 
  175: start:    exp
  176:           {
  177:             if ($1 == NULL)
  178:               YYABORT;
  179:             ((struct parse_args *) arg)->res = $1;
  180:           }
  181:         ;
  182: 
  183: exp:      exp '?' exp ':' exp
  184:           {
  185:             $$ = new_exp_3 (qmop, $1, $3, $5);
  186:           }
  187:         | exp '|' exp
  188:           {
  189:             $$ = new_exp_2 (lor, $1, $3);
  190:           }
  191:         | exp '&' exp
  192:           {
  193:             $$ = new_exp_2 (land, $1, $3);
  194:           }
  195:         | exp EQUOP2 exp
  196:           {
  197:             $$ = new_exp_2 ($2, $1, $3);
  198:           }
  199:         | exp CMPOP2 exp
  200:           {
  201:             $$ = new_exp_2 ($2, $1, $3);
  202:           }
  203:         | exp ADDOP2 exp
  204:           {
  205:             $$ = new_exp_2 ($2, $1, $3);
  206:           }
  207:         | exp MULOP2 exp
  208:           {
  209:             $$ = new_exp_2 ($2, $1, $3);
  210:           }
  211:         | '!' exp
  212:           {
  213:             $$ = new_exp_1 (lnot, $2);
  214:           }
  215:         | 'n'
  216:           {
  217:             $$ = new_exp_0 (var);
  218:           }
  219:         | NUMBER
  220:           {
  221:             if (($$ = new_exp_0 (num)) != NULL)
  222:               $$->val.num = $1;
  223:           }
  224:         | '(' exp ')'
  225:           {
  226:             $$ = $2;
  227:           }
  228:         ;
  229: 
  230: %%
  231: 
  232: void
  233: internal_function
  234: FREE_EXPRESSION (exp)
  235:      struct expression *exp;
  236: {
  237:   if (exp == NULL)
  238:     return;
  239: 
  240:   /* Handle the recursive case.  */
  241:   switch (exp->nargs)
  242:     {
  243:     case 3:
  244:       FREE_EXPRESSION (exp->val.args[2]);
  245:       /* FALLTHROUGH */
  246:     case 2:
  247:       FREE_EXPRESSION (exp->val.args[1]);
  248:       /* FALLTHROUGH */
  249:     case 1:
  250:       FREE_EXPRESSION (exp->val.args[0]);
  251:       /* FALLTHROUGH */
  252:     default:
  253:       break;
  254:     }
  255: 
  256:   free (exp);
  257: }
  258: 
  259: 
  260: static int
  261: yylex (lval, pexp)
  262:      YYSTYPE *lval;
  263:      const char **pexp;
  264: {
  265:   const char *exp = *pexp;
  266:   int result;
  267: 
  268:   while (1)
  269:     {
  270:       if (exp[0] == '\0')
  271:         {
  272:           *pexp = exp;
  273:           return YYEOF;
  274:         }
  275: 
  276:       if (exp[0] != ' ' && exp[0] != '\t')
  277:         break;
  278: 
  279:       ++exp;
  280:     }
  281: 
  282:   result = *exp++;
  283:   switch (result)
  284:     {
  285:     case '0': case '1': case '2': case '3': case '4':
  286:     case '5': case '6': case '7': case '8': case '9':
  287:       {
  288:         unsigned long int n = result - '0';
  289:         while (exp[0] >= '0' && exp[0] <= '9')
  290:           {
  291:             n *= 10;
  292:             n += exp[0] - '0';
  293:             ++exp;
  294:           }
  295:         lval->num = n;
  296:         result = NUMBER;
  297:       }
  298:       break;
  299: 
  300:     case '=':
  301:       if (exp[0] == '=')
  302:         {
  303:           ++exp;
  304:           lval->op = equal;
  305:           result = EQUOP2;
  306:         }
  307:       else
  308:         result = YYERRCODE;
  309:       break;
  310: 
  311:     case '!':
  312:       if (exp[0] == '=')
  313:         {
  314:           ++exp;
  315:           lval->op = not_equal;
  316:           result = EQUOP2;
  317:         }
  318:       break;
  319: 
  320:     case '&':
  321:     case '|':
  322:       if (exp[0] == result)
  323:         ++exp;
  324:       else
  325:         result = YYERRCODE;
  326:       break;
  327: 
  328:     case '<':
  329:       if (exp[0] == '=')
  330:         {
  331:           ++exp;
  332:           lval->op = less_or_equal;
  333:         }
  334:       else
  335:         lval->op = less_than;
  336:       result = CMPOP2;
  337:       break;
  338: 
  339:     case '>':
  340:       if (exp[0] == '=')
  341:         {
  342:           ++exp;
  343:           lval->op = greater_or_equal;
  344:         }
  345:       else
  346:         lval->op = greater_than;
  347:       result = CMPOP2;
  348:       break;
  349: 
  350:     case '*':
  351:       lval->op = mult;
  352:       result = MULOP2;
  353:       break;
  354: 
  355:     case '/':
  356:       lval->op = divide;
  357:       result = MULOP2;
  358:       break;
  359: 
  360:     case '%':
  361:       lval->op = module;
  362:       result = MULOP2;
  363:       break;
  364: 
  365:     case '+':
  366:       lval->op = plus;
  367:       result = ADDOP2;
  368:       break;
  369: 
  370:     case '-':
  371:       lval->op = minus;
  372:       result = ADDOP2;
  373:       break;
  374: 
  375:     case 'n':
  376:     case '?':
  377:     case ':':
  378:     case '(':
  379:     case ')':
  380:       /* Nothing, just return the character.  */
  381:       break;
  382: 
  383:     case ';':
  384:     case '\n':
  385:     case '\0':
  386:       /* Be safe and let the user call this function again.  */
  387:       --exp;
  388:       result = YYEOF;
  389:       break;
  390: 
  391:     default:
  392:       result = YYERRCODE;
  393: #if YYDEBUG != 0
  394:       --exp;
  395: #endif
  396:       break;
  397:     }
  398: 
  399:   *pexp = exp;
  400: 
  401:   return result;
  402: }
  403: 
  404: 
  405: static void
  406: yyerror (str)
  407:      const char *str;
  408: {
  409:   /* Do nothing.  We don't print error messages here.  */
  410: }