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