OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [intl/] [plural.c] - Blame information for rev 301

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* A Bison parser, made from plural.y
2
   by GNU bison 1.35.  */
3
 
4
#define YYBISON 1  /* Identify Bison output.  */
5
 
6
#define yyparse __gettextparse
7
#define yylex __gettextlex
8
#define yyerror __gettexterror
9
#define yylval __gettextlval
10
#define yychar __gettextchar
11
#define yydebug __gettextdebug
12
#define yynerrs __gettextnerrs
13
# define        EQUOP2  257
14
# define        CMPOP2  258
15
# define        ADDOP2  259
16
# define        MULOP2  260
17
# define        NUMBER  261
18
 
19
#line 1 "plural.y"
20
 
21
/* Expression parsing for plural form selection.
22
   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
23
   Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
24
 
25
   This program is free software; you can redistribute it and/or modify it
26
   under the terms of the GNU Library General Public License as published
27
   by the Free Software Foundation; either version 2, or (at your option)
28
   any later version.
29
 
30
   This program is distributed in the hope that it will be useful,
31
   but WITHOUT ANY WARRANTY; without even the implied warranty of
32
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
33
   Library General Public License for more details.
34
 
35
   You should have received a copy of the GNU Library General Public
36
   License along with this program; if not, write to the Free Software
37
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
38
   USA.  */
39
 
40
/* The bison generated parser uses alloca.  AIX 3 forces us to put this
41
   declaration at the beginning of the file.  The declaration in bison's
42
   skeleton file comes too late.  This must come before <config.h>
43
   because <config.h> may include arbitrary system headers.  */
44
#if defined _AIX && !defined __GNUC__
45
 #pragma alloca
46
#endif
47
 
48
#ifdef HAVE_CONFIG_H
49
# include <config.h>
50
#endif
51
 
52
#include <stddef.h>
53
#include <stdlib.h>
54
#include "plural-exp.h"
55
 
56
/* The main function generated by the parser is called __gettextparse,
57
   but we want it to be called PLURAL_PARSE.  */
58
#ifndef _LIBC
59
# define __gettextparse PLURAL_PARSE
60
#endif
61
 
62
#define YYLEX_PARAM     &((struct parse_args *) arg)->cp
63
#define YYPARSE_PARAM   arg
64
 
65
#line 49 "plural.y"
66
#ifndef YYSTYPE
67
typedef union {
68
  unsigned long int num;
69
  enum operator op;
70
  struct expression *exp;
71
} yystype;
72
# define YYSTYPE yystype
73
# define YYSTYPE_IS_TRIVIAL 1
74
#endif
75
#line 55 "plural.y"
76
 
77
/* Prototypes for local functions.  */
78
static struct expression *new_exp PARAMS ((int nargs, enum operator op,
79
                                           struct expression * const *args));
80
static inline struct expression *new_exp_0 PARAMS ((enum operator op));
81
static inline struct expression *new_exp_1 PARAMS ((enum operator op,
82
                                                   struct expression *right));
83
static struct expression *new_exp_2 PARAMS ((enum operator op,
84
                                             struct expression *left,
85
                                             struct expression *right));
86
static inline struct expression *new_exp_3 PARAMS ((enum operator op,
87
                                                   struct expression *bexp,
88
                                                   struct expression *tbranch,
89
                                                   struct expression *fbranch));
90
static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
91
static void yyerror PARAMS ((const char *str));
92
 
93
/* Allocation of expressions.  */
94
 
95
static struct expression *
96
new_exp (nargs, op, args)
97
     int nargs;
98
     enum operator op;
99
     struct expression * const *args;
100
{
101
  int i;
102
  struct expression *newp;
103
 
104
  /* If any of the argument could not be malloc'ed, just return NULL.  */
105
  for (i = nargs - 1; i >= 0; i--)
106
    if (args[i] == NULL)
107
      goto fail;
108
 
109
  /* Allocate a new expression.  */
110
  newp = (struct expression *) malloc (sizeof (*newp));
111
  if (newp != NULL)
112
    {
113
      newp->nargs = nargs;
114
      newp->operation = op;
115
      for (i = nargs - 1; i >= 0; i--)
116
        newp->val.args[i] = args[i];
117
      return newp;
118
    }
119
 
120
 fail:
121
  for (i = nargs - 1; i >= 0; i--)
122
    FREE_EXPRESSION (args[i]);
123
 
124
  return NULL;
125
}
126
 
127
static inline struct expression *
128
new_exp_0 (op)
129
     enum operator op;
130
{
131
  return new_exp (0, op, NULL);
132
}
133
 
134
static inline struct expression *
135
new_exp_1 (op, right)
136
     enum operator op;
137
     struct expression *right;
138
{
139
  struct expression *args[1];
140
 
141
  args[0] = right;
142
  return new_exp (1, op, args);
143
}
144
 
145
static struct expression *
146
new_exp_2 (op, left, right)
147
     enum operator op;
148
     struct expression *left;
149
     struct expression *right;
150
{
151
  struct expression *args[2];
152
 
153
  args[0] = left;
154
  args[1] = right;
155
  return new_exp (2, op, args);
156
}
157
 
158
static inline struct expression *
159
new_exp_3 (op, bexp, tbranch, fbranch)
160
     enum operator op;
161
     struct expression *bexp;
162
     struct expression *tbranch;
163
     struct expression *fbranch;
164
{
165
  struct expression *args[3];
166
 
167
  args[0] = bexp;
168
  args[1] = tbranch;
169
  args[2] = fbranch;
170
  return new_exp (3, op, args);
171
}
172
 
173
#ifndef YYDEBUG
174
# define YYDEBUG 0
175
#endif
176
 
177
 
178
 
179
#define YYFINAL         27
180
#define YYFLAG          -32768
181
#define YYNTBASE        16
182
 
183
/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
184
#define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
185
 
186
/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
187
static const char yytranslate[] =
188
{
189
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
190
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
191
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
192
       2,     2,     2,    10,     2,     2,     2,     2,     5,     2,
193
      14,    15,     2,     2,     2,     2,     2,     2,     2,     2,
194
       2,     2,     2,     2,     2,     2,     2,     2,    12,     2,
195
       2,     2,     2,     3,     2,     2,     2,     2,     2,     2,
196
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
197
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
198
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
199
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
200
      13,     2,     2,     2,     2,     2,     2,     2,     2,     2,
201
       2,     2,     2,     2,     4,     2,     2,     2,     2,     2,
202
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
203
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
204
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
205
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
206
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
207
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
208
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
209
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
210
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
211
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
212
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
213
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
214
       2,     2,     2,     2,     2,     2,     1,     6,     7,     8,
215
       9,    11
216
};
217
 
218
#if YYDEBUG
219
static const short yyprhs[] =
220
{
221
       0,     0,     2,     8,    12,    16,    20,    24,    28,    32,
222
      35,    37,    39
223
};
224
static const short yyrhs[] =
225
{
226
      17,     0,    17,     3,    17,    12,    17,     0,    17,     4,
227
      17,     0,    17,     5,    17,     0,    17,     6,    17,     0,
228
      17,     7,    17,     0,    17,     8,    17,     0,    17,     9,
229
      17,     0,    10,    17,     0,    13,     0,    11,     0,    14,
230
      17,    15,     0
231
};
232
 
233
#endif
234
 
235
#if YYDEBUG
236
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
237
static const short yyrline[] =
238
{
239
       0,   174,   182,   186,   190,   194,   198,   202,   206,   210,
240
     214,   218,   223
241
};
242
#endif
243
 
244
 
245
#if (YYDEBUG) || defined YYERROR_VERBOSE
246
 
247
/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
248
static const char *const yytname[] =
249
{
250
  "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
251
  "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
252
  "start", "exp", 0
253
};
254
#endif
255
 
256
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
257
static const short yyr1[] =
258
{
259
       0,    16,    17,    17,    17,    17,    17,    17,    17,    17,
260
      17,    17,    17
261
};
262
 
263
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
264
static const short yyr2[] =
265
{
266
       0,     1,     5,     3,     3,     3,     3,     3,     3,     2,
267
       1,     1,     3
268
};
269
 
270
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
271
   doesn't specify something else to do.  Zero means the default is an
272
   error. */
273
static const short yydefact[] =
274
{
275
       0,     0,    11,    10,     0,     1,     9,     0,     0,     0,
276
       0,     0,     0,     0,     0,    12,     0,     3,     4,     5,
277
       6,     7,     8,     0,     2,     0,     0,     0
278
};
279
 
280
static const short yydefgoto[] =
281
{
282
      25,     5
283
};
284
 
285
static const short yypact[] =
286
{
287
      -9,    -9,-32768,-32768,    -9,    34,-32768,    11,    -9,    -9,
288
      -9,    -9,    -9,    -9,    -9,-32768,    24,    39,    43,    16,
289
      26,    -3,-32768,    -9,    34,    21,    53,-32768
290
};
291
 
292
static const short yypgoto[] =
293
{
294
  -32768,    -1
295
};
296
 
297
 
298
#define YYLAST          53
299
 
300
 
301
static const short yytable[] =
302
{
303
       6,     1,     2,     7,     3,     4,    14,    16,    17,    18,
304
      19,    20,    21,    22,     8,     9,    10,    11,    12,    13,
305
      14,    26,    24,    12,    13,    14,    15,     8,     9,    10,
306
      11,    12,    13,    14,    13,    14,    23,     8,     9,    10,
307
      11,    12,    13,    14,    10,    11,    12,    13,    14,    11,
308
      12,    13,    14,    27
309
};
310
 
311
static const short yycheck[] =
312
{
313
       1,    10,    11,     4,    13,    14,     9,     8,     9,    10,
314
      11,    12,    13,    14,     3,     4,     5,     6,     7,     8,
315
       9,     0,    23,     7,     8,     9,    15,     3,     4,     5,
316
       6,     7,     8,     9,     8,     9,    12,     3,     4,     5,
317
       6,     7,     8,     9,     5,     6,     7,     8,     9,     6,
318
       7,     8,     9,     0
319
};
320
#define YYPURE 1
321
 
322
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
323
#line 3 "/usr/local/share/bison/bison.simple"
324
 
325
/* Skeleton output parser for bison,
326
 
327
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
328
   Foundation, Inc.
329
 
330
   This program is free software; you can redistribute it and/or modify
331
   it under the terms of the GNU General Public License as published by
332
   the Free Software Foundation; either version 2, or (at your option)
333
   any later version.
334
 
335
   This program is distributed in the hope that it will be useful,
336
   but WITHOUT ANY WARRANTY; without even the implied warranty of
337
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
338
   GNU General Public License for more details.
339
 
340
   You should have received a copy of the GNU General Public License
341
   along with this program; if not, write to the Free Software
342
   Foundation, Inc., 51 Franklin Street - Fifth Floor,
343
   Boston, MA 02110-1301, USA.  */
344
 
345
/* As a special exception, when this file is copied by Bison into a
346
   Bison output file, you may use that output file without restriction.
347
   This special exception was added by the Free Software Foundation
348
   in version 1.24 of Bison.  */
349
 
350
/* This is the parser code that is written into each bison parser when
351
   the %semantic_parser declaration is not specified in the grammar.
352
   It was written by Richard Stallman by simplifying the hairy parser
353
   used when %semantic_parser is specified.  */
354
 
355
/* All symbols defined below should begin with yy or YY, to avoid
356
   infringing on user name space.  This should be done even for local
357
   variables, as they might otherwise be expanded by user macros.
358
   There are some unavoidable exceptions within include files to
359
   define necessary library symbols; they are noted "INFRINGES ON
360
   USER NAME SPACE" below.  */
361
 
362
#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
363
 
364
/* The parser invokes alloca or malloc; define the necessary symbols.  */
365
 
366
# if YYSTACK_USE_ALLOCA
367
#  define YYSTACK_ALLOC alloca
368
# else
369
#  ifndef YYSTACK_USE_ALLOCA
370
#   if defined (alloca) || defined (_ALLOCA_H)
371
#    define YYSTACK_ALLOC alloca
372
#   else
373
#    ifdef __GNUC__
374
#     define YYSTACK_ALLOC __builtin_alloca
375
#    endif
376
#   endif
377
#  endif
378
# endif
379
 
380
# ifdef YYSTACK_ALLOC
381
   /* Pacify GCC's `empty if-body' warning. */
382
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
383
# else
384
#  if defined (__STDC__) || defined (__cplusplus)
385
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
386
#   define YYSIZE_T size_t
387
#  endif
388
#  define YYSTACK_ALLOC malloc
389
#  define YYSTACK_FREE free
390
# endif
391
#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
392
 
393
 
394
#if (! defined (yyoverflow) \
395
     && (! defined (__cplusplus) \
396
         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
397
 
398
/* A type that is properly aligned for any stack member.  */
399
union yyalloc
400
{
401
  short yyss;
402
  YYSTYPE yyvs;
403
# if YYLSP_NEEDED
404
  YYLTYPE yyls;
405
# endif
406
};
407
 
408
/* The size of the maximum gap between one aligned stack and the next.  */
409
# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
410
 
411
/* The size of an array large to enough to hold all stacks, each with
412
   N elements.  */
413
# if YYLSP_NEEDED
414
#  define YYSTACK_BYTES(N) \
415
     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
416
      + 2 * YYSTACK_GAP_MAX)
417
# else
418
#  define YYSTACK_BYTES(N) \
419
     ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
420
      + YYSTACK_GAP_MAX)
421
# endif
422
 
423
/* Copy COUNT objects from FROM to TO.  The source and destination do
424
   not overlap.  */
425
# ifndef YYCOPY
426
#  if 1 < __GNUC__
427
#   define YYCOPY(To, From, Count) \
428
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
429
#  else
430
#   define YYCOPY(To, From, Count)              \
431
      do                                        \
432
        {                                       \
433
          register YYSIZE_T yyi;                \
434
          for (yyi = 0; yyi < (Count); yyi++)    \
435
            (To)[yyi] = (From)[yyi];            \
436
        }                                       \
437
      while (0)
438
#  endif
439
# endif
440
 
441
/* Relocate STACK from its old location to the new one.  The
442
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
443
   elements in the stack, and YYPTR gives the new location of the
444
   stack.  Advance YYPTR to a properly aligned location for the next
445
   stack.  */
446
# define YYSTACK_RELOCATE(Stack)                                        \
447
    do                                                                  \
448
      {                                                                 \
449
        YYSIZE_T yynewbytes;                                            \
450
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
451
        Stack = &yyptr->Stack;                                          \
452
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
453
        yyptr += yynewbytes / sizeof (*yyptr);                          \
454
      }                                                                 \
455
    while (0)
456
 
457
#endif
458
 
459
 
460
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
461
# define YYSIZE_T __SIZE_TYPE__
462
#endif
463
#if ! defined (YYSIZE_T) && defined (size_t)
464
# define YYSIZE_T size_t
465
#endif
466
#if ! defined (YYSIZE_T)
467
# if defined (__STDC__) || defined (__cplusplus)
468
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
469
#  define YYSIZE_T size_t
470
# endif
471
#endif
472
#if ! defined (YYSIZE_T)
473
# define YYSIZE_T unsigned int
474
#endif
475
 
476
#define yyerrok         (yyerrstatus = 0)
477
#define yyclearin       (yychar = YYEMPTY)
478
#define YYEMPTY         -2
479
#define YYEOF           0
480
#define YYACCEPT        goto yyacceptlab
481
#define YYABORT         goto yyabortlab
482
#define YYERROR         goto yyerrlab1
483
/* Like YYERROR except do call yyerror.  This remains here temporarily
484
   to ease the transition to the new meaning of YYERROR, for GCC.
485
   Once GCC version 2 has supplanted version 1, this can go.  */
486
#define YYFAIL          goto yyerrlab
487
#define YYRECOVERING()  (!!yyerrstatus)
488
#define YYBACKUP(Token, Value)                                  \
489
do                                                              \
490
  if (yychar == YYEMPTY && yylen == 1)                          \
491
    {                                                           \
492
      yychar = (Token);                                         \
493
      yylval = (Value);                                         \
494
      yychar1 = YYTRANSLATE (yychar);                           \
495
      YYPOPSTACK;                                               \
496
      goto yybackup;                                            \
497
    }                                                           \
498
  else                                                          \
499
    {                                                           \
500
      yyerror ("syntax error: cannot back up");                 \
501
      YYERROR;                                                  \
502
    }                                                           \
503
while (0)
504
 
505
#define YYTERROR        1
506
#define YYERRCODE       256
507
 
508
 
509
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
510
   are run).
511
 
512
   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
513
   first token.  By default, to implement support for ranges, extend
514
   its range to the last symbol.  */
515
 
516
#ifndef YYLLOC_DEFAULT
517
# define YYLLOC_DEFAULT(Current, Rhs, N)        \
518
   Current.last_line   = Rhs[N].last_line;      \
519
   Current.last_column = Rhs[N].last_column;
520
#endif
521
 
522
 
523
/* YYLEX -- calling `yylex' with the right arguments.  */
524
 
525
#if YYPURE
526
# if YYLSP_NEEDED
527
#  ifdef YYLEX_PARAM
528
#   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
529
#  else
530
#   define YYLEX                yylex (&yylval, &yylloc)
531
#  endif
532
# else /* !YYLSP_NEEDED */
533
#  ifdef YYLEX_PARAM
534
#   define YYLEX                yylex (&yylval, YYLEX_PARAM)
535
#  else
536
#   define YYLEX                yylex (&yylval)
537
#  endif
538
# endif /* !YYLSP_NEEDED */
539
#else /* !YYPURE */
540
# define YYLEX                  yylex ()
541
#endif /* !YYPURE */
542
 
543
 
544
/* Enable debugging if requested.  */
545
#if YYDEBUG
546
 
547
# ifndef YYFPRINTF
548
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
549
#  define YYFPRINTF fprintf
550
# endif
551
 
552
# define YYDPRINTF(Args)                        \
553
do {                                            \
554
  if (yydebug)                                  \
555
    YYFPRINTF Args;                             \
556
} while (0)
557
/* Nonzero means print parse trace.  It is left uninitialized so that
558
   multiple parsers can coexist.  */
559
int yydebug;
560
#else /* !YYDEBUG */
561
# define YYDPRINTF(Args)
562
#endif /* !YYDEBUG */
563
 
564
/* YYINITDEPTH -- initial size of the parser's stacks.  */
565
#ifndef YYINITDEPTH
566
# define YYINITDEPTH 200
567
#endif
568
 
569
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
570
   if the built-in stack extension method is used).
571
 
572
   Do not make this value too large; the results are undefined if
573
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
574
   evaluated with infinite-precision integer arithmetic.  */
575
 
576
#if YYMAXDEPTH == 0
577
# undef YYMAXDEPTH
578
#endif
579
 
580
#ifndef YYMAXDEPTH
581
# define YYMAXDEPTH 10000
582
#endif
583
 
584
#ifdef YYERROR_VERBOSE
585
 
586
# ifndef yystrlen
587
#  if defined (__GLIBC__) && defined (_STRING_H)
588
#   define yystrlen strlen
589
#  else
590
/* Return the length of YYSTR.  */
591
static YYSIZE_T
592
#   if defined (__STDC__) || defined (__cplusplus)
593
yystrlen (const char *yystr)
594
#   else
595
yystrlen (yystr)
596
     const char *yystr;
597
#   endif
598
{
599
  register const char *yys = yystr;
600
 
601
  while (*yys++ != '\0')
602
    continue;
603
 
604
  return yys - yystr - 1;
605
}
606
#  endif
607
# endif
608
 
609
# ifndef yystpcpy
610
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
611
#   define yystpcpy stpcpy
612
#  else
613
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
614
   YYDEST.  */
615
static char *
616
#   if defined (__STDC__) || defined (__cplusplus)
617
yystpcpy (char *yydest, const char *yysrc)
618
#   else
619
yystpcpy (yydest, yysrc)
620
     char *yydest;
621
     const char *yysrc;
622
#   endif
623
{
624
  register char *yyd = yydest;
625
  register const char *yys = yysrc;
626
 
627
  while ((*yyd++ = *yys++) != '\0')
628
    continue;
629
 
630
  return yyd - 1;
631
}
632
#  endif
633
# endif
634
#endif
635
 
636
#line 315 "/usr/local/share/bison/bison.simple"
637
 
638
 
639
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
640
   into yyparse.  The argument should have type void *.
641
   It should actually point to an object.
642
   Grammar actions can access the variable by casting it
643
   to the proper pointer type.  */
644
 
645
#ifdef YYPARSE_PARAM
646
# if defined (__STDC__) || defined (__cplusplus)
647
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
648
#  define YYPARSE_PARAM_DECL
649
# else
650
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
651
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
652
# endif
653
#else /* !YYPARSE_PARAM */
654
# define YYPARSE_PARAM_ARG
655
# define YYPARSE_PARAM_DECL
656
#endif /* !YYPARSE_PARAM */
657
 
658
/* Prevent warning if -Wstrict-prototypes.  */
659
#ifdef __GNUC__
660
# ifdef YYPARSE_PARAM
661
int yyparse (void *);
662
# else
663
int yyparse (void);
664
# endif
665
#endif
666
 
667
/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
668
   variables are global, or local to YYPARSE.  */
669
 
670
#define YY_DECL_NON_LSP_VARIABLES                       \
671
/* The lookahead symbol.  */                            \
672
int yychar;                                             \
673
                                                        \
674
/* The semantic value of the lookahead symbol. */       \
675
YYSTYPE yylval;                                         \
676
                                                        \
677
/* Number of parse errors so far.  */                   \
678
int yynerrs;
679
 
680
#if YYLSP_NEEDED
681
# define YY_DECL_VARIABLES                      \
682
YY_DECL_NON_LSP_VARIABLES                       \
683
                                                \
684
/* Location data for the lookahead symbol.  */  \
685
YYLTYPE yylloc;
686
#else
687
# define YY_DECL_VARIABLES                      \
688
YY_DECL_NON_LSP_VARIABLES
689
#endif
690
 
691
 
692
/* If nonreentrant, generate the variables here. */
693
 
694
#if !YYPURE
695
YY_DECL_VARIABLES
696
#endif  /* !YYPURE */
697
 
698
int
699
yyparse (YYPARSE_PARAM_ARG)
700
     YYPARSE_PARAM_DECL
701
{
702
  /* If reentrant, generate the variables here. */
703
#if YYPURE
704
  YY_DECL_VARIABLES
705
#endif  /* !YYPURE */
706
 
707
  register int yystate;
708
  register int yyn;
709
  int yyresult;
710
  /* Number of tokens to shift before error messages enabled.  */
711
  int yyerrstatus;
712
  /* Lookahead token as an internal (translated) token number.  */
713
  int yychar1 = 0;
714
 
715
  /* Three stacks and their tools:
716
     `yyss': related to states,
717
     `yyvs': related to semantic values,
718
     `yyls': related to locations.
719
 
720
     Refer to the stacks thru separate pointers, to allow yyoverflow
721
     to reallocate them elsewhere.  */
722
 
723
  /* The state stack. */
724
  short yyssa[YYINITDEPTH];
725
  short *yyss = yyssa;
726
  register short *yyssp;
727
 
728
  /* The semantic value stack.  */
729
  YYSTYPE yyvsa[YYINITDEPTH];
730
  YYSTYPE *yyvs = yyvsa;
731
  register YYSTYPE *yyvsp;
732
 
733
#if YYLSP_NEEDED
734
  /* The location stack.  */
735
  YYLTYPE yylsa[YYINITDEPTH];
736
  YYLTYPE *yyls = yylsa;
737
  YYLTYPE *yylsp;
738
#endif
739
 
740
#if YYLSP_NEEDED
741
# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
742
#else
743
# define YYPOPSTACK   (yyvsp--, yyssp--)
744
#endif
745
 
746
  YYSIZE_T yystacksize = YYINITDEPTH;
747
 
748
 
749
  /* The variables used to return semantic value and location from the
750
     action routines.  */
751
  YYSTYPE yyval;
752
#if YYLSP_NEEDED
753
  YYLTYPE yyloc;
754
#endif
755
 
756
  /* When reducing, the number of symbols on the RHS of the reduced
757
     rule. */
758
  int yylen;
759
 
760
  YYDPRINTF ((stderr, "Starting parse\n"));
761
 
762
  yystate = 0;
763
  yyerrstatus = 0;
764
  yynerrs = 0;
765
  yychar = YYEMPTY;             /* Cause a token to be read.  */
766
 
767
  /* Initialize stack pointers.
768
     Waste one element of value and location stack
769
     so that they stay on the same level as the state stack.
770
     The wasted elements are never initialized.  */
771
 
772
  yyssp = yyss;
773
  yyvsp = yyvs;
774
#if YYLSP_NEEDED
775
  yylsp = yyls;
776
#endif
777
  goto yysetstate;
778
 
779
/*------------------------------------------------------------.
780
| yynewstate -- Push a new state, which is found in yystate.  |
781
`------------------------------------------------------------*/
782
 yynewstate:
783
  /* In all cases, when you get here, the value and location stacks
784
     have just been pushed. so pushing a state here evens the stacks.
785
     */
786
  yyssp++;
787
 
788
 yysetstate:
789
  *yyssp = yystate;
790
 
791
  if (yyssp >= yyss + yystacksize - 1)
792
    {
793
      /* Get the current used size of the three stacks, in elements.  */
794
      YYSIZE_T yysize = yyssp - yyss + 1;
795
 
796
#ifdef yyoverflow
797
      {
798
        /* Give user a chance to reallocate the stack. Use copies of
799
           these so that the &'s don't force the real ones into
800
           memory.  */
801
        YYSTYPE *yyvs1 = yyvs;
802
        short *yyss1 = yyss;
803
 
804
        /* Each stack pointer address is followed by the size of the
805
           data in use in that stack, in bytes.  */
806
# if YYLSP_NEEDED
807
        YYLTYPE *yyls1 = yyls;
808
        /* This used to be a conditional around just the two extra args,
809
           but that might be undefined if yyoverflow is a macro.  */
810
        yyoverflow ("parser stack overflow",
811
                    &yyss1, yysize * sizeof (*yyssp),
812
                    &yyvs1, yysize * sizeof (*yyvsp),
813
                    &yyls1, yysize * sizeof (*yylsp),
814
                    &yystacksize);
815
        yyls = yyls1;
816
# else
817
        yyoverflow ("parser stack overflow",
818
                    &yyss1, yysize * sizeof (*yyssp),
819
                    &yyvs1, yysize * sizeof (*yyvsp),
820
                    &yystacksize);
821
# endif
822
        yyss = yyss1;
823
        yyvs = yyvs1;
824
      }
825
#else /* no yyoverflow */
826
# ifndef YYSTACK_RELOCATE
827
      goto yyoverflowlab;
828
# else
829
      /* Extend the stack our own way.  */
830
      if (yystacksize >= YYMAXDEPTH)
831
        goto yyoverflowlab;
832
      yystacksize *= 2;
833
      if (yystacksize > YYMAXDEPTH)
834
        yystacksize = YYMAXDEPTH;
835
 
836
      {
837
        short *yyss1 = yyss;
838
        union yyalloc *yyptr =
839
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
840
        if (! yyptr)
841
          goto yyoverflowlab;
842
        YYSTACK_RELOCATE (yyss);
843
        YYSTACK_RELOCATE (yyvs);
844
# if YYLSP_NEEDED
845
        YYSTACK_RELOCATE (yyls);
846
# endif
847
# undef YYSTACK_RELOCATE
848
        if (yyss1 != yyssa)
849
          YYSTACK_FREE (yyss1);
850
      }
851
# endif
852
#endif /* no yyoverflow */
853
 
854
      yyssp = yyss + yysize - 1;
855
      yyvsp = yyvs + yysize - 1;
856
#if YYLSP_NEEDED
857
      yylsp = yyls + yysize - 1;
858
#endif
859
 
860
      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
861
                  (unsigned long int) yystacksize));
862
 
863
      if (yyssp >= yyss + yystacksize - 1)
864
        YYABORT;
865
    }
866
 
867
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
868
 
869
  goto yybackup;
870
 
871
 
872
/*-----------.
873
| yybackup.  |
874
`-----------*/
875
yybackup:
876
 
877
/* Do appropriate processing given the current state.  */
878
/* Read a lookahead token if we need one and don't already have one.  */
879
/* yyresume: */
880
 
881
  /* First try to decide what to do without reference to lookahead token.  */
882
 
883
  yyn = yypact[yystate];
884
  if (yyn == YYFLAG)
885
    goto yydefault;
886
 
887
  /* Not known => get a lookahead token if don't already have one.  */
888
 
889
  /* yychar is either YYEMPTY or YYEOF
890
     or a valid token in external form.  */
891
 
892
  if (yychar == YYEMPTY)
893
    {
894
      YYDPRINTF ((stderr, "Reading a token: "));
895
      yychar = YYLEX;
896
    }
897
 
898
  /* Convert token to internal form (in yychar1) for indexing tables with */
899
 
900
  if (yychar <= 0)               /* This means end of input. */
901
    {
902
      yychar1 = 0;
903
      yychar = YYEOF;           /* Don't call YYLEX any more */
904
 
905
      YYDPRINTF ((stderr, "Now at end of input.\n"));
906
    }
907
  else
908
    {
909
      yychar1 = YYTRANSLATE (yychar);
910
 
911
#if YYDEBUG
912
     /* We have to keep this `#if YYDEBUG', since we use variables
913
        which are defined only if `YYDEBUG' is set.  */
914
      if (yydebug)
915
        {
916
          YYFPRINTF (stderr, "Next token is %d (%s",
917
                     yychar, yytname[yychar1]);
918
          /* Give the individual parser a way to print the precise
919
             meaning of a token, for further debugging info.  */
920
# ifdef YYPRINT
921
          YYPRINT (stderr, yychar, yylval);
922
# endif
923
          YYFPRINTF (stderr, ")\n");
924
        }
925
#endif
926
    }
927
 
928
  yyn += yychar1;
929
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
930
    goto yydefault;
931
 
932
  yyn = yytable[yyn];
933
 
934
  /* yyn is what to do for this token type in this state.
935
     Negative => reduce, -yyn is rule number.
936
     Positive => shift, yyn is new state.
937
       New state is final state => don't bother to shift,
938
       just return success.
939
     0, or most negative number => error.  */
940
 
941
  if (yyn < 0)
942
    {
943
      if (yyn == YYFLAG)
944
        goto yyerrlab;
945
      yyn = -yyn;
946
      goto yyreduce;
947
    }
948
  else if (yyn == 0)
949
    goto yyerrlab;
950
 
951
  if (yyn == YYFINAL)
952
    YYACCEPT;
953
 
954
  /* Shift the lookahead token.  */
955
  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
956
              yychar, yytname[yychar1]));
957
 
958
  /* Discard the token being shifted unless it is eof.  */
959
  if (yychar != YYEOF)
960
    yychar = YYEMPTY;
961
 
962
  *++yyvsp = yylval;
963
#if YYLSP_NEEDED
964
  *++yylsp = yylloc;
965
#endif
966
 
967
  /* Count tokens shifted since error; after three, turn off error
968
     status.  */
969
  if (yyerrstatus)
970
    yyerrstatus--;
971
 
972
  yystate = yyn;
973
  goto yynewstate;
974
 
975
 
976
/*-----------------------------------------------------------.
977
| yydefault -- do the default action for the current state.  |
978
`-----------------------------------------------------------*/
979
yydefault:
980
  yyn = yydefact[yystate];
981
  if (yyn == 0)
982
    goto yyerrlab;
983
  goto yyreduce;
984
 
985
 
986
/*-----------------------------.
987
| yyreduce -- Do a reduction.  |
988
`-----------------------------*/
989
yyreduce:
990
  /* yyn is the number of a rule to reduce with.  */
991
  yylen = yyr2[yyn];
992
 
993
  /* If YYLEN is nonzero, implement the default value of the action:
994
     `$$ = $1'.
995
 
996
     Otherwise, the following line sets YYVAL to the semantic value of
997
     the lookahead token.  This behavior is undocumented and Bison
998
     users should not rely upon it.  Assigning to YYVAL
999
     unconditionally makes the parser a bit smaller, and it avoids a
1000
     GCC warning that YYVAL may be used uninitialized.  */
1001
  yyval = yyvsp[1-yylen];
1002
 
1003
#if YYLSP_NEEDED
1004
  /* Similarly for the default location.  Let the user run additional
1005
     commands if for instance locations are ranges.  */
1006
  yyloc = yylsp[1-yylen];
1007
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1008
#endif
1009
 
1010
#if YYDEBUG
1011
  /* We have to keep this `#if YYDEBUG', since we use variables which
1012
     are defined only if `YYDEBUG' is set.  */
1013
  if (yydebug)
1014
    {
1015
      int yyi;
1016
 
1017
      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1018
                 yyn, yyrline[yyn]);
1019
 
1020
      /* Print the symbols being reduced, and their result.  */
1021
      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1022
        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1023
      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1024
    }
1025
#endif
1026
 
1027
  switch (yyn) {
1028
 
1029
case 1:
1030
#line 175 "plural.y"
1031
{
1032
            if (yyvsp[0].exp == NULL)
1033
              YYABORT;
1034
            ((struct parse_args *) arg)->res = yyvsp[0].exp;
1035
          }
1036
    break;
1037
case 2:
1038
#line 183 "plural.y"
1039
{
1040
            yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
1041
          }
1042
    break;
1043
case 3:
1044
#line 187 "plural.y"
1045
{
1046
            yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
1047
          }
1048
    break;
1049
case 4:
1050
#line 191 "plural.y"
1051
{
1052
            yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
1053
          }
1054
    break;
1055
case 5:
1056
#line 195 "plural.y"
1057
{
1058
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1059
          }
1060
    break;
1061
case 6:
1062
#line 199 "plural.y"
1063
{
1064
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1065
          }
1066
    break;
1067
case 7:
1068
#line 203 "plural.y"
1069
{
1070
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1071
          }
1072
    break;
1073
case 8:
1074
#line 207 "plural.y"
1075
{
1076
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1077
          }
1078
    break;
1079
case 9:
1080
#line 211 "plural.y"
1081
{
1082
            yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
1083
          }
1084
    break;
1085
case 10:
1086
#line 215 "plural.y"
1087
{
1088
            yyval.exp = new_exp_0 (var);
1089
          }
1090
    break;
1091
case 11:
1092
#line 219 "plural.y"
1093
{
1094
            if ((yyval.exp = new_exp_0 (num)) != NULL)
1095
              yyval.exp->val.num = yyvsp[0].num;
1096
          }
1097
    break;
1098
case 12:
1099
#line 224 "plural.y"
1100
{
1101
            yyval.exp = yyvsp[-1].exp;
1102
          }
1103
    break;
1104
}
1105
 
1106
#line 705 "/usr/local/share/bison/bison.simple"
1107
 
1108
 
1109
  yyvsp -= yylen;
1110
  yyssp -= yylen;
1111
#if YYLSP_NEEDED
1112
  yylsp -= yylen;
1113
#endif
1114
 
1115
#if YYDEBUG
1116
  if (yydebug)
1117
    {
1118
      short *yyssp1 = yyss - 1;
1119
      YYFPRINTF (stderr, "state stack now");
1120
      while (yyssp1 != yyssp)
1121
        YYFPRINTF (stderr, " %d", *++yyssp1);
1122
      YYFPRINTF (stderr, "\n");
1123
    }
1124
#endif
1125
 
1126
  *++yyvsp = yyval;
1127
#if YYLSP_NEEDED
1128
  *++yylsp = yyloc;
1129
#endif
1130
 
1131
  /* Now `shift' the result of the reduction.  Determine what state
1132
     that goes to, based on the state we popped back to and the rule
1133
     number reduced by.  */
1134
 
1135
  yyn = yyr1[yyn];
1136
 
1137
  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1138
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1139
    yystate = yytable[yystate];
1140
  else
1141
    yystate = yydefgoto[yyn - YYNTBASE];
1142
 
1143
  goto yynewstate;
1144
 
1145
 
1146
/*------------------------------------.
1147
| yyerrlab -- here on detecting error |
1148
`------------------------------------*/
1149
yyerrlab:
1150
  /* If not already recovering from an error, report this error.  */
1151
  if (!yyerrstatus)
1152
    {
1153
      ++yynerrs;
1154
 
1155
#ifdef YYERROR_VERBOSE
1156
      yyn = yypact[yystate];
1157
 
1158
      if (yyn > YYFLAG && yyn < YYLAST)
1159
        {
1160
          YYSIZE_T yysize = 0;
1161
          char *yymsg;
1162
          int yyx, yycount;
1163
 
1164
          yycount = 0;
1165
          /* Start YYX at -YYN if negative to avoid negative indexes in
1166
             YYCHECK.  */
1167
          for (yyx = yyn < 0 ? -yyn : 0;
1168
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1169
            if (yycheck[yyx + yyn] == yyx)
1170
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1171
          yysize += yystrlen ("parse error, unexpected ") + 1;
1172
          yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1173
          yymsg = (char *) YYSTACK_ALLOC (yysize);
1174
          if (yymsg != 0)
1175
            {
1176
              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1177
              yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1178
 
1179
              if (yycount < 5)
1180
                {
1181
                  yycount = 0;
1182
                  for (yyx = yyn < 0 ? -yyn : 0;
1183
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
1184
                       yyx++)
1185
                    if (yycheck[yyx + yyn] == yyx)
1186
                      {
1187
                        const char *yyq = ! yycount ? ", expecting " : " or ";
1188
                        yyp = yystpcpy (yyp, yyq);
1189
                        yyp = yystpcpy (yyp, yytname[yyx]);
1190
                        yycount++;
1191
                      }
1192
                }
1193
              yyerror (yymsg);
1194
              YYSTACK_FREE (yymsg);
1195
            }
1196
          else
1197
            yyerror ("parse error; also virtual memory exhausted");
1198
        }
1199
      else
1200
#endif /* defined (YYERROR_VERBOSE) */
1201
        yyerror ("parse error");
1202
    }
1203
  goto yyerrlab1;
1204
 
1205
 
1206
/*--------------------------------------------------.
1207
| yyerrlab1 -- error raised explicitly by an action |
1208
`--------------------------------------------------*/
1209
yyerrlab1:
1210
  if (yyerrstatus == 3)
1211
    {
1212
      /* If just tried and failed to reuse lookahead token after an
1213
         error, discard it.  */
1214
 
1215
      /* return failure if at end of input */
1216
      if (yychar == YYEOF)
1217
        YYABORT;
1218
      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1219
                  yychar, yytname[yychar1]));
1220
      yychar = YYEMPTY;
1221
    }
1222
 
1223
  /* Else will try to reuse lookahead token after shifting the error
1224
     token.  */
1225
 
1226
  yyerrstatus = 3;              /* Each real token shifted decrements this */
1227
 
1228
  goto yyerrhandle;
1229
 
1230
 
1231
/*-------------------------------------------------------------------.
1232
| yyerrdefault -- current state does not do anything special for the |
1233
| error token.                                                       |
1234
`-------------------------------------------------------------------*/
1235
yyerrdefault:
1236
#if 0
1237
  /* This is wrong; only states that explicitly want error tokens
1238
     should shift them.  */
1239
 
1240
  /* If its default is to accept any token, ok.  Otherwise pop it.  */
1241
  yyn = yydefact[yystate];
1242
  if (yyn)
1243
    goto yydefault;
1244
#endif
1245
 
1246
 
1247
/*---------------------------------------------------------------.
1248
| yyerrpop -- pop the current state because it cannot handle the |
1249
| error token                                                    |
1250
`---------------------------------------------------------------*/
1251
yyerrpop:
1252
  if (yyssp == yyss)
1253
    YYABORT;
1254
  yyvsp--;
1255
  yystate = *--yyssp;
1256
#if YYLSP_NEEDED
1257
  yylsp--;
1258
#endif
1259
 
1260
#if YYDEBUG
1261
  if (yydebug)
1262
    {
1263
      short *yyssp1 = yyss - 1;
1264
      YYFPRINTF (stderr, "Error: state stack now");
1265
      while (yyssp1 != yyssp)
1266
        YYFPRINTF (stderr, " %d", *++yyssp1);
1267
      YYFPRINTF (stderr, "\n");
1268
    }
1269
#endif
1270
 
1271
/*--------------.
1272
| yyerrhandle.  |
1273
`--------------*/
1274
yyerrhandle:
1275
  yyn = yypact[yystate];
1276
  if (yyn == YYFLAG)
1277
    goto yyerrdefault;
1278
 
1279
  yyn += YYTERROR;
1280
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1281
    goto yyerrdefault;
1282
 
1283
  yyn = yytable[yyn];
1284
  if (yyn < 0)
1285
    {
1286
      if (yyn == YYFLAG)
1287
        goto yyerrpop;
1288
      yyn = -yyn;
1289
      goto yyreduce;
1290
    }
1291
  else if (yyn == 0)
1292
    goto yyerrpop;
1293
 
1294
  if (yyn == YYFINAL)
1295
    YYACCEPT;
1296
 
1297
  YYDPRINTF ((stderr, "Shifting error token, "));
1298
 
1299
  *++yyvsp = yylval;
1300
#if YYLSP_NEEDED
1301
  *++yylsp = yylloc;
1302
#endif
1303
 
1304
  yystate = yyn;
1305
  goto yynewstate;
1306
 
1307
 
1308
/*-------------------------------------.
1309
| yyacceptlab -- YYACCEPT comes here.  |
1310
`-------------------------------------*/
1311
yyacceptlab:
1312
  yyresult = 0;
1313
  goto yyreturn;
1314
 
1315
/*-----------------------------------.
1316
| yyabortlab -- YYABORT comes here.  |
1317
`-----------------------------------*/
1318
yyabortlab:
1319
  yyresult = 1;
1320
  goto yyreturn;
1321
 
1322
/*---------------------------------------------.
1323
| yyoverflowab -- parser overflow comes here.  |
1324
`---------------------------------------------*/
1325
yyoverflowlab:
1326
  yyerror ("parser stack overflow");
1327
  yyresult = 2;
1328
  /* Fall through.  */
1329
 
1330
yyreturn:
1331
#ifndef yyoverflow
1332
  if (yyss != yyssa)
1333
    YYSTACK_FREE (yyss);
1334
#endif
1335
  return yyresult;
1336
}
1337
#line 229 "plural.y"
1338
 
1339
 
1340
void
1341
internal_function
1342
FREE_EXPRESSION (exp)
1343
     struct expression *exp;
1344
{
1345
  if (exp == NULL)
1346
    return;
1347
 
1348
  /* Handle the recursive case.  */
1349
  switch (exp->nargs)
1350
    {
1351
    case 3:
1352
      FREE_EXPRESSION (exp->val.args[2]);
1353
      /* FALLTHROUGH */
1354
    case 2:
1355
      FREE_EXPRESSION (exp->val.args[1]);
1356
      /* FALLTHROUGH */
1357
    case 1:
1358
      FREE_EXPRESSION (exp->val.args[0]);
1359
      /* FALLTHROUGH */
1360
    default:
1361
      break;
1362
    }
1363
 
1364
  free (exp);
1365
}
1366
 
1367
 
1368
static int
1369
yylex (lval, pexp)
1370
     YYSTYPE *lval;
1371
     const char **pexp;
1372
{
1373
  const char *exp = *pexp;
1374
  int result;
1375
 
1376
  while (1)
1377
    {
1378
      if (exp[0] == '\0')
1379
        {
1380
          *pexp = exp;
1381
          return YYEOF;
1382
        }
1383
 
1384
      if (exp[0] != ' ' && exp[0] != '\t')
1385
        break;
1386
 
1387
      ++exp;
1388
    }
1389
 
1390
  result = *exp++;
1391
  switch (result)
1392
    {
1393
    case '0': case '1': case '2': case '3': case '4':
1394
    case '5': case '6': case '7': case '8': case '9':
1395
      {
1396
        unsigned long int n = result - '0';
1397
        while (exp[0] >= '0' && exp[0] <= '9')
1398
          {
1399
            n *= 10;
1400
            n += exp[0] - '0';
1401
            ++exp;
1402
          }
1403
        lval->num = n;
1404
        result = NUMBER;
1405
      }
1406
      break;
1407
 
1408
    case '=':
1409
      if (exp[0] == '=')
1410
        {
1411
          ++exp;
1412
          lval->op = equal;
1413
          result = EQUOP2;
1414
        }
1415
      else
1416
        result = YYERRCODE;
1417
      break;
1418
 
1419
    case '!':
1420
      if (exp[0] == '=')
1421
        {
1422
          ++exp;
1423
          lval->op = not_equal;
1424
          result = EQUOP2;
1425
        }
1426
      break;
1427
 
1428
    case '&':
1429
    case '|':
1430
      if (exp[0] == result)
1431
        ++exp;
1432
      else
1433
        result = YYERRCODE;
1434
      break;
1435
 
1436
    case '<':
1437
      if (exp[0] == '=')
1438
        {
1439
          ++exp;
1440
          lval->op = less_or_equal;
1441
        }
1442
      else
1443
        lval->op = less_than;
1444
      result = CMPOP2;
1445
      break;
1446
 
1447
    case '>':
1448
      if (exp[0] == '=')
1449
        {
1450
          ++exp;
1451
          lval->op = greater_or_equal;
1452
        }
1453
      else
1454
        lval->op = greater_than;
1455
      result = CMPOP2;
1456
      break;
1457
 
1458
    case '*':
1459
      lval->op = mult;
1460
      result = MULOP2;
1461
      break;
1462
 
1463
    case '/':
1464
      lval->op = divide;
1465
      result = MULOP2;
1466
      break;
1467
 
1468
    case '%':
1469
      lval->op = module;
1470
      result = MULOP2;
1471
      break;
1472
 
1473
    case '+':
1474
      lval->op = plus;
1475
      result = ADDOP2;
1476
      break;
1477
 
1478
    case '-':
1479
      lval->op = minus;
1480
      result = ADDOP2;
1481
      break;
1482
 
1483
    case 'n':
1484
    case '?':
1485
    case ':':
1486
    case '(':
1487
    case ')':
1488
      /* Nothing, just return the character.  */
1489
      break;
1490
 
1491
    case ';':
1492
    case '\n':
1493
    case '\0':
1494
      /* Be safe and let the user call this function again.  */
1495
      --exp;
1496
      result = YYEOF;
1497
      break;
1498
 
1499
    default:
1500
      result = YYERRCODE;
1501
#if YYDEBUG != 0
1502
      --exp;
1503
#endif
1504
      break;
1505
    }
1506
 
1507
  *pexp = exp;
1508
 
1509
  return result;
1510
}
1511
 
1512
 
1513
static void
1514
yyerror (str)
1515
     const char *str;
1516
{
1517
  /* Do nothing.  We don't print error messages here.  */
1518
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.