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