navit/intl/plural.y

%{
/* Expression parsing for plural form selection.
   Copyright (C) 2000-2001, 2003 Free Software Foundation, Inc.
   Written by Ulrich Drepper <drepper@cygnus.com>, 2000.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA.  */

/* The bison generated parser uses alloca.  AIX 3 forces us to put this
   declaration at the beginning of the file.  The declaration in bison's
   skeleton file comes too late.  This must come before <config.h>
   because <config.h> may include arbitrary system headers.  */
#if defined _AIX && !defined __GNUC__
 #pragma alloca
#endif

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <stddef.h>
#include <stdlib.h>
#include "plural-exp.h"

/* The main function generated by the parser is called __gettextparse,
   but we want it to be called PLURAL_PARSE.  */
#ifndef _LIBC
# define __gettextparse PLURAL_PARSE
#endif

#define YYLEX_PARAM     &((struct parse_args *) arg)->cp
#define YYPARSE_PARAM   arg
%}
%pure_parser
%expect 7

%union {
  unsigned long int num;
  enum operator op;
  struct expression *exp;
}

%{
/* Prototypes for local functions.  */
static int yylex (YYSTYPE *lval, const char **pexp);
static void yyerror (const char *str);

/* Allocation of expressions.  */

static struct expression *
new_exp (int nargs, enum operator op, struct expression * const *args)
{
  int i;
  struct expression *newp;

  /* If any of the argument could not be malloc'ed, just return NULL.  */
  for (i = nargs - 1; i >= 0; i--)
    if (args[i] == NULL)
      goto fail;

  /* Allocate a new expression.  */
  newp = (struct expression *) malloc (sizeof (*newp));
  if (newp != NULL)
    {
      newp->nargs = nargs;
      newp->operation = op;
      for (i = nargs - 1; i >= 0; i--)
        newp->val.args[i] = args[i];
      return newp;
    }

 fail:
  for (i = nargs - 1; i >= 0; i--)
    FREE_EXPRESSION (args[i]);

  return NULL;
}

static inline struct expression *
new_exp_0 (enum operator op)
{
  return new_exp (0, op, NULL);
}

static inline struct expression *
new_exp_1 (enum operator op, struct expression *right)
{
  struct expression *args[1];

  args[0] = right;
  return new_exp (1, op, args);
}

static struct expression *
new_exp_2 (enum operator op, struct expression *left, struct expression *right)
{
  struct expression *args[2];

  args[0] = left;
  args[1] = right;
  return new_exp (2, op, args);
}

static inline struct expression *
new_exp_3 (enum operator op, struct expression *bexp,
           struct expression *tbranch, struct expression *fbranch)
{
  struct expression *args[3];

  args[0] = bexp;
  args[1] = tbranch;
  args[2] = fbranch;
  return new_exp (3, op, args);
}

%}

/* This declares that all operators have the same associativity and the
   precedence order as in C.  See [Harbison, Steele: C, A Reference Manual].
   There is no unary minus and no bitwise operators.
   Operators with the same syntactic behaviour have been merged into a single
   token, to save space in the array generated by bison.  */
%right '?'              /*   ?          */
%left '|'               /*   ||         */
%left '&'           /*   &&         */
%left EQUOP2            /*   == !=      */
%left CMPOP2            /*   < > <= >=      */
%left ADDOP2            /*   + -        */
%left MULOP2            /*   * / %      */
%right '!'              /*   !          */

%token <op> EQUOP2 CMPOP2 ADDOP2 MULOP2
%token <num> NUMBER
%type <exp> exp

%%

start:    exp
          {
            if ($1 == NULL)
              YYABORT;
            ((struct parse_args *) arg)->res = $1;
          }
        ;

exp:      exp '?' exp ':' exp
          {
            $$ = new_exp_3 (qmop, $1, $3, $5);
          }
        | exp '|' exp
          {
            $$ = new_exp_2 (lor, $1, $3);
          }
        | exp '&' exp
          {
            $$ = new_exp_2 (land, $1, $3);
          }
        | exp EQUOP2 exp
          {
            $$ = new_exp_2 ($2, $1, $3);
          }
        | exp CMPOP2 exp
          {
            $$ = new_exp_2 ($2, $1, $3);
          }
        | exp ADDOP2 exp
          {
            $$ = new_exp_2 ($2, $1, $3);
          }
        | exp MULOP2 exp
          {
            $$ = new_exp_2 ($2, $1, $3);
          }
        | '!' exp
          {
            $$ = new_exp_1 (lnot, $2);
          }
        | 'n'
          {
            $$ = new_exp_0 (var);
          }
        | NUMBER
          {
            if (($$ = new_exp_0 (num)) != NULL)
              $$->val.num = $1;
          }
        | '(' exp ')'
          {
            $$ = $2;
          }
        ;

%%

void
internal_function
FREE_EXPRESSION (struct expression *exp)
{
  if (exp == NULL)
    return;

  /* Handle the recursive case.  */
  switch (exp->nargs)
    {
    case 3:
      FREE_EXPRESSION (exp->val.args[2]);
      /* FALLTHROUGH */
    case 2:
      FREE_EXPRESSION (exp->val.args[1]);
      /* FALLTHROUGH */
    case 1:
      FREE_EXPRESSION (exp->val.args[0]);
      /* FALLTHROUGH */
    default:
      break;
    }

  free (exp);
}


static int
yylex (YYSTYPE *lval, const char **pexp)
{
  const char *exp = *pexp;
  int result;

  while (1)
    {
      if (exp[0] == '\0')
        {
          *pexp = exp;
          return YYEOF;
        }

      if (exp[0] != ' ' && exp[0] != '\t')
        break;

      ++exp;
    }

  result = *exp++;
  switch (result)
    {
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
      {
        unsigned long int n = result - '0';
        while (exp[0] >= '0' && exp[0] <= '9')
          {
            n *= 10;
            n += exp[0] - '0';
            ++exp;
          }
        lval->num = n;
        result = NUMBER;
      }
      break;

    case '=':
      if (exp[0] == '=')
        {
          ++exp;
          lval->op = equal;
          result = EQUOP2;
        }
      else
        result = YYERRCODE;
      break;

    case '!':
      if (exp[0] == '=')
        {
          ++exp;
          lval->op = not_equal;
          result = EQUOP2;
        }
      break;

    case '&':
    case '|':
      if (exp[0] == result)
        ++exp;
      else
        result = YYERRCODE;
      break;

    case '<':
      if (exp[0] == '=')
        {
          ++exp;
          lval->op = less_or_equal;
        }
      else
        lval->op = less_than;
      result = CMPOP2;
      break;

    case '>':
      if (exp[0] == '=')
        {
          ++exp;
          lval->op = greater_or_equal;
        }
      else
        lval->op = greater_than;
      result = CMPOP2;
      break;

    case '*':
      lval->op = mult;
      result = MULOP2;
      break;

    case '/':
      lval->op = divide;
      result = MULOP2;
      break;

    case '%':
      lval->op = module;
      result = MULOP2;
      break;

    case '+':
      lval->op = plus;
      result = ADDOP2;
      break;

    case '-':
      lval->op = minus;
      result = ADDOP2;
      break;

    case 'n':
    case '?':
    case ':':
    case '(':
    case ')':
      /* Nothing, just return the character.  */
      break;

    case ';':
    case '\n':
    case '\0':
      /* Be safe and let the user call this function again.  */
      --exp;
      result = YYEOF;
      break;

    default:
      result = YYERRCODE;
#if YYDEBUG != 0
      --exp;
#endif
      break;
    }

  *pexp = exp;

  return result;
}


static void
yyerror (const char *str)
{
  /* Do nothing.  We don't print error messages here.  */
}
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			}