« back to all changes in this revision
Viewing changes to intl/plural.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Torsten Werner
- Date: 2007-05-20 13:26:57 UTC
- Revision ID: james.westby@ubuntu.com-20070520132657-moq2xuphoap7532j
Tags: upstream-0.12
Import upstream version 0.12
- files added:
- intl
- po
- src
added
removed
intl/plural.c
1
2
/* A Bison parser, made from plural.y
3
by GNU Bison version 1.28 */
4
5
#define YYBISON 1 /* Identify Bison output. */
6
7
#define yyparse __gettextparse
8
#define yylex __gettextlex
9
#define yyerror __gettexterror
10
#define yylval __gettextlval
11
#define yychar __gettextchar
12
#define yydebug __gettextdebug
13
#define yynerrs __gettextnerrs
14
#define EQUOP2 257
15
#define CMPOP2 258
16
#define ADDOP2 259
17
#define MULOP2 260
18
#define NUMBER 261
19
20
#line 1 "plural.y"
21
22
/* Expression parsing for plural form selection.
23
Copyright (C) 2000, 2001 Free Software Foundation, Inc.
24
Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
25
26
This program is free software; you can redistribute it and/or modify it
27
under the terms of the GNU Library General Public License as published
28
by the Free Software Foundation; either version 2, or (at your option)
29
any later version.
30
31
This program is distributed in the hope that it will be useful,
32
but WITHOUT ANY WARRANTY; without even the implied warranty of
33
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
34
Library General Public License for more details.
35
36
You should have received a copy of the GNU Library General Public
37
License along with this program; if not, write to the Free Software
38
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
39
USA. */
40
41
/* The bison generated parser uses alloca. AIX 3 forces us to put this
42
declaration at the beginning of the file. The declaration in bison's
43
skeleton file comes too late. This must come before <config.h>
44
because <config.h> may include arbitrary system headers. */
45
#if defined _AIX && !defined __GNUC__
46
#pragma alloca
47
#endif
48
49
#ifdef HAVE_CONFIG_H
50
# include <config.h>
51
#endif
52
53
#include <stdlib.h>
54
#include "gettextP.h"
55
56
/* Names for the libintl functions are a problem. They must not clash
57
with existing names and they should follow ANSI C. But this source
58
code is also used in GNU C Library where the names have a __
59
prefix. So we have to make a difference here. */
60
#ifdef _LIBC
61
# define FREE_EXPRESSION __gettext_free_exp
62
#else
63
# define FREE_EXPRESSION gettext_free_exp__
64
# define __gettextparse gettextparse__
65
#endif
66
67
#define YYLEX_PARAM &((struct parse_args *) arg)->cp
68
#define YYPARSE_PARAM arg
69
70
#line 53 "plural.y"
71
typedef union {
72
unsigned long int num;
73
enum operator op;
74
struct expression *exp;
75
} YYSTYPE;
76
#line 59 "plural.y"
77
78
/* Prototypes for local functions. */
79
static struct expression *new_exp PARAMS ((int nargs, enum operator op,
80
struct expression * const *args));
81
static inline struct expression *new_exp_0 PARAMS ((enum operator op));
82
static inline struct expression *new_exp_1 PARAMS ((enum operator op,
83
struct expression *right));
84
static struct expression *new_exp_2 PARAMS ((enum operator op,
85
struct expression *left,
86
struct expression *right));
87
static inline struct expression *new_exp_3 PARAMS ((enum operator op,
88
struct expression *bexp,
89
struct expression *tbranch,
90
struct expression *fbranch));
91
static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
92
static void yyerror PARAMS ((const char *str));
93
94
/* Allocation of expressions. */
95
96
static struct expression *
97
new_exp (nargs, op, args)
98
int nargs;
99
enum operator op;
100
struct expression * const *args;
101
{
102
int i;
103
struct expression *newp;
104
105
/* If any of the argument could not be malloc'ed, just return NULL. */
106
for (i = nargs - 1; i >= 0; i--)
107
if (args[i] == NULL)
108
goto fail;
109
110
/* Allocate a new expression. */
111
newp = (struct expression *) malloc (sizeof (*newp));
112
if (newp != NULL)
113
{
114
newp->nargs = nargs;
115
newp->operation = op;
116
for (i = nargs - 1; i >= 0; i--)
117
newp->val.args[i] = args[i];
118
return newp;
119
}
120
121
fail:
122
for (i = nargs - 1; i >= 0; i--)
123
FREE_EXPRESSION (args[i]);
124
125
return NULL;
126
}
127
128
static inline struct expression *
129
new_exp_0 (op)
130
enum operator op;
131
{
132
return new_exp (0, op, NULL);
133
}
134
135
static inline struct expression *
136
new_exp_1 (op, right)
137
enum operator op;
138
struct expression *right;
139
{
140
struct expression *args[1];
141
142
args[0] = right;
143
return new_exp (1, op, args);
144
}
145
146
static struct expression *
147
new_exp_2 (op, left, right)
148
enum operator op;
149
struct expression *left;
150
struct expression *right;
151
{
152
struct expression *args[2];
153
154
args[0] = left;
155
args[1] = right;
156
return new_exp (2, op, args);
157
}
158
159
static inline struct expression *
160
new_exp_3 (op, bexp, tbranch, fbranch)
161
enum operator op;
162
struct expression *bexp;
163
struct expression *tbranch;
164
struct expression *fbranch;
165
{
166
struct expression *args[3];
167
168
args[0] = bexp;
169
args[1] = tbranch;
170
args[2] = fbranch;
171
return new_exp (3, op, args);
172
}
173
174
#include <stdio.h>
175
176
#ifndef __cplusplus
177
#ifndef __STDC__
178
#define const
179
#endif
180
#endif
181
182
183
184
#define YYFINAL 27
185
#define YYFLAG -32768
186
#define YYNTBASE 16
187
188
#define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
189
190
static const char yytranslate[] = { 0,
191
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
192
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
193
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
194
2, 2, 10, 2, 2, 2, 2, 5, 2, 14,
195
15, 2, 2, 2, 2, 2, 2, 2, 2, 2,
196
2, 2, 2, 2, 2, 2, 2, 12, 2, 2,
197
2, 2, 3, 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
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
201
2, 2, 2, 2, 2, 2, 2, 2, 2, 13,
202
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
203
2, 2, 2, 4, 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, 2, 2, 2, 2,
215
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
216
2, 2, 2, 2, 2, 1, 6, 7, 8, 9,
217
11
218
};
219
220
#if YYDEBUG != 0
221
static const short yyprhs[] = { 0,
222
0, 2, 8, 12, 16, 20, 24, 28, 32, 35,
223
37, 39
224
};
225
226
static const short yyrhs[] = { 17,
227
0, 17, 3, 17, 12, 17, 0, 17, 4, 17,
228
0, 17, 5, 17, 0, 17, 6, 17, 0, 17,
229
7, 17, 0, 17, 8, 17, 0, 17, 9, 17,
230
0, 10, 17, 0, 13, 0, 11, 0, 14, 17,
231
15, 0
232
};
233
234
#endif
235
236
#if YYDEBUG != 0
237
static const short yyrline[] = { 0,
238
178, 186, 190, 194, 198, 202, 206, 210, 214, 218,
239
222, 227
240
};
241
#endif
242
243
244
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
245
246
static const char * const yytname[] = { "$","error","$undefined.","'?'","'|'",
247
"'&'","EQUOP2","CMPOP2","ADDOP2","MULOP2","'!'","NUMBER","':'","'n'","'('","')'",
248
"start","exp", NULL
249
};
250
#endif
251
252
static const short yyr1[] = { 0,
253
16, 17, 17, 17, 17, 17, 17, 17, 17, 17,
254
17, 17
255
};
256
257
static const short yyr2[] = { 0,
258
1, 5, 3, 3, 3, 3, 3, 3, 2, 1,
259
1, 3
260
};
261
262
static const short yydefact[] = { 0,
263
0, 11, 10, 0, 1, 9, 0, 0, 0, 0,
264
0, 0, 0, 0, 12, 0, 3, 4, 5, 6,
265
7, 8, 0, 2, 0, 0, 0
266
};
267
268
static const short yydefgoto[] = { 25,
269
5
270
};
271
272
static const short yypact[] = { -9,
273
-9,-32768,-32768, -9, 34,-32768, 11, -9, -9, -9,
274
-9, -9, -9, -9,-32768, 24, 39, 43, 16, 26,
275
-3,-32768, -9, 34, 21, 53,-32768
276
};
277
278
static const short yypgoto[] = {-32768,
279
-1
280
};
281
282
283
#define YYLAST 53
284
285
286
static const short yytable[] = { 6,
287
1, 2, 7, 3, 4, 14, 16, 17, 18, 19,
288
20, 21, 22, 8, 9, 10, 11, 12, 13, 14,
289
26, 24, 12, 13, 14, 15, 8, 9, 10, 11,
290
12, 13, 14, 13, 14, 23, 8, 9, 10, 11,
291
12, 13, 14, 10, 11, 12, 13, 14, 11, 12,
292
13, 14, 27
293
};
294
295
static const short yycheck[] = { 1,
296
10, 11, 4, 13, 14, 9, 8, 9, 10, 11,
297
12, 13, 14, 3, 4, 5, 6, 7, 8, 9,
298
0, 23, 7, 8, 9, 15, 3, 4, 5, 6,
299
7, 8, 9, 8, 9, 12, 3, 4, 5, 6,
300
7, 8, 9, 5, 6, 7, 8, 9, 6, 7,
301
8, 9, 0
302
};
303
#define YYPURE 1
304
305
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
306
#line 3 "/home/haible/gnu/arch/linuxlibc6/share/bison.simple"
307
/* This file comes from bison-1.28. */
308
309
/* Skeleton output parser for bison,
310
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
311
312
This program is free software; you can redistribute it and/or modify
313
it under the terms of the GNU General Public License as published by
314
the Free Software Foundation; either version 2, or (at your option)
315
any later version.
316
317
This program is distributed in the hope that it will be useful,
318
but WITHOUT ANY WARRANTY; without even the implied warranty of
319
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
320
GNU General Public License for more details.
321
322
You should have received a copy of the GNU General Public License
323
along with this program; if not, write to the Free Software
324
Foundation, Inc., 59 Temple Place - Suite 330,
325
Boston, MA 02111-1307, USA. */
326
327
/* As a special exception, when this file is copied by Bison into a
328
Bison output file, you may use that output file without restriction.
329
This special exception was added by the Free Software Foundation
330
in version 1.24 of Bison. */
331
332
/* This is the parser code that is written into each bison parser
333
when the %semantic_parser declaration is not specified in the grammar.
334
It was written by Richard Stallman by simplifying the hairy parser
335
used when %semantic_parser is specified. */
336
337
#ifndef YYSTACK_USE_ALLOCA
338
#ifdef alloca
339
#define YYSTACK_USE_ALLOCA
340
#else /* alloca not defined */
341
#ifdef __GNUC__
342
#define YYSTACK_USE_ALLOCA
343
#define alloca __builtin_alloca
344
#else /* not GNU C. */
345
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
346
#define YYSTACK_USE_ALLOCA
347
#include <alloca.h>
348
#else /* not sparc */
349
/* We think this test detects Watcom and Microsoft C. */
350
/* This used to test MSDOS, but that is a bad idea
351
since that symbol is in the user namespace. */
352
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
353
#if 0 /* No need for malloc.h, which pollutes the namespace;
354
instead, just don't use alloca. */
355
#include <malloc.h>
356
#endif
357
#else /* not MSDOS, or __TURBOC__ */
358
#if defined(_AIX)
359
/* I don't know what this was needed for, but it pollutes the namespace.
360
So I turned it off. rms, 2 May 1997. */
361
/* #include <malloc.h> */
362
#pragma alloca
363
#define YYSTACK_USE_ALLOCA
364
#else /* not MSDOS, or __TURBOC__, or _AIX */
365
#if 0
366
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
367
and on HPUX 10. Eventually we can turn this on. */
368
#define YYSTACK_USE_ALLOCA
369
#define alloca __builtin_alloca
370
#endif /* __hpux */
371
#endif
372
#endif /* not _AIX */
373
#endif /* not MSDOS, or __TURBOC__ */
374
#endif /* not sparc */
375
#endif /* not GNU C */
376
#endif /* alloca not defined */
377
#endif /* YYSTACK_USE_ALLOCA not defined */
378
379
#ifdef YYSTACK_USE_ALLOCA
380
#define YYSTACK_ALLOC alloca
381
#else
382
#define YYSTACK_ALLOC malloc
383
#endif
384
385
/* Note: there must be only one dollar sign in this file.
386
It is replaced by the list of actions, each action
387
as one case of the switch. */
388
389
#define yyerrok (yyerrstatus = 0)
390
#define yyclearin (yychar = YYEMPTY)
391
#define YYEMPTY -2
392
#define YYEOF 0
393
#define YYACCEPT goto yyacceptlab
394
#define YYABORT goto yyabortlab
395
#define YYERROR goto yyerrlab1
396
/* Like YYERROR except do call yyerror.
397
This remains here temporarily to ease the
398
transition to the new meaning of YYERROR, for GCC.
399
Once GCC version 2 has supplanted version 1, this can go. */
400
#define YYFAIL goto yyerrlab
401
#define YYRECOVERING() (!!yyerrstatus)
402
#define YYBACKUP(token, value) \
403
do \
404
if (yychar == YYEMPTY && yylen == 1) \
405
{ yychar = (token), yylval = (value); \
406
yychar1 = YYTRANSLATE (yychar); \
407
YYPOPSTACK; \
408
goto yybackup; \
409
} \
410
else \
411
{ yyerror ("syntax error: cannot back up"); YYERROR; } \
412
while (0)
413
414
#define YYTERROR 1
415
#define YYERRCODE 256
416
417
#ifndef YYPURE
418
#define YYLEX yylex()
419
#endif
420
421
#ifdef YYPURE
422
#ifdef YYLSP_NEEDED
423
#ifdef YYLEX_PARAM
424
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
425
#else
426
#define YYLEX yylex(&yylval, &yylloc)
427
#endif
428
#else /* not YYLSP_NEEDED */
429
#ifdef YYLEX_PARAM
430
#define YYLEX yylex(&yylval, YYLEX_PARAM)
431
#else
432
#define YYLEX yylex(&yylval)
433
#endif
434
#endif /* not YYLSP_NEEDED */
435
#endif
436
437
/* If nonreentrant, generate the variables here */
438
439
#ifndef YYPURE
440
441
int yychar; /* the lookahead symbol */
442
YYSTYPE yylval; /* the semantic value of the */
443
/* lookahead symbol */
444
445
#ifdef YYLSP_NEEDED
446
YYLTYPE yylloc; /* location data for the lookahead */
447
/* symbol */
448
#endif
449
450
int yynerrs; /* number of parse errors so far */
451
#endif /* not YYPURE */
452
453
#if YYDEBUG != 0
454
int yydebug; /* nonzero means print parse trace */
455
/* Since this is uninitialized, it does not stop multiple parsers
456
from coexisting. */
457
#endif
458
459
/* YYINITDEPTH indicates the initial size of the parser's stacks */
460
461
#ifndef YYINITDEPTH
462
#define YYINITDEPTH 200
463
#endif
464
465
/* YYMAXDEPTH is the maximum size the stacks can grow to
466
(effective only if the built-in stack extension method is used). */
467
468
#if YYMAXDEPTH == 0
469
#undef YYMAXDEPTH
470
#endif
471
472
#ifndef YYMAXDEPTH
473
#define YYMAXDEPTH 10000
474
#endif
475
476
/* Define __yy_memcpy. Note that the size argument
477
should be passed with type unsigned int, because that is what the non-GCC
478
definitions require. With GCC, __builtin_memcpy takes an arg
479
of type size_t, but it can handle unsigned int. */
480
481
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
482
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
483
#else /* not GNU C or C++ */
484
#ifndef __cplusplus
485
486
/* This is the most reliable way to avoid incompatibilities
487
in available built-in functions on various systems. */
488
static void
489
__yy_memcpy (to, from, count)
490
char *to;
491
char *from;
492
unsigned int count;
493
{
494
register char *f = from;
495
register char *t = to;
496
register int i = count;
497
498
while (i-- > 0)
499
*t++ = *f++;
500
}
501
502
#else /* __cplusplus */
503
504
/* This is the most reliable way to avoid incompatibilities
505
in available built-in functions on various systems. */
506
static void
507
__yy_memcpy (char *to, char *from, unsigned int count)
508
{
509
register char *t = to;
510
register char *f = from;
511
register int i = count;
512
513
while (i-- > 0)
514
*t++ = *f++;
515
}
516
517
#endif
518
#endif
519
520
#line 217 "/home/haible/gnu/arch/linuxlibc6/share/bison.simple"
521
522
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
523
into yyparse. The argument should have type void *.
524
It should actually point to an object.
525
Grammar actions can access the variable by casting it
526
to the proper pointer type. */
527
528
#ifdef YYPARSE_PARAM
529
#ifdef __cplusplus
530
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
531
#define YYPARSE_PARAM_DECL
532
#else /* not __cplusplus */
533
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
534
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
535
#endif /* not __cplusplus */
536
#else /* not YYPARSE_PARAM */
537
#define YYPARSE_PARAM_ARG
538
#define YYPARSE_PARAM_DECL
539
#endif /* not YYPARSE_PARAM */
540
541
/* Prevent warning if -Wstrict-prototypes. */
542
#ifdef __GNUC__
543
#ifdef YYPARSE_PARAM
544
int yyparse (void *);
545
#else
546
int yyparse (void);
547
#endif
548
#endif
549
550
int
551
yyparse(YYPARSE_PARAM_ARG)
552
YYPARSE_PARAM_DECL
553
{
554
register int yystate;
555
register int yyn;
556
register short *yyssp;
557
register YYSTYPE *yyvsp;
558
int yyerrstatus; /* number of tokens to shift before error messages enabled */
559
int yychar1 = 0; /* lookahead token as an internal (translated) token number */
560
561
short yyssa[YYINITDEPTH]; /* the state stack */
562
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
563
564
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
565
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
566
567
#ifdef YYLSP_NEEDED
568
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
569
YYLTYPE *yyls = yylsa;
570
YYLTYPE *yylsp;
571
572
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
573
#else
574
#define YYPOPSTACK (yyvsp--, yyssp--)
575
#endif
576
577
int yystacksize = YYINITDEPTH;
578
int yyfree_stacks = 0;
579
580
#ifdef YYPURE
581
int yychar;
582
YYSTYPE yylval;
583
int yynerrs;
584
#ifdef YYLSP_NEEDED
585
YYLTYPE yylloc;
586
#endif
587
#endif
588
589
YYSTYPE yyval; /* the variable used to return */
590
/* semantic values from the action */
591
/* routines */
592
593
int yylen;
594
595
#if YYDEBUG != 0
596
if (yydebug)
597
fprintf(stderr, "Starting parse\n");
598
#endif
599
600
yystate = 0;
601
yyerrstatus = 0;
602
yynerrs = 0;
603
yychar = YYEMPTY; /* Cause a token to be read. */
604
605
/* Initialize stack pointers.
606
Waste one element of value and location stack
607
so that they stay on the same level as the state stack.
608
The wasted elements are never initialized. */
609
610
yyssp = yyss - 1;
611
yyvsp = yyvs;
612
#ifdef YYLSP_NEEDED
613
yylsp = yyls;
614
#endif
615
616
/* Push a new state, which is found in yystate . */
617
/* In all cases, when you get here, the value and location stacks
618
have just been pushed. so pushing a state here evens the stacks. */
619
yynewstate:
620
621
*++yyssp = yystate;
622
623
if (yyssp >= yyss + yystacksize - 1)
624
{
625
/* Give user a chance to reallocate the stack */
626
/* Use copies of these so that the &'s don't force the real ones into memory. */
627
YYSTYPE *yyvs1 = yyvs;
628
short *yyss1 = yyss;
629
#ifdef YYLSP_NEEDED
630
YYLTYPE *yyls1 = yyls;
631
#endif
632
633
/* Get the current used size of the three stacks, in elements. */
634
int size = yyssp - yyss + 1;
635
636
#ifdef yyoverflow
637
/* Each stack pointer address is followed by the size of
638
the data in use in that stack, in bytes. */
639
#ifdef YYLSP_NEEDED
640
/* This used to be a conditional around just the two extra args,
641
but that might be undefined if yyoverflow is a macro. */
642
yyoverflow("parser stack overflow",
643
&yyss1, size * sizeof (*yyssp),
644
&yyvs1, size * sizeof (*yyvsp),
645
&yyls1, size * sizeof (*yylsp),
646
&yystacksize);
647
#else
648
yyoverflow("parser stack overflow",
649
&yyss1, size * sizeof (*yyssp),
650
&yyvs1, size * sizeof (*yyvsp),
651
&yystacksize);
652
#endif
653
654
yyss = yyss1; yyvs = yyvs1;
655
#ifdef YYLSP_NEEDED
656
yyls = yyls1;
657
#endif
658
#else /* no yyoverflow */
659
/* Extend the stack our own way. */
660
if (yystacksize >= YYMAXDEPTH)
661
{
662
yyerror("parser stack overflow");
663
if (yyfree_stacks)
664
{
665
free (yyss);
666
free (yyvs);
667
#ifdef YYLSP_NEEDED
668
free (yyls);
669
#endif
670
}
671
return 2;
672
}
673
yystacksize *= 2;
674
if (yystacksize > YYMAXDEPTH)
675
yystacksize = YYMAXDEPTH;
676
#ifndef YYSTACK_USE_ALLOCA
677
yyfree_stacks = 1;
678
#endif
679
yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
680
__yy_memcpy ((char *)yyss, (char *)yyss1,
681
size * (unsigned int) sizeof (*yyssp));
682
yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
683
__yy_memcpy ((char *)yyvs, (char *)yyvs1,
684
size * (unsigned int) sizeof (*yyvsp));
685
#ifdef YYLSP_NEEDED
686
yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
687
__yy_memcpy ((char *)yyls, (char *)yyls1,
688
size * (unsigned int) sizeof (*yylsp));
689
#endif
690
#endif /* no yyoverflow */
691
692
yyssp = yyss + size - 1;
693
yyvsp = yyvs + size - 1;
694
#ifdef YYLSP_NEEDED
695
yylsp = yyls + size - 1;
696
#endif
697
698
#if YYDEBUG != 0
699
if (yydebug)
700
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
701
#endif
702
703
if (yyssp >= yyss + yystacksize - 1)
704
YYABORT;
705
}
706
707
#if YYDEBUG != 0
708
if (yydebug)
709
fprintf(stderr, "Entering state %d\n", yystate);
710
#endif
711
712
goto yybackup;
713
yybackup:
714
715
/* Do appropriate processing given the current state. */
716
/* Read a lookahead token if we need one and don't already have one. */
717
/* yyresume: */
718
719
/* First try to decide what to do without reference to lookahead token. */
720
721
yyn = yypact[yystate];
722
if (yyn == YYFLAG)
723
goto yydefault;
724
725
/* Not known => get a lookahead token if don't already have one. */
726
727
/* yychar is either YYEMPTY or YYEOF
728
or a valid token in external form. */
729
730
if (yychar == YYEMPTY)
731
{
732
#if YYDEBUG != 0
733
if (yydebug)
734
fprintf(stderr, "Reading a token: ");
735
#endif
736
yychar = YYLEX;
737
}
738
739
/* Convert token to internal form (in yychar1) for indexing tables with */
740
741
if (yychar <= 0) /* This means end of input. */
742
{
743
yychar1 = 0;
744
yychar = YYEOF; /* Don't call YYLEX any more */
745
746
#if YYDEBUG != 0
747
if (yydebug)
748
fprintf(stderr, "Now at end of input.\n");
749
#endif
750
}
751
else
752
{
753
yychar1 = YYTRANSLATE(yychar);
754
755
#if YYDEBUG != 0
756
if (yydebug)
757
{
758
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
759
/* Give the individual parser a way to print the precise meaning
760
of a token, for further debugging info. */
761
#ifdef YYPRINT
762
YYPRINT (stderr, yychar, yylval);
763
#endif
764
fprintf (stderr, ")\n");
765
}
766
#endif
767
}
768
769
yyn += yychar1;
770
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
771
goto yydefault;
772
773
yyn = yytable[yyn];
774
775
/* yyn is what to do for this token type in this state.
776
Negative => reduce, -yyn is rule number.
777
Positive => shift, yyn is new state.
778
New state is final state => don't bother to shift,
779
just return success.
780
0, or most negative number => error. */
781
782
if (yyn < 0)
783
{
784
if (yyn == YYFLAG)
785
goto yyerrlab;
786
yyn = -yyn;
787
goto yyreduce;
788
}
789
else if (yyn == 0)
790
goto yyerrlab;
791
792
if (yyn == YYFINAL)
793
YYACCEPT;
794
795
/* Shift the lookahead token. */
796
797
#if YYDEBUG != 0
798
if (yydebug)
799
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
800
#endif
801
802
/* Discard the token being shifted unless it is eof. */
803
if (yychar != YYEOF)
804
yychar = YYEMPTY;
805
806
*++yyvsp = yylval;
807
#ifdef YYLSP_NEEDED
808
*++yylsp = yylloc;
809
#endif
810
811
/* count tokens shifted since error; after three, turn off error status. */
812
if (yyerrstatus) yyerrstatus--;
813
814
yystate = yyn;
815
goto yynewstate;
816
817
/* Do the default action for the current state. */
818
yydefault:
819
820
yyn = yydefact[yystate];
821
if (yyn == 0)
822
goto yyerrlab;
823
824
/* Do a reduction. yyn is the number of a rule to reduce with. */
825
yyreduce:
826
yylen = yyr2[yyn];
827
if (yylen > 0)
828
yyval = yyvsp[1-yylen]; /* implement default value of the action */
829
830
#if YYDEBUG != 0
831
if (yydebug)
832
{
833
int i;
834
835
fprintf (stderr, "Reducing via rule %d (line %d), ",
836
yyn, yyrline[yyn]);
837
838
/* Print the symbols being reduced, and their result. */
839
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
840
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
841
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
842
}
843
#endif
844
845
846
switch (yyn) {
847
848
case 1:
849
#line 179 "plural.y"
850
{
851
if (yyvsp[0].exp == NULL)
852
YYABORT;
853
((struct parse_args *) arg)->res = yyvsp[0].exp;
854
;
855
break;}
856
case 2:
857
#line 187 "plural.y"
858
{
859
yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
860
;
861
break;}
862
case 3:
863
#line 191 "plural.y"
864
{
865
yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
866
;
867
break;}
868
case 4:
869
#line 195 "plural.y"
870
{
871
yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
872
;
873
break;}
874
case 5:
875
#line 199 "plural.y"
876
{
877
yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
878
;
879
break;}
880
case 6:
881
#line 203 "plural.y"
882
{
883
yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
884
;
885
break;}
886
case 7:
887
#line 207 "plural.y"
888
{
889
yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
890
;
891
break;}
892
case 8:
893
#line 211 "plural.y"
894
{
895
yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
896
;
897
break;}
898
case 9:
899
#line 215 "plural.y"
900
{
901
yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
902
;
903
break;}
904
case 10:
905
#line 219 "plural.y"
906
{
907
yyval.exp = new_exp_0 (var);
908
;
909
break;}
910
case 11:
911
#line 223 "plural.y"
912
{
913
if ((yyval.exp = new_exp_0 (num)) != NULL)
914
yyval.exp->val.num = yyvsp[0].num;
915
;
916
break;}
917
case 12:
918
#line 228 "plural.y"
919
{
920
yyval.exp = yyvsp[-1].exp;
921
;
922
break;}
923
}
924
/* the action file gets copied in in place of this dollarsign */
925
#line 543 "/home/haible/gnu/arch/linuxlibc6/share/bison.simple"
926
927
yyvsp -= yylen;
928
yyssp -= yylen;
929
#ifdef YYLSP_NEEDED
930
yylsp -= yylen;
931
#endif
932
933
#if YYDEBUG != 0
934
if (yydebug)
935
{
936
short *ssp1 = yyss - 1;
937
fprintf (stderr, "state stack now");
938
while (ssp1 != yyssp)
939
fprintf (stderr, " %d", *++ssp1);
940
fprintf (stderr, "\n");
941
}
942
#endif
943
944
*++yyvsp = yyval;
945
946
#ifdef YYLSP_NEEDED
947
yylsp++;
948
if (yylen == 0)
949
{
950
yylsp->first_line = yylloc.first_line;
951
yylsp->first_column = yylloc.first_column;
952
yylsp->last_line = (yylsp-1)->last_line;
953
yylsp->last_column = (yylsp-1)->last_column;
954
yylsp->text = 0;
955
}
956
else
957
{
958
yylsp->last_line = (yylsp+yylen-1)->last_line;
959
yylsp->last_column = (yylsp+yylen-1)->last_column;
960
}
961
#endif
962
963
/* Now "shift" the result of the reduction.
964
Determine what state that goes to,
965
based on the state we popped back to
966
and the rule number reduced by. */
967
968
yyn = yyr1[yyn];
969
970
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
971
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
972
yystate = yytable[yystate];
973
else
974
yystate = yydefgoto[yyn - YYNTBASE];
975
976
goto yynewstate;
977
978
yyerrlab: /* here on detecting error */
979
980
if (! yyerrstatus)
981
/* If not already recovering from an error, report this error. */
982
{
983
++yynerrs;
984
985
#ifdef YYERROR_VERBOSE
986
yyn = yypact[yystate];
987
988
if (yyn > YYFLAG && yyn < YYLAST)
989
{
990
int size = 0;
991
char *msg;
992
int x, count;
993
994
count = 0;
995
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
996
for (x = (yyn < 0 ? -yyn : 0);
997
x < (sizeof(yytname) / sizeof(char *)); x++)
998
if (yycheck[x + yyn] == x)
999
size += strlen(yytname[x]) + 15, count++;
1000
msg = (char *) malloc(size + 15);
1001
if (msg != 0)
1002
{
1003
strcpy(msg, "parse error");
1004
1005
if (count < 5)
1006
{
1007
count = 0;
1008
for (x = (yyn < 0 ? -yyn : 0);
1009
x < (sizeof(yytname) / sizeof(char *)); x++)
1010
if (yycheck[x + yyn] == x)
1011
{
1012
strcat(msg, count == 0 ? ", expecting `" : " or `");
1013
strcat(msg, yytname[x]);
1014
strcat(msg, "'");
1015
count++;
1016
}
1017
}
1018
yyerror(msg);
1019
free(msg);
1020
}
1021
else
1022
yyerror ("parse error; also virtual memory exceeded");
1023
}
1024
else
1025
#endif /* YYERROR_VERBOSE */
1026
yyerror("parse error");
1027
}
1028
1029
goto yyerrlab1;
1030
yyerrlab1: /* here on error raised explicitly by an action */
1031
1032
if (yyerrstatus == 3)
1033
{
1034
/* if just tried and failed to reuse lookahead token after an error, discard it. */
1035
1036
/* return failure if at end of input */
1037
if (yychar == YYEOF)
1038
YYABORT;
1039
1040
#if YYDEBUG != 0
1041
if (yydebug)
1042
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1043
#endif
1044
1045
yychar = YYEMPTY;
1046
}
1047
1048
/* Else will try to reuse lookahead token
1049
after shifting the error token. */
1050
1051
yyerrstatus = 3; /* Each real token shifted decrements this */
1052
1053
goto yyerrhandle;
1054
1055
yyerrdefault: /* current state does not do anything special for the error token. */
1056
1057
#if 0
1058
/* This is wrong; only states that explicitly want error tokens
1059
should shift them. */
1060
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1061
if (yyn) goto yydefault;
1062
#endif
1063
1064
yyerrpop: /* pop the current state because it cannot handle the error token */
1065
1066
if (yyssp == yyss) YYABORT;
1067
yyvsp--;
1068
yystate = *--yyssp;
1069
#ifdef YYLSP_NEEDED
1070
yylsp--;
1071
#endif
1072
1073
#if YYDEBUG != 0
1074
if (yydebug)
1075
{
1076
short *ssp1 = yyss - 1;
1077
fprintf (stderr, "Error: state stack now");
1078
while (ssp1 != yyssp)
1079
fprintf (stderr, " %d", *++ssp1);
1080
fprintf (stderr, "\n");
1081
}
1082
#endif
1083
1084
yyerrhandle:
1085
1086
yyn = yypact[yystate];
1087
if (yyn == YYFLAG)
1088
goto yyerrdefault;
1089
1090
yyn += YYTERROR;
1091
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1092
goto yyerrdefault;
1093
1094
yyn = yytable[yyn];
1095
if (yyn < 0)
1096
{
1097
if (yyn == YYFLAG)
1098
goto yyerrpop;
1099
yyn = -yyn;
1100
goto yyreduce;
1101
}
1102
else if (yyn == 0)
1103
goto yyerrpop;
1104
1105
if (yyn == YYFINAL)
1106
YYACCEPT;
1107
1108
#if YYDEBUG != 0
1109
if (yydebug)
1110
fprintf(stderr, "Shifting error token, ");
1111
#endif
1112
1113
*++yyvsp = yylval;
1114
#ifdef YYLSP_NEEDED
1115
*++yylsp = yylloc;
1116
#endif
1117
1118
yystate = yyn;
1119
goto yynewstate;
1120
1121
yyacceptlab:
1122
/* YYACCEPT comes here. */
1123
if (yyfree_stacks)
1124
{
1125
free (yyss);
1126
free (yyvs);
1127
#ifdef YYLSP_NEEDED
1128
free (yyls);
1129
#endif
1130
}
1131
return 0;
1132
1133
yyabortlab:
1134
/* YYABORT comes here. */
1135
if (yyfree_stacks)
1136
{
1137
free (yyss);
1138
free (yyvs);
1139
#ifdef YYLSP_NEEDED
1140
free (yyls);
1141
#endif
1142
}
1143
return 1;
1144
}
1145
#line 233 "plural.y"
1146
1147
1148
void
1149
internal_function
1150
FREE_EXPRESSION (exp)
1151
struct expression *exp;
1152
{
1153
if (exp == NULL)
1154
return;
1155
1156
/* Handle the recursive case. */
1157
switch (exp->nargs)
1158
{
1159
case 3:
1160
FREE_EXPRESSION (exp->val.args[2]);
1161
/* FALLTHROUGH */
1162
case 2:
1163
FREE_EXPRESSION (exp->val.args[1]);
1164
/* FALLTHROUGH */
1165
case 1:
1166
FREE_EXPRESSION (exp->val.args[0]);
1167
/* FALLTHROUGH */
1168
default:
1169
break;
1170
}
1171
1172
free (exp);
1173
}
1174
1175
1176
static int
1177
yylex (lval, pexp)
1178
YYSTYPE *lval;
1179
const char **pexp;
1180
{
1181
const char *exp = *pexp;
1182
int result;
1183
1184
while (1)
1185
{
1186
if (exp[0] == '\0')
1187
{
1188
*pexp = exp;
1189
return YYEOF;
1190
}
1191
1192
if (exp[0] != ' ' && exp[0] != '\t')
1193
break;
1194
1195
++exp;
1196
}
1197
1198
result = *exp++;
1199
switch (result)
1200
{
1201
case '0': case '1': case '2': case '3': case '4':
1202
case '5': case '6': case '7': case '8': case '9':
1203
{
1204
unsigned long int n = result - '0';
1205
while (exp[0] >= '0' && exp[0] <= '9')
1206
{
1207
n *= 10;
1208
n += exp[0] - '0';
1209
++exp;
1210
}
1211
lval->num = n;
1212
result = NUMBER;
1213
}
1214
break;
1215
1216
case '=':
1217
if (exp[0] == '=')
1218
{
1219
++exp;
1220
lval->op = equal;
1221
result = EQUOP2;
1222
}
1223
else
1224
result = YYERRCODE;
1225
break;
1226
1227
case '!':
1228
if (exp[0] == '=')
1229
{
1230
++exp;
1231
lval->op = not_equal;
1232
result = EQUOP2;
1233
}
1234
break;
1235
1236
case '&':
1237
case '|':
1238
if (exp[0] == result)
1239
++exp;
1240
else
1241
result = YYERRCODE;
1242
break;
1243
1244
case '<':
1245
if (exp[0] == '=')
1246
{
1247
++exp;
1248
lval->op = less_or_equal;
1249
}
1250
else
1251
lval->op = less_than;
1252
result = CMPOP2;
1253
break;
1254
1255
case '>':
1256
if (exp[0] == '=')
1257
{
1258
++exp;
1259
lval->op = greater_or_equal;
1260
}
1261
else
1262
lval->op = greater_than;
1263
result = CMPOP2;
1264
break;
1265
1266
case '*':
1267
lval->op = mult;
1268
result = MULOP2;
1269
break;
1270
1271
case '/':
1272
lval->op = divide;
1273
result = MULOP2;
1274
break;
1275
1276
case '%':
1277
lval->op = module;
1278
result = MULOP2;
1279
break;
1280
1281
case '+':
1282
lval->op = plus;
1283
result = ADDOP2;
1284
break;
1285
1286
case '-':
1287
lval->op = minus;
1288
result = ADDOP2;
1289
break;
1290
1291
case 'n':
1292
case '?':
1293
case ':':
1294
case '(':
1295
case ')':
1296
/* Nothing, just return the character. */
1297
break;
1298
1299
case ';':
1300
case '\n':
1301
case '\0':
1302
/* Be safe and let the user call this function again. */
1303
--exp;
1304
result = YYEOF;
1305
break;
1306
1307
default:
1308
result = YYERRCODE;
1309
#if YYDEBUG != 0
1310
--exp;
1311
#endif
1312
break;
1313
}
1314
1315
*pexp = exp;
1316
1317
return result;
1318
}
1319
1320
1321
static void
1322
yyerror (str)
1323
const char *str;
1324
{
1325
/* Do nothing. We don't print error messages here. */
1326
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1