[binutils.git] / intl / plural.y

%{
/* Expression parsing for plural form selection.
   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
   Written by Ulrich Drepper <[email protected]>, 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   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 struct expression *new_exp PARAMS ((int nargs, enum operator op,
					   struct expression * const *args));
static inline struct expression *new_exp_0 PARAMS ((enum operator op));
static inline struct expression *new_exp_1 PARAMS ((enum operator op,
						   struct expression *right));
static struct expression *new_exp_2 PARAMS ((enum operator op,
					     struct expression *left,
					     struct expression *right));
static inline struct expression *new_exp_3 PARAMS ((enum operator op,
						   struct expression *bexp,
						   struct expression *tbranch,
						   struct expression *fbranch));
static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
static void yyerror PARAMS ((const char *str));

/* Allocation of expressions.  */

static struct expression *
new_exp (nargs, op, args)
     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 (op)
     enum operator op;
{
  return new_exp (0, op, NULL);
}

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