URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [intl/] [plural.y] - Blame information for rev 26

Details | Compare with Previous | View Log


%{
/* Expression parsing for plural form selection.
   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
   Written by Ulrich Drepper , 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 
   because  may include arbitrary system headers.  */
#if defined _AIX && !defined __GNUC__
 #pragma alloca
#endif
 
#ifdef HAVE_CONFIG_H
# include 
#endif
 
#include 
#include 
#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  EQUOP2 CMPOP2 ADDOP2 MULOP2
%token  NUMBER
%type  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.  */
}

Browse

Tools

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [intl/] [plural.y] - Blame information for rev 26

Line No.	Rev	Author	Line
1	26	jlechner	`%{`
2			`/* Expression parsing for plural form selection.`
3			`Copyright (C) 2000, 2001 Free Software Foundation, Inc.`
4			`Written by Ulrich Drepper , 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`
24			`because may include arbitrary system headers. */`
25			`#if defined _AIX && !defined __GNUC__`
26			`#pragma alloca`
27			`#endif`
28
29			`#ifdef HAVE_CONFIG_H`
30			`# include`
31			`#endif`
32
33			`#include`
34			`#include`
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 EQUOP2 CMPOP2 ADDOP2 MULOP2`
169			`%token NUMBER`
170			`%type 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			`}`