intl/plural.y

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