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