Add libc_hidden_def.
[kopensolaris-gnu/glibc.git] / intl / plural.y
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.  */
58 static struct expression *new_exp PARAMS ((int nargs, enum operator op,
59                                            struct expression * const *args));
60 static inline struct expression *new_exp_0 PARAMS ((enum operator op));
61 static inline struct expression *new_exp_1 PARAMS ((enum operator op,
62                                                    struct expression *right));
63 static struct expression *new_exp_2 PARAMS ((enum operator op,
64                                              struct expression *left,
65                                              struct expression *right));
66 static inline struct expression *new_exp_3 PARAMS ((enum operator op,
67                                                    struct expression *bexp,
68                                                    struct expression *tbranch,
69                                                    struct expression *fbranch));
70 static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
71 static void yyerror PARAMS ((const char *str));
72
73 /* Allocation of expressions.  */
74
75 static struct expression *
76 new_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
107 static inline struct expression *
108 new_exp_0 (op)
109      enum operator op;
110 {
111   return new_exp (0, op, NULL);
112 }
113
114 static inline struct expression *
115 new_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
125 static struct expression *
126 new_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
138 static inline struct expression *
139 new_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
175 start:    exp
176           {
177             if ($1 == NULL)
178               YYABORT;
179             ((struct parse_args *) arg)->res = $1;
180           }
181         ;
182
183 exp:      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
232 void
233 internal_function
234 FREE_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
260 static int
261 yylex (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
405 static void
406 yyerror (str)
407      const char *str;
408 {
409   /* Do nothing.  We don't print error messages here.  */
410 }