source: vendor/glibc/current/intl/plural.y

Last change on this file was 1836, checked in by bird, 20 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 8.1 KB
Line 
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. */
58static struct expression *new_exp PARAMS ((int nargs, enum operator op,
59 struct expression * const *args));
60static inline struct expression *new_exp_0 PARAMS ((enum operator op));
61static inline struct expression *new_exp_1 PARAMS ((enum operator op,
62 struct expression *right));
63static struct expression *new_exp_2 PARAMS ((enum operator op,
64 struct expression *left,
65 struct expression *right));
66static inline struct expression *new_exp_3 PARAMS ((enum operator op,
67 struct expression *bexp,
68 struct expression *tbranch,
69 struct expression *fbranch));
70static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
71static void yyerror PARAMS ((const char *str));
72
73/* Allocation of expressions. */
74
75static struct expression *
76new_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
107static inline struct expression *
108new_exp_0 (op)
109 enum operator op;
110{
111 return new_exp (0, op, NULL);
112}
113
114static inline struct expression *
115new_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
125static struct expression *
126new_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
138static inline struct expression *
139new_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
175start: exp
176 {
177 if ($1 == NULL)
178 YYABORT;
179 ((struct parse_args *) arg)->res = $1;
180 }
181 ;
182
183exp: 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
232void
233internal_function
234FREE_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
260static int
261yylex (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
405static void
406yyerror (str)
407 const char *str;
408{
409 /* Do nothing. We don't print error messages here. */
410}
Note: See TracBrowser for help on using the repository browser.