/[zanavi_public1]/navit/intl/plural.y
ZANavi

Contents of /navit/intl/plural.y

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (hide annotations) (download)
Fri Oct 28 21:19:04 2011 UTC (10 years, 9 months ago) by zoff99
File size: 7353 byte(s)
import files
1 zoff99 2 %{
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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     }

   
Visit the ZANavi Wiki