Switched to GPLv3.
[gnupg.git] / 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 }