← Back to branch summary

~ubuntu-branches/debian/sid/vorbis-tools/sid

« back to all changes in this revision

Viewing changes to intl/plural.c

  • Committer: Bazaar Package Importer
  • Author(s): John Francesco Ferlito
  • Date: 2010-04-05 14:05:24 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20100405140524-jjqkbl1r2sxbydrb
Tags: 1.4.0-1
http://bugs.debian.org/575677
http://bugs.debian.org/528802
http://bugs.debian.org/333437
http://bugs.debian.org/333442
http://bugs.debian.org/417606
http://bugs.debian.org/437093
http://bugs.debian.org/425549
http://bugs.debian.org/362530
http://bugs.debian.org/264365
http://bugs.debian.org/272037
http://bugs.debian.org/507230
* New upstream release. (Closes: #575677)
  - remove patches/for_upstream-manpage_typos.diff.
  - remove patches/upstream_r14728-speex_format_validation.diff.
  - remove patches/upstream_r14957-ogg123_stop_decode_on_closed_buffer.diff.
  - remove patches/upstream_r14982-ogg123_man_page_http_only.diff.
  - ogg123 thinks any file it opens is seekable.  (Closes: #528802)
  - oggenc confuses minimum and maximum bitrate. (Closes: #333437)
  - Files encoded with oggenc show a false min/max bitrate.  (Closes: #333442)
  - vorbiscomment manpage is unclear about clearing tags. (Closes: #417606)
  - time overflow in oggenc. (Closes: #437093)
  - ogg123: duhk at the end of files.ogg. (Closes: #425549)
  - please support replaygain. (Closes: #362530)
  - /usr/bin/oggenc: Please escape dashes in the manpage. (Closes: #264365)
  - vorbis-tools: [INTL:hu] New Hungarian translation. (Closes: #272037)
* Allow global tag editing in vorbistagedit. (Closes: #507230)
* debian/compat
  - Moved to version 7
* debian/control
  - Added ${misc:Depends}.
  - Bumped dependency on debhelper to 7.0.50~.
  - Depend on libao >= 1.0.0
  - Depend on libvorbis >= 1.3.0
* Added debian/docs
* Moved to debhelper 7 style dh rules
* Add source/format, 1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
intl/plural.c
1
 
/* A Bison parser, made from plural.y
2
 
   by GNU bison 1.35.  */
3
 
 
4
 
#define YYBISON 1  /* Identify Bison output.  */
5
 
 
 
1
/* A Bison parser, made by GNU Bison 2.3.  */
 
2
 
 
3
/* Skeleton implementation for Bison's Yacc-like parsers in C
 
4
 
 
5
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
 
6
   Free Software Foundation, Inc.
 
7
 
 
8
   This program is free software; you can redistribute it and/or modify
 
9
   it under the terms of the GNU General Public License as published by
 
10
   the Free Software Foundation; either version 2, or (at your option)
 
11
   any later version.
 
12
 
 
13
   This program is distributed in the hope that it will be useful,
 
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
   GNU General Public License for more details.
 
17
 
 
18
   You should have received a copy of the GNU General Public License
 
19
   along with this program; if not, write to the Free Software
 
20
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
21
   Boston, MA 02110-1301, USA.  */
 
22
 
 
23
/* As a special exception, you may create a larger work that contains
 
24
   part or all of the Bison parser skeleton and distribute that work
 
25
   under terms of your choice, so long as that work isn't itself a
 
26
   parser generator using the skeleton or a modified version thereof
 
27
   as a parser skeleton.  Alternatively, if you modify or redistribute
 
28
   the parser skeleton itself, you may (at your option) remove this
 
29
   special exception, which will cause the skeleton and the resulting
 
30
   Bison output files to be licensed under the GNU General Public
 
31
   License without this special exception.
 
32
 
 
33
   This special exception was added by the Free Software Foundation in
 
34
   version 2.2 of Bison.  */
 
35
 
 
36
/* C LALR(1) parser skeleton written by Richard Stallman, by
 
37
   simplifying the original so-called "semantic" parser.  */
 
38
 
 
39
/* All symbols defined below should begin with yy or YY, to avoid
 
40
   infringing on user name space.  This should be done even for local
 
41
   variables, as they might otherwise be expanded by user macros.
 
42
   There are some unavoidable exceptions within include files to
 
43
   define necessary library symbols; they are noted "INFRINGES ON
 
44
   USER NAME SPACE" below.  */
 
45
 
 
46
/* Identify Bison output.  */
 
47
#define YYBISON 1
 
48
 
 
49
/* Bison version.  */
 
50
#define YYBISON_VERSION "2.3"
 
51
 
 
52
/* Skeleton name.  */
 
53
#define YYSKELETON_NAME "yacc.c"
 
54
 
 
55
/* Pure parsers.  */
 
56
#define YYPURE 1
 
57
 
 
58
/* Using locations.  */
 
59
#define YYLSP_NEEDED 0
 
60
 
 
61
/* Substitute the variable and function names.  */
6
62
#define yyparse __gettextparse
7
 
#define yylex __gettextlex
 
63
#define yylex   __gettextlex
8
64
#define yyerror __gettexterror
9
 
#define yylval __gettextlval
10
 
#define yychar __gettextchar
 
65
#define yylval  __gettextlval
 
66
#define yychar  __gettextchar
11
67
#define yydebug __gettextdebug
12
68
#define yynerrs __gettextnerrs
13
 
# define        EQUOP2  257
14
 
# define        CMPOP2  258
15
 
# define        ADDOP2  259
16
 
# define        MULOP2  260
17
 
# define        NUMBER  261
18
 
 
 
69
 
 
70
 
 
71
/* Tokens.  */
 
72
#ifndef YYTOKENTYPE
 
73
# define YYTOKENTYPE
 
74
   /* Put the tokens into the symbol table, so that GDB and other debuggers
 
75
      know about them.  */
 
76
   enum yytokentype {
 
77
     EQUOP2 = 258,
 
78
     CMPOP2 = 259,
 
79
     ADDOP2 = 260,
 
80
     MULOP2 = 261,
 
81
     NUMBER = 262
 
82
   };
 
83
#endif
 
84
/* Tokens.  */
 
85
#define EQUOP2 258
 
86
#define CMPOP2 259
 
87
#define ADDOP2 260
 
88
#define MULOP2 261
 
89
#define NUMBER 262
 
90
 
 
91
 
 
92
 
 
93
 
 
94
/* Copy the first part of user declarations.  */
19
95
#line 1 "plural.y"
20
96
 
21
97
/* Expression parsing for plural form selection.
22
 
   Copyright (C) 2000-2001, 2003, 2005 Free Software Foundation, Inc.
 
98
   Copyright (C) 2000-2001, 2003, 2005-2006 Free Software Foundation, Inc.
23
99
   Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
24
100
 
25
101
   This program is free software; you can redistribute it and/or modify it
64
140
#define YYLEX_PARAM     &((struct parse_args *) arg)->cp
65
141
#define YYPARSE_PARAM   arg
66
142
 
 
143
 
 
144
/* Enabling traces.  */
 
145
#ifndef YYDEBUG
 
146
# define YYDEBUG 0
 
147
#endif
 
148
 
 
149
/* Enabling verbose error messages.  */
 
150
#ifdef YYERROR_VERBOSE
 
151
# undef YYERROR_VERBOSE
 
152
# define YYERROR_VERBOSE 1
 
153
#else
 
154
# define YYERROR_VERBOSE 0
 
155
#endif
 
156
 
 
157
/* Enabling the token table.  */
 
158
#ifndef YYTOKEN_TABLE
 
159
# define YYTOKEN_TABLE 0
 
160
#endif
 
161
 
 
162
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 
163
typedef union YYSTYPE
67
164
#line 51 "plural.y"
68
 
#ifndef YYSTYPE
69
 
typedef union {
 
165
{
70
166
  unsigned long int num;
71
 
  enum operator op;
 
167
  enum expression_operator op;
72
168
  struct expression *exp;
73
 
} yystype;
74
 
# define YYSTYPE yystype
 
169
}
 
170
/* Line 187 of yacc.c.  */
 
171
#line 172 "plural.c"
 
172
        YYSTYPE;
 
173
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 
174
# define YYSTYPE_IS_DECLARED 1
75
175
# define YYSTYPE_IS_TRIVIAL 1
76
176
#endif
 
177
 
 
178
 
 
179
 
 
180
/* Copy the second part of user declarations.  */
77
181
#line 57 "plural.y"
78
182
 
79
183
/* Prototypes for local functions.  */
83
187
/* Allocation of expressions.  */
84
188
 
85
189
static struct expression *
86
 
new_exp (int nargs, enum operator op, struct expression * const *args)
 
190
new_exp (int nargs, enum expression_operator op,
 
191
         struct expression * const *args)
87
192
{
88
193
  int i;
89
194
  struct expression *newp;
112
217
}
113
218
 
114
219
static inline struct expression *
115
 
new_exp_0 (enum operator op)
 
220
new_exp_0 (enum expression_operator op)
116
221
{
117
222
  return new_exp (0, op, NULL);
118
223
}
119
224
 
120
225
static inline struct expression *
121
 
new_exp_1 (enum operator op, struct expression *right)
 
226
new_exp_1 (enum expression_operator op, struct expression *right)
122
227
{
123
228
  struct expression *args[1];
124
229
 
127
232
}
128
233
 
129
234
static struct expression *
130
 
new_exp_2 (enum operator op, struct expression *left, struct expression *right)
 
235
new_exp_2 (enum expression_operator op, struct expression *left,
 
236
           struct expression *right)
131
237
{
132
238
  struct expression *args[2];
133
239
 
137
243
}
138
244
 
139
245
static inline struct expression *
140
 
new_exp_3 (enum operator op, struct expression *bexp,
 
246
new_exp_3 (enum expression_operator op, struct expression *bexp,
141
247
           struct expression *tbranch, struct expression *fbranch)
142
248
{
143
249
  struct expression *args[3];
148
254
  return new_exp (3, op, args);
149
255
}
150
256
 
151
 
#ifndef YYDEBUG
152
 
# define YYDEBUG 0
153
 
#endif
154
 
 
155
 
 
156
 
 
157
 
#define YYFINAL         27
158
 
#define YYFLAG          -32768
159
 
#define YYNTBASE        16
160
 
 
161
 
/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
162
 
#define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
163
 
 
164
 
/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
165
 
static const char yytranslate[] =
166
 
{
167
 
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
168
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
169
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
170
 
       2,     2,     2,    10,     2,     2,     2,     2,     5,     2,
171
 
      14,    15,     2,     2,     2,     2,     2,     2,     2,     2,
172
 
       2,     2,     2,     2,     2,     2,     2,     2,    12,     2,
173
 
       2,     2,     2,     3,     2,     2,     2,     2,     2,     2,
174
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
175
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
176
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
177
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
178
 
      13,     2,     2,     2,     2,     2,     2,     2,     2,     2,
179
 
       2,     2,     2,     2,     4,     2,     2,     2,     2,     2,
180
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
181
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
182
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
183
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
184
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
185
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
186
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
187
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
188
 
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
189
 
       2,     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,     2,     2,     2,     1,     6,     7,     8,
193
 
       9,    11
194
 
};
195
 
 
196
 
#if YYDEBUG
197
 
static const short yyprhs[] =
198
 
{
199
 
       0,     0,     2,     8,    12,    16,    20,    24,    28,    32,
200
 
      35,    37,    39
201
 
};
202
 
static const short yyrhs[] =
203
 
{
204
 
      17,     0,    17,     3,    17,    12,    17,     0,    17,     4,
205
 
      17,     0,    17,     5,    17,     0,    17,     6,    17,     0,
206
 
      17,     7,    17,     0,    17,     8,    17,     0,    17,     9,
207
 
      17,     0,    10,    17,     0,    13,     0,    11,     0,    14,
208
 
      17,    15,     0
209
 
};
210
 
 
211
 
#endif
212
 
 
213
 
#if YYDEBUG
214
 
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
215
 
static const short yyrline[] =
216
 
{
217
 
       0,   152,   160,   164,   168,   172,   176,   180,   184,   188,
218
 
     192,   196,   201
219
 
};
220
 
#endif
221
 
 
222
 
 
223
 
#if (YYDEBUG) || defined YYERROR_VERBOSE
224
 
 
225
 
/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
226
 
static const char *const yytname[] =
227
 
{
228
 
  "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2", 
229
 
  "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'", 
230
 
  "start", "exp", 0
231
 
};
232
 
#endif
233
 
 
234
 
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
235
 
static const short yyr1[] =
236
 
{
237
 
       0,    16,    17,    17,    17,    17,    17,    17,    17,    17,
238
 
      17,    17,    17
239
 
};
240
 
 
241
 
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
242
 
static const short yyr2[] =
243
 
{
244
 
       0,     1,     5,     3,     3,     3,     3,     3,     3,     2,
245
 
       1,     1,     3
246
 
};
247
 
 
248
 
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
249
 
   doesn't specify something else to do.  Zero means the default is an
250
 
   error. */
251
 
static const short yydefact[] =
252
 
{
253
 
       0,     0,    11,    10,     0,     1,     9,     0,     0,     0,
254
 
       0,     0,     0,     0,     0,    12,     0,     3,     4,     5,
255
 
       6,     7,     8,     0,     2,     0,     0,     0
256
 
};
257
 
 
258
 
static const short yydefgoto[] =
259
 
{
260
 
      25,     5
261
 
};
262
 
 
263
 
static const short yypact[] =
264
 
{
265
 
      -9,    -9,-32768,-32768,    -9,    34,-32768,    11,    -9,    -9,
266
 
      -9,    -9,    -9,    -9,    -9,-32768,    24,    39,    43,    16,
267
 
      26,    -3,-32768,    -9,    34,    21,    53,-32768
268
 
};
269
 
 
270
 
static const short yypgoto[] =
271
 
{
272
 
  -32768,    -1
273
 
};
274
 
 
275
 
 
276
 
#define YYLAST          53
277
 
 
278
 
 
279
 
static const short yytable[] =
280
 
{
281
 
       6,     1,     2,     7,     3,     4,    14,    16,    17,    18,
282
 
      19,    20,    21,    22,     8,     9,    10,    11,    12,    13,
283
 
      14,    26,    24,    12,    13,    14,    15,     8,     9,    10,
284
 
      11,    12,    13,    14,    13,    14,    23,     8,     9,    10,
285
 
      11,    12,    13,    14,    10,    11,    12,    13,    14,    11,
286
 
      12,    13,    14,    27
287
 
};
288
 
 
289
 
static const short yycheck[] =
290
 
{
291
 
       1,    10,    11,     4,    13,    14,     9,     8,     9,    10,
292
 
      11,    12,    13,    14,     3,     4,     5,     6,     7,     8,
293
 
       9,     0,    23,     7,     8,     9,    15,     3,     4,     5,
294
 
       6,     7,     8,     9,     8,     9,    12,     3,     4,     5,
295
 
       6,     7,     8,     9,     5,     6,     7,     8,     9,     6,
296
 
       7,     8,     9,     0
297
 
};
298
 
#define YYPURE 1
299
 
 
300
 
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
301
 
#line 3 "bison.simple"
302
 
 
303
 
/* Skeleton output parser for bison,
304
 
 
305
 
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
306
 
   Foundation, Inc.
307
 
 
308
 
   This program is free software; you can redistribute it and/or modify
309
 
   it under the terms of the GNU General Public License as published by
310
 
   the Free Software Foundation; either version 2, or (at your option)
311
 
   any later version.
312
 
 
313
 
   This program is distributed in the hope that it will be useful,
314
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
315
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
316
 
   GNU General Public License for more details.
317
 
 
318
 
   You should have received a copy of the GNU General Public License
319
 
   along with this program; if not, write to the Free Software
320
 
   Foundation, Inc., 59 Temple Place - Suite 330,
321
 
   Boston, MA 02111-1307, USA.  */
322
 
 
323
 
/* As a special exception, when this file is copied by Bison into a
324
 
   Bison output file, you may use that output file without restriction.
325
 
   This special exception was added by the Free Software Foundation
326
 
   in version 1.24 of Bison.  */
327
 
 
328
 
/* This is the parser code that is written into each bison parser when
329
 
   the %semantic_parser declaration is not specified in the grammar.
330
 
   It was written by Richard Stallman by simplifying the hairy parser
331
 
   used when %semantic_parser is specified.  */
332
 
 
333
 
/* All symbols defined below should begin with yy or YY, to avoid
334
 
   infringing on user name space.  This should be done even for local
335
 
   variables, as they might otherwise be expanded by user macros.
336
 
   There are some unavoidable exceptions within include files to
337
 
   define necessary library symbols; they are noted "INFRINGES ON
338
 
   USER NAME SPACE" below.  */
339
 
 
340
 
#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
 
257
 
 
258
 
 
259
/* Line 216 of yacc.c.  */
 
260
#line 261 "plural.c"
 
261
 
 
262
#ifdef short
 
263
# undef short
 
264
#endif
 
265
 
 
266
#ifdef YYTYPE_UINT8
 
267
typedef YYTYPE_UINT8 yytype_uint8;
 
268
#else
 
269
typedef unsigned char yytype_uint8;
 
270
#endif
 
271
 
 
272
#ifdef YYTYPE_INT8
 
273
typedef YYTYPE_INT8 yytype_int8;
 
274
#elif (defined __STDC__ || defined __C99__FUNC__ \
 
275
     || defined __cplusplus || defined _MSC_VER)
 
276
typedef signed char yytype_int8;
 
277
#else
 
278
typedef short int yytype_int8;
 
279
#endif
 
280
 
 
281
#ifdef YYTYPE_UINT16
 
282
typedef YYTYPE_UINT16 yytype_uint16;
 
283
#else
 
284
typedef unsigned short int yytype_uint16;
 
285
#endif
 
286
 
 
287
#ifdef YYTYPE_INT16
 
288
typedef YYTYPE_INT16 yytype_int16;
 
289
#else
 
290
typedef short int yytype_int16;
 
291
#endif
 
292
 
 
293
#ifndef YYSIZE_T
 
294
# ifdef __SIZE_TYPE__
 
295
#  define YYSIZE_T __SIZE_TYPE__
 
296
# elif defined size_t
 
297
#  define YYSIZE_T size_t
 
298
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 
299
     || defined __cplusplus || defined _MSC_VER)
 
300
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 
301
#  define YYSIZE_T size_t
 
302
# else
 
303
#  define YYSIZE_T unsigned int
 
304
# endif
 
305
#endif
 
306
 
 
307
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
308
 
 
309
#ifndef YY_
 
310
# if YYENABLE_NLS
 
311
#  if ENABLE_NLS
 
312
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 
313
#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 
314
#  endif
 
315
# endif
 
316
# ifndef YY_
 
317
#  define YY_(msgid) msgid
 
318
# endif
 
319
#endif
 
320
 
 
321
/* Suppress unused-variable warnings by "using" E.  */
 
322
#if ! defined lint || defined __GNUC__
 
323
# define YYUSE(e) ((void) (e))
 
324
#else
 
325
# define YYUSE(e) /* empty */
 
326
#endif
 
327
 
 
328
/* Identity function, used to suppress warnings about constant conditions.  */
 
329
#ifndef lint
 
330
# define YYID(n) (n)
 
331
#else
 
332
#if (defined __STDC__ || defined __C99__FUNC__ \
 
333
     || defined __cplusplus || defined _MSC_VER)
 
334
static int
 
335
YYID (int i)
 
336
#else
 
337
static int
 
338
YYID (i)
 
339
    int i;
 
340
#endif
 
341
{
 
342
  return i;
 
343
}
 
344
#endif
 
345
 
 
346
#if ! defined yyoverflow || YYERROR_VERBOSE
341
347
 
342
348
/* The parser invokes alloca or malloc; define the necessary symbols.  */
343
349
 
344
 
# if YYSTACK_USE_ALLOCA
345
 
#  define YYSTACK_ALLOC alloca
346
 
# else
347
 
#  ifndef YYSTACK_USE_ALLOCA
348
 
#   if defined (alloca) || defined (_ALLOCA_H)
 
350
# ifdef YYSTACK_USE_ALLOCA
 
351
#  if YYSTACK_USE_ALLOCA
 
352
#   ifdef __GNUC__
 
353
#    define YYSTACK_ALLOC __builtin_alloca
 
354
#   elif defined __BUILTIN_VA_ARG_INCR
 
355
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 
356
#   elif defined _AIX
 
357
#    define YYSTACK_ALLOC __alloca
 
358
#   elif defined _MSC_VER
 
359
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 
360
#    define alloca _alloca
 
361
#   else
349
362
#    define YYSTACK_ALLOC alloca
350
 
#   else
351
 
#    ifdef __GNUC__
352
 
#     define YYSTACK_ALLOC __builtin_alloca
 
363
#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
364
     || defined __cplusplus || defined _MSC_VER)
 
365
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 
366
#     ifndef _STDLIB_H
 
367
#      define _STDLIB_H 1
 
368
#     endif
353
369
#    endif
354
370
#   endif
355
371
#  endif
356
372
# endif
357
373
 
358
374
# ifdef YYSTACK_ALLOC
359
 
   /* Pacify GCC's `empty if-body' warning. */
360
 
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 
375
   /* Pacify GCC's `empty if-body' warning.  */
 
376
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 
377
#  ifndef YYSTACK_ALLOC_MAXIMUM
 
378
    /* The OS might guarantee only one guard page at the bottom of the stack,
 
379
       and a page size can be as small as 4096 bytes.  So we cannot safely
 
380
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 
381
       to allow for a few compiler-allocated temporary stack slots.  */
 
382
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 
383
#  endif
361
384
# else
362
 
#  if defined (__STDC__) || defined (__cplusplus)
 
385
#  define YYSTACK_ALLOC YYMALLOC
 
386
#  define YYSTACK_FREE YYFREE
 
387
#  ifndef YYSTACK_ALLOC_MAXIMUM
 
388
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 
389
#  endif
 
390
#  if (defined __cplusplus && ! defined _STDLIB_H \
 
391
       && ! ((defined YYMALLOC || defined malloc) \
 
392
             && (defined YYFREE || defined free)))
363
393
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
364
 
#   define YYSIZE_T size_t
365
 
#  endif
366
 
#  define YYSTACK_ALLOC malloc
367
 
#  define YYSTACK_FREE free
 
394
#   ifndef _STDLIB_H
 
395
#    define _STDLIB_H 1
 
396
#   endif
 
397
#  endif
 
398
#  ifndef YYMALLOC
 
399
#   define YYMALLOC malloc
 
400
#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
401
     || defined __cplusplus || defined _MSC_VER)
 
402
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 
403
#   endif
 
404
#  endif
 
405
#  ifndef YYFREE
 
406
#   define YYFREE free
 
407
#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
408
     || defined __cplusplus || defined _MSC_VER)
 
409
void free (void *); /* INFRINGES ON USER NAME SPACE */
 
410
#   endif
 
411
#  endif
368
412
# endif
369
 
#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
370
 
 
371
 
 
372
 
#if (! defined (yyoverflow) \
373
 
     && (! defined (__cplusplus) \
374
 
         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
413
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
414
 
 
415
 
 
416
#if (! defined yyoverflow \
 
417
     && (! defined __cplusplus \
 
418
         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
375
419
 
376
420
/* A type that is properly aligned for any stack member.  */
377
421
union yyalloc
378
422
{
379
 
  short yyss;
 
423
  yytype_int16 yyss;
380
424
  YYSTYPE yyvs;
381
 
# if YYLSP_NEEDED
382
 
  YYLTYPE yyls;
383
 
# endif
384
 
};
 
425
  };
385
426
 
386
427
/* The size of the maximum gap between one aligned stack and the next.  */
387
 
# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 
428
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
388
429
 
389
430
/* The size of an array large to enough to hold all stacks, each with
390
431
   N elements.  */
391
 
# if YYLSP_NEEDED
392
 
#  define YYSTACK_BYTES(N) \
393
 
     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
394
 
      + 2 * YYSTACK_GAP_MAX)
395
 
# else
396
 
#  define YYSTACK_BYTES(N) \
397
 
     ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
398
 
      + YYSTACK_GAP_MAX)
399
 
# endif
 
432
# define YYSTACK_BYTES(N) \
 
433
     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 
434
      + YYSTACK_GAP_MAXIMUM)
400
435
 
401
436
/* Copy COUNT objects from FROM to TO.  The source and destination do
402
437
   not overlap.  */
403
438
# ifndef YYCOPY
404
 
#  if 1 < __GNUC__
 
439
#  if defined __GNUC__ && 1 < __GNUC__
405
440
#   define YYCOPY(To, From, Count) \
406
441
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
407
442
#  else
408
443
#   define YYCOPY(To, From, Count)              \
409
444
      do                                        \
410
445
        {                                       \
411
 
          register YYSIZE_T yyi;                \
 
446
          YYSIZE_T yyi;                         \
412
447
          for (yyi = 0; yyi < (Count); yyi++)   \
413
448
            (To)[yyi] = (From)[yyi];            \
414
449
        }                                       \
415
 
      while (0)
 
450
      while (YYID (0))
416
451
#  endif
417
452
# endif
418
453
 
427
462
        YYSIZE_T yynewbytes;                                            \
428
463
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
429
464
        Stack = &yyptr->Stack;                                          \
430
 
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 
465
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
431
466
        yyptr += yynewbytes / sizeof (*yyptr);                          \
432
467
      }                                                                 \
433
 
    while (0)
434
 
 
435
 
#endif
436
 
 
437
 
 
438
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
439
 
# define YYSIZE_T __SIZE_TYPE__
440
 
#endif
441
 
#if ! defined (YYSIZE_T) && defined (size_t)
442
 
# define YYSIZE_T size_t
443
 
#endif
444
 
#if ! defined (YYSIZE_T)
445
 
# if defined (__STDC__) || defined (__cplusplus)
446
 
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
447
 
#  define YYSIZE_T size_t
 
468
    while (YYID (0))
 
469
 
 
470
#endif
 
471
 
 
472
/* YYFINAL -- State number of the termination state.  */
 
473
#define YYFINAL  9
 
474
/* YYLAST -- Last index in YYTABLE.  */
 
475
#define YYLAST   54
 
476
 
 
477
/* YYNTOKENS -- Number of terminals.  */
 
478
#define YYNTOKENS  16
 
479
/* YYNNTS -- Number of nonterminals.  */
 
480
#define YYNNTS  3
 
481
/* YYNRULES -- Number of rules.  */
 
482
#define YYNRULES  13
 
483
/* YYNRULES -- Number of states.  */
 
484
#define YYNSTATES  27
 
485
 
 
486
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
487
#define YYUNDEFTOK  2
 
488
#define YYMAXUTOK   262
 
489
 
 
490
#define YYTRANSLATE(YYX)                                                \
 
491
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
492
 
 
493
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 
494
static const yytype_uint8 yytranslate[] =
 
495
{
 
496
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
497
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
498
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
499
       2,     2,     2,    10,     2,     2,     2,     2,     5,     2,
 
500
      14,    15,     2,     2,     2,     2,     2,     2,     2,     2,
 
501
       2,     2,     2,     2,     2,     2,     2,     2,    12,     2,
 
502
       2,     2,     2,     3,     2,     2,     2,     2,     2,     2,
 
503
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
504
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
505
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
506
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
507
      13,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
508
       2,     2,     2,     2,     4,     2,     2,     2,     2,     2,
 
509
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
510
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
511
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
512
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
513
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
514
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
515
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
516
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
517
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
518
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
519
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
520
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
521
       2,     2,     2,     2,     2,     2,     1,     2,     6,     7,
 
522
       8,     9,    11
 
523
};
 
524
 
 
525
#if YYDEBUG
 
526
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 
527
   YYRHS.  */
 
528
static const yytype_uint8 yyprhs[] =
 
529
{
 
530
       0,     0,     3,     5,    11,    15,    19,    23,    27,    31,
 
531
      35,    38,    40,    42
 
532
};
 
533
 
 
534
/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 
535
static const yytype_int8 yyrhs[] =
 
536
{
 
537
      17,     0,    -1,    18,    -1,    18,     3,    18,    12,    18,
 
538
      -1,    18,     4,    18,    -1,    18,     5,    18,    -1,    18,
 
539
       6,    18,    -1,    18,     7,    18,    -1,    18,     8,    18,
 
540
      -1,    18,     9,    18,    -1,    10,    18,    -1,    13,    -1,
 
541
      11,    -1,    14,    18,    15,    -1
 
542
};
 
543
 
 
544
/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 
545
static const yytype_uint8 yyrline[] =
 
546
{
 
547
       0,   154,   154,   162,   166,   170,   174,   178,   182,   186,
 
548
     190,   194,   198,   203
 
549
};
 
550
#endif
 
551
 
 
552
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 
553
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 
554
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 
555
static const char *const yytname[] =
 
556
{
 
557
  "$end", "error", "$undefined", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
 
558
  "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
 
559
  "$accept", "start", "exp", 0
 
560
};
 
561
#endif
 
562
 
 
563
# ifdef YYPRINT
 
564
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 
565
   token YYLEX-NUM.  */
 
566
static const yytype_uint16 yytoknum[] =
 
567
{
 
568
       0,   256,   257,    63,   124,    38,   258,   259,   260,   261,
 
569
      33,   262,    58,   110,    40,    41
 
570
};
448
571
# endif
449
 
#endif
450
 
#if ! defined (YYSIZE_T)
451
 
# define YYSIZE_T unsigned int
452
 
#endif
 
572
 
 
573
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 
574
static const yytype_uint8 yyr1[] =
 
575
{
 
576
       0,    16,    17,    18,    18,    18,    18,    18,    18,    18,
 
577
      18,    18,    18,    18
 
578
};
 
579
 
 
580
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 
581
static const yytype_uint8 yyr2[] =
 
582
{
 
583
       0,     2,     1,     5,     3,     3,     3,     3,     3,     3,
 
584
       2,     1,     1,     3
 
585
};
 
586
 
 
587
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 
588
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 
589
   means the default is an error.  */
 
590
static const yytype_uint8 yydefact[] =
 
591
{
 
592
       0,     0,    12,    11,     0,     0,     2,    10,     0,     1,
 
593
       0,     0,     0,     0,     0,     0,     0,    13,     0,     4,
 
594
       5,     6,     7,     8,     9,     0,     3
 
595
};
 
596
 
 
597
/* YYDEFGOTO[NTERM-NUM].  */
 
598
static const yytype_int8 yydefgoto[] =
 
599
{
 
600
      -1,     5,     6
 
601
};
 
602
 
 
603
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 
604
   STATE-NUM.  */
 
605
#define YYPACT_NINF -10
 
606
static const yytype_int8 yypact[] =
 
607
{
 
608
      -9,    -9,   -10,   -10,    -9,     8,    36,   -10,    13,   -10,
 
609
      -9,    -9,    -9,    -9,    -9,    -9,    -9,   -10,    26,    41,
 
610
      45,    18,    -2,    14,   -10,    -9,    36
 
611
};
 
612
 
 
613
/* YYPGOTO[NTERM-NUM].  */
 
614
static const yytype_int8 yypgoto[] =
 
615
{
 
616
     -10,   -10,    -1
 
617
};
 
618
 
 
619
/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 
620
   positive, shift that token.  If negative, reduce the rule which
 
621
   number is the opposite.  If zero, do what YYDEFACT says.
 
622
   If YYTABLE_NINF, syntax error.  */
 
623
#define YYTABLE_NINF -1
 
624
static const yytype_uint8 yytable[] =
 
625
{
 
626
       7,     1,     2,     8,     3,     4,    15,    16,     9,    18,
 
627
      19,    20,    21,    22,    23,    24,    10,    11,    12,    13,
 
628
      14,    15,    16,    16,    26,    14,    15,    16,    17,    10,
 
629
      11,    12,    13,    14,    15,    16,     0,     0,    25,    10,
 
630
      11,    12,    13,    14,    15,    16,    12,    13,    14,    15,
 
631
      16,    13,    14,    15,    16
 
632
};
 
633
 
 
634
static const yytype_int8 yycheck[] =
 
635
{
 
636
       1,    10,    11,     4,    13,    14,     8,     9,     0,    10,
 
637
      11,    12,    13,    14,    15,    16,     3,     4,     5,     6,
 
638
       7,     8,     9,     9,    25,     7,     8,     9,    15,     3,
 
639
       4,     5,     6,     7,     8,     9,    -1,    -1,    12,     3,
 
640
       4,     5,     6,     7,     8,     9,     5,     6,     7,     8,
 
641
       9,     6,     7,     8,     9
 
642
};
 
643
 
 
644
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 
645
   symbol of state STATE-NUM.  */
 
646
static const yytype_uint8 yystos[] =
 
647
{
 
648
       0,    10,    11,    13,    14,    17,    18,    18,    18,     0,
 
649
       3,     4,     5,     6,     7,     8,     9,    15,    18,    18,
 
650
      18,    18,    18,    18,    18,    12,    18
 
651
};
453
652
 
454
653
#define yyerrok         (yyerrstatus = 0)
455
654
#define yyclearin       (yychar = YYEMPTY)
456
 
#define YYEMPTY         -2
 
655
#define YYEMPTY         (-2)
457
656
#define YYEOF           0
 
657
 
458
658
#define YYACCEPT        goto yyacceptlab
459
 
#define YYABORT         goto yyabortlab
460
 
#define YYERROR         goto yyerrlab1
 
659
#define YYABORT         goto yyabortlab
 
660
#define YYERROR         goto yyerrorlab
 
661
 
 
662
 
461
663
/* Like YYERROR except do call yyerror.  This remains here temporarily
462
664
   to ease the transition to the new meaning of YYERROR, for GCC.
463
665
   Once GCC version 2 has supplanted version 1, this can go.  */
 
666
 
464
667
#define YYFAIL          goto yyerrlab
 
668
 
465
669
#define YYRECOVERING()  (!!yyerrstatus)
 
670
 
466
671
#define YYBACKUP(Token, Value)                                  \
467
672
do                                                              \
468
673
  if (yychar == YYEMPTY && yylen == 1)                          \
469
674
    {                                                           \
470
675
      yychar = (Token);                                         \
471
676
      yylval = (Value);                                         \
472
 
      yychar1 = YYTRANSLATE (yychar);                           \
473
 
      YYPOPSTACK;                                               \
 
677
      yytoken = YYTRANSLATE (yychar);                           \
 
678
      YYPOPSTACK (1);                                           \
474
679
      goto yybackup;                                            \
475
680
    }                                                           \
476
681
  else                                                          \
477
 
    {                                                           \
478
 
      yyerror ("syntax error: cannot back up");                 \
 
682
    {                                                           \
 
683
      yyerror (YY_("syntax error: cannot back up")); \
479
684
      YYERROR;                                                  \
480
685
    }                                                           \
481
 
while (0)
 
686
while (YYID (0))
 
687
 
482
688
 
483
689
#define YYTERROR        1
484
690
#define YYERRCODE       256
485
691
 
486
692
 
487
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
488
 
   are run).
489
 
 
490
 
   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
491
 
   first token.  By default, to implement support for ranges, extend
492
 
   its range to the last symbol.  */
493
 
 
 
693
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 
694
   If N is 0, then set CURRENT to the empty location which ends
 
695
   the previous symbol: RHS[0] (always defined).  */
 
696
 
 
697
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
494
698
#ifndef YYLLOC_DEFAULT
495
 
# define YYLLOC_DEFAULT(Current, Rhs, N)        \
496
 
   Current.last_line   = Rhs[N].last_line;      \
497
 
   Current.last_column = Rhs[N].last_column;
 
699
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 
700
    do                                                                  \
 
701
      if (YYID (N))                                                    \
 
702
        {                                                               \
 
703
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 
704
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 
705
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 
706
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 
707
        }                                                               \
 
708
      else                                                              \
 
709
        {                                                               \
 
710
          (Current).first_line   = (Current).last_line   =              \
 
711
            YYRHSLOC (Rhs, 0).last_line;                                \
 
712
          (Current).first_column = (Current).last_column =              \
 
713
            YYRHSLOC (Rhs, 0).last_column;                              \
 
714
        }                                                               \
 
715
    while (YYID (0))
 
716
#endif
 
717
 
 
718
 
 
719
/* YY_LOCATION_PRINT -- Print the location on the stream.
 
720
   This macro was not mandated originally: define only if we know
 
721
   we won't break user code: when these are the locations we know.  */
 
722
 
 
723
#ifndef YY_LOCATION_PRINT
 
724
# if YYLTYPE_IS_TRIVIAL
 
725
#  define YY_LOCATION_PRINT(File, Loc)                  \
 
726
     fprintf (File, "%d.%d-%d.%d",                      \
 
727
              (Loc).first_line, (Loc).first_column,     \
 
728
              (Loc).last_line,  (Loc).last_column)
 
729
# else
 
730
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 
731
# endif
498
732
#endif
499
733
 
500
734
 
501
735
/* YYLEX -- calling `yylex' with the right arguments.  */
502
736
 
503
 
#if YYPURE
504
 
# if YYLSP_NEEDED
505
 
#  ifdef YYLEX_PARAM
506
 
#   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
507
 
#  else
508
 
#   define YYLEX                yylex (&yylval, &yylloc)
509
 
#  endif
510
 
# else /* !YYLSP_NEEDED */
511
 
#  ifdef YYLEX_PARAM
512
 
#   define YYLEX                yylex (&yylval, YYLEX_PARAM)
513
 
#  else
514
 
#   define YYLEX                yylex (&yylval)
515
 
#  endif
516
 
# endif /* !YYLSP_NEEDED */
517
 
#else /* !YYPURE */
518
 
# define YYLEX                  yylex ()
519
 
#endif /* !YYPURE */
520
 
 
 
737
#ifdef YYLEX_PARAM
 
738
# define YYLEX yylex (&yylval, YYLEX_PARAM)
 
739
#else
 
740
# define YYLEX yylex (&yylval)
 
741
#endif
521
742
 
522
743
/* Enable debugging if requested.  */
523
744
#if YYDEBUG
531
752
do {                                            \
532
753
  if (yydebug)                                  \
533
754
    YYFPRINTF Args;                             \
534
 
} while (0)
 
755
} while (YYID (0))
 
756
 
 
757
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 
758
do {                                                                      \
 
759
  if (yydebug)                                                            \
 
760
    {                                                                     \
 
761
      YYFPRINTF (stderr, "%s ", Title);                                   \
 
762
      yy_symbol_print (stderr,                                            \
 
763
                  Type, Value); \
 
764
      YYFPRINTF (stderr, "\n");                                           \
 
765
    }                                                                     \
 
766
} while (YYID (0))
 
767
 
 
768
 
 
769
/*--------------------------------.
 
770
| Print this symbol on YYOUTPUT.  |
 
771
`--------------------------------*/
 
772
 
 
773
/*ARGSUSED*/
 
774
#if (defined __STDC__ || defined __C99__FUNC__ \
 
775
     || defined __cplusplus || defined _MSC_VER)
 
776
static void
 
777
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 
778
#else
 
779
static void
 
780
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 
781
    FILE *yyoutput;
 
782
    int yytype;
 
783
    YYSTYPE const * const yyvaluep;
 
784
#endif
 
785
{
 
786
  if (!yyvaluep)
 
787
    return;
 
788
# ifdef YYPRINT
 
789
  if (yytype < YYNTOKENS)
 
790
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 
791
# else
 
792
  YYUSE (yyoutput);
 
793
# endif
 
794
  switch (yytype)
 
795
    {
 
796
      default:
 
797
        break;
 
798
    }
 
799
}
 
800
 
 
801
 
 
802
/*--------------------------------.
 
803
| Print this symbol on YYOUTPUT.  |
 
804
`--------------------------------*/
 
805
 
 
806
#if (defined __STDC__ || defined __C99__FUNC__ \
 
807
     || defined __cplusplus || defined _MSC_VER)
 
808
static void
 
809
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 
810
#else
 
811
static void
 
812
yy_symbol_print (yyoutput, yytype, yyvaluep)
 
813
    FILE *yyoutput;
 
814
    int yytype;
 
815
    YYSTYPE const * const yyvaluep;
 
816
#endif
 
817
{
 
818
  if (yytype < YYNTOKENS)
 
819
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 
820
  else
 
821
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
822
 
 
823
  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 
824
  YYFPRINTF (yyoutput, ")");
 
825
}
 
826
 
 
827
/*------------------------------------------------------------------.
 
828
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
 
829
| TOP (included).                                                   |
 
830
`------------------------------------------------------------------*/
 
831
 
 
832
#if (defined __STDC__ || defined __C99__FUNC__ \
 
833
     || defined __cplusplus || defined _MSC_VER)
 
834
static void
 
835
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 
836
#else
 
837
static void
 
838
yy_stack_print (bottom, top)
 
839
    yytype_int16 *bottom;
 
840
    yytype_int16 *top;
 
841
#endif
 
842
{
 
843
  YYFPRINTF (stderr, "Stack now");
 
844
  for (; bottom <= top; ++bottom)
 
845
    YYFPRINTF (stderr, " %d", *bottom);
 
846
  YYFPRINTF (stderr, "\n");
 
847
}
 
848
 
 
849
# define YY_STACK_PRINT(Bottom, Top)                            \
 
850
do {                                                            \
 
851
  if (yydebug)                                                  \
 
852
    yy_stack_print ((Bottom), (Top));                           \
 
853
} while (YYID (0))
 
854
 
 
855
 
 
856
/*------------------------------------------------.
 
857
| Report that the YYRULE is going to be reduced.  |
 
858
`------------------------------------------------*/
 
859
 
 
860
#if (defined __STDC__ || defined __C99__FUNC__ \
 
861
     || defined __cplusplus || defined _MSC_VER)
 
862
static void
 
863
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
 
864
#else
 
865
static void
 
866
yy_reduce_print (yyvsp, yyrule)
 
867
    YYSTYPE *yyvsp;
 
868
    int yyrule;
 
869
#endif
 
870
{
 
871
  int yynrhs = yyr2[yyrule];
 
872
  int yyi;
 
873
  unsigned long int yylno = yyrline[yyrule];
 
874
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 
875
             yyrule - 1, yylno);
 
876
  /* The symbols being reduced.  */
 
877
  for (yyi = 0; yyi < yynrhs; yyi++)
 
878
    {
 
879
      fprintf (stderr, "   $%d = ", yyi + 1);
 
880
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 
881
                       &(yyvsp[(yyi + 1) - (yynrhs)])
 
882
                                       );
 
883
      fprintf (stderr, "\n");
 
884
    }
 
885
}
 
886
 
 
887
# define YY_REDUCE_PRINT(Rule)          \
 
888
do {                                    \
 
889
  if (yydebug)                          \
 
890
    yy_reduce_print (yyvsp, Rule); \
 
891
} while (YYID (0))
 
892
 
535
893
/* Nonzero means print parse trace.  It is left uninitialized so that
536
894
   multiple parsers can coexist.  */
537
895
int yydebug;
538
896
#else /* !YYDEBUG */
539
897
# define YYDPRINTF(Args)
 
898
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 
899
# define YY_STACK_PRINT(Bottom, Top)
 
900
# define YY_REDUCE_PRINT(Rule)
540
901
#endif /* !YYDEBUG */
541
902
 
 
903
 
542
904
/* YYINITDEPTH -- initial size of the parser's stacks.  */
543
905
#ifndef YYINITDEPTH
544
906
# define YYINITDEPTH 200
548
910
   if the built-in stack extension method is used).
549
911
 
550
912
   Do not make this value too large; the results are undefined if
551
 
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 
913
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
552
914
   evaluated with infinite-precision integer arithmetic.  */
553
915
 
554
 
#if YYMAXDEPTH == 0
555
 
# undef YYMAXDEPTH
556
 
#endif
557
 
 
558
916
#ifndef YYMAXDEPTH
559
917
# define YYMAXDEPTH 10000
560
918
#endif
 
919
 
561
920
 
562
 
#ifdef YYERROR_VERBOSE
 
921
 
 
922
#if YYERROR_VERBOSE
563
923
 
564
924
# ifndef yystrlen
565
 
#  if defined (__GLIBC__) && defined (_STRING_H)
 
925
#  if defined __GLIBC__ && defined _STRING_H
566
926
#   define yystrlen strlen
567
927
#  else
568
928
/* Return the length of YYSTR.  */
 
929
#if (defined __STDC__ || defined __C99__FUNC__ \
 
930
     || defined __cplusplus || defined _MSC_VER)
569
931
static YYSIZE_T
570
 
#   if defined (__STDC__) || defined (__cplusplus)
571
932
yystrlen (const char *yystr)
572
 
#   else
 
933
#else
 
934
static YYSIZE_T
573
935
yystrlen (yystr)
574
 
     const char *yystr;
575
 
#   endif
 
936
    const char *yystr;
 
937
#endif
576
938
{
577
 
  register const char *yys = yystr;
578
 
 
579
 
  while (*yys++ != '\0')
 
939
  YYSIZE_T yylen;
 
940
  for (yylen = 0; yystr[yylen]; yylen++)
580
941
    continue;
581
 
 
582
 
  return yys - yystr - 1;
 
942
  return yylen;
583
943
}
584
944
#  endif
585
945
# endif
586
946
 
587
947
# ifndef yystpcpy
588
 
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 
948
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
589
949
#   define yystpcpy stpcpy
590
950
#  else
591
951
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
592
952
   YYDEST.  */
 
953
#if (defined __STDC__ || defined __C99__FUNC__ \
 
954
     || defined __cplusplus || defined _MSC_VER)
593
955
static char *
594
 
#   if defined (__STDC__) || defined (__cplusplus)
595
956
yystpcpy (char *yydest, const char *yysrc)
596
 
#   else
 
957
#else
 
958
static char *
597
959
yystpcpy (yydest, yysrc)
598
 
     char *yydest;
599
 
     const char *yysrc;
600
 
#   endif
 
960
    char *yydest;
 
961
    const char *yysrc;
 
962
#endif
601
963
{
602
 
  register char *yyd = yydest;
603
 
  register const char *yys = yysrc;
 
964
  char *yyd = yydest;
 
965
  const char *yys = yysrc;
604
966
 
605
967
  while ((*yyd++ = *yys++) != '\0')
606
968
    continue;
609
971
}
610
972
#  endif
611
973
# endif
 
974
 
 
975
# ifndef yytnamerr
 
976
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 
977
   quotes and backslashes, so that it's suitable for yyerror.  The
 
978
   heuristic is that double-quoting is unnecessary unless the string
 
979
   contains an apostrophe, a comma, or backslash (other than
 
980
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 
981
   null, do not copy; instead, return the length of what the result
 
982
   would have been.  */
 
983
static YYSIZE_T
 
984
yytnamerr (char *yyres, const char *yystr)
 
985
{
 
986
  if (*yystr == '"')
 
987
    {
 
988
      YYSIZE_T yyn = 0;
 
989
      char const *yyp = yystr;
 
990
 
 
991
      for (;;)
 
992
        switch (*++yyp)
 
993
          {
 
994
          case '\'':
 
995
          case ',':
 
996
            goto do_not_strip_quotes;
 
997
 
 
998
          case '\\':
 
999
            if (*++yyp != '\\')
 
1000
              goto do_not_strip_quotes;
 
1001
            /* Fall through.  */
 
1002
          default:
 
1003
            if (yyres)
 
1004
              yyres[yyn] = *yyp;
 
1005
            yyn++;
 
1006
            break;
 
1007
 
 
1008
          case '"':
 
1009
            if (yyres)
 
1010
              yyres[yyn] = '\0';
 
1011
            return yyn;
 
1012
          }
 
1013
    do_not_strip_quotes: ;
 
1014
    }
 
1015
 
 
1016
  if (! yyres)
 
1017
    return yystrlen (yystr);
 
1018
 
 
1019
  return yystpcpy (yyres, yystr) - yyres;
 
1020
}
 
1021
# endif
 
1022
 
 
1023
/* Copy into YYRESULT an error message about the unexpected token
 
1024
   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
 
1025
   including the terminating null byte.  If YYRESULT is null, do not
 
1026
   copy anything; just return the number of bytes that would be
 
1027
   copied.  As a special case, return 0 if an ordinary "syntax error"
 
1028
   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
 
1029
   size calculation.  */
 
1030
static YYSIZE_T
 
1031
yysyntax_error (char *yyresult, int yystate, int yychar)
 
1032
{
 
1033
  int yyn = yypact[yystate];
 
1034
 
 
1035
  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
 
1036
    return 0;
 
1037
  else
 
1038
    {
 
1039
      int yytype = YYTRANSLATE (yychar);
 
1040
      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
 
1041
      YYSIZE_T yysize = yysize0;
 
1042
      YYSIZE_T yysize1;
 
1043
      int yysize_overflow = 0;
 
1044
      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 
1045
      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 
1046
      int yyx;
 
1047
 
 
1048
# if 0
 
1049
      /* This is so xgettext sees the translatable formats that are
 
1050
         constructed on the fly.  */
 
1051
      YY_("syntax error, unexpected %s");
 
1052
      YY_("syntax error, unexpected %s, expecting %s");
 
1053
      YY_("syntax error, unexpected %s, expecting %s or %s");
 
1054
      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
 
1055
      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
 
1056
# endif
 
1057
      char *yyfmt;
 
1058
      char const *yyf;
 
1059
      static char const yyunexpected[] = "syntax error, unexpected %s";
 
1060
      static char const yyexpecting[] = ", expecting %s";
 
1061
      static char const yyor[] = " or %s";
 
1062
      char yyformat[sizeof yyunexpected
 
1063
                    + sizeof yyexpecting - 1
 
1064
                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
 
1065
                       * (sizeof yyor - 1))];
 
1066
      char const *yyprefix = yyexpecting;
 
1067
 
 
1068
      /* Start YYX at -YYN if negative to avoid negative indexes in
 
1069
         YYCHECK.  */
 
1070
      int yyxbegin = yyn < 0 ? -yyn : 0;
 
1071
 
 
1072
      /* Stay within bounds of both yycheck and yytname.  */
 
1073
      int yychecklim = YYLAST - yyn + 1;
 
1074
      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 
1075
      int yycount = 1;
 
1076
 
 
1077
      yyarg[0] = yytname[yytype];
 
1078
      yyfmt = yystpcpy (yyformat, yyunexpected);
 
1079
 
 
1080
      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 
1081
        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 
1082
          {
 
1083
            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 
1084
              {
 
1085
                yycount = 1;
 
1086
                yysize = yysize0;
 
1087
                yyformat[sizeof yyunexpected - 1] = '\0';
 
1088
                break;
 
1089
              }
 
1090
            yyarg[yycount++] = yytname[yyx];
 
1091
            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
 
1092
            yysize_overflow |= (yysize1 < yysize);
 
1093
            yysize = yysize1;
 
1094
            yyfmt = yystpcpy (yyfmt, yyprefix);
 
1095
            yyprefix = yyor;
 
1096
          }
 
1097
 
 
1098
      yyf = YY_(yyformat);
 
1099
      yysize1 = yysize + yystrlen (yyf);
 
1100
      yysize_overflow |= (yysize1 < yysize);
 
1101
      yysize = yysize1;
 
1102
 
 
1103
      if (yysize_overflow)
 
1104
        return YYSIZE_MAXIMUM;
 
1105
 
 
1106
      if (yyresult)
 
1107
        {
 
1108
          /* Avoid sprintf, as that infringes on the user's name space.
 
1109
             Don't have undefined behavior even if the translation
 
1110
             produced a string with the wrong number of "%s"s.  */
 
1111
          char *yyp = yyresult;
 
1112
          int yyi = 0;
 
1113
          while ((*yyp = *yyf) != '\0')
 
1114
            {
 
1115
              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
 
1116
                {
 
1117
                  yyp += yytnamerr (yyp, yyarg[yyi++]);
 
1118
                  yyf += 2;
 
1119
                }
 
1120
              else
 
1121
                {
 
1122
                  yyp++;
 
1123
                  yyf++;
 
1124
                }
 
1125
            }
 
1126
        }
 
1127
      return yysize;
 
1128
    }
 
1129
}
 
1130
#endif /* YYERROR_VERBOSE */
 
1131
 
 
1132
 
 
1133
/*-----------------------------------------------.
 
1134
| Release the memory associated to this symbol.  |
 
1135
`-----------------------------------------------*/
 
1136
 
 
1137
/*ARGSUSED*/
 
1138
#if (defined __STDC__ || defined __C99__FUNC__ \
 
1139
     || defined __cplusplus || defined _MSC_VER)
 
1140
static void
 
1141
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 
1142
#else
 
1143
static void
 
1144
yydestruct (yymsg, yytype, yyvaluep)
 
1145
    const char *yymsg;
 
1146
    int yytype;
 
1147
    YYSTYPE *yyvaluep;
612
1148
#endif
 
1149
{
 
1150
  YYUSE (yyvaluep);
 
1151
 
 
1152
  if (!yymsg)
 
1153
    yymsg = "Deleting";
 
1154
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
1155
 
 
1156
  switch (yytype)
 
1157
    {
 
1158
 
 
1159
      default:
 
1160
        break;
 
1161
    }
 
1162
}
613
1163
 
614
 
#line 315 "bison.simple"
615
 
 
616
 
 
617
 
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
618
 
   into yyparse.  The argument should have type void *.
619
 
   It should actually point to an object.
620
 
   Grammar actions can access the variable by casting it
621
 
   to the proper pointer type.  */
 
1164
 
 
1165
/* Prevent warnings from -Wmissing-prototypes.  */
622
1166
 
623
1167
#ifdef YYPARSE_PARAM
624
 
# if defined (__STDC__) || defined (__cplusplus)
625
 
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
626
 
#  define YYPARSE_PARAM_DECL
627
 
# else
628
 
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
629
 
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
630
 
# endif
631
 
#else /* !YYPARSE_PARAM */
632
 
# define YYPARSE_PARAM_ARG
633
 
# define YYPARSE_PARAM_DECL
634
 
#endif /* !YYPARSE_PARAM */
635
 
 
636
 
/* Prevent warning if -Wstrict-prototypes.  */
637
 
#ifdef __GNUC__
638
 
# ifdef YYPARSE_PARAM
639
 
int yyparse (void *);
640
 
# else
 
1168
#if defined __STDC__ || defined __cplusplus
 
1169
int yyparse (void *YYPARSE_PARAM);
 
1170
#else
 
1171
int yyparse ();
 
1172
#endif
 
1173
#else /* ! YYPARSE_PARAM */
 
1174
#if defined __STDC__ || defined __cplusplus
641
1175
int yyparse (void);
642
 
# endif
643
 
#endif
644
 
 
645
 
/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
646
 
   variables are global, or local to YYPARSE.  */
647
 
 
648
 
#define YY_DECL_NON_LSP_VARIABLES                       \
649
 
/* The lookahead symbol.  */                            \
650
 
int yychar;                                             \
651
 
                                                        \
652
 
/* The semantic value of the lookahead symbol. */       \
653
 
YYSTYPE yylval;                                         \
654
 
                                                        \
655
 
/* Number of parse errors so far.  */                   \
 
1176
#else
 
1177
int yyparse ();
 
1178
#endif
 
1179
#endif /* ! YYPARSE_PARAM */
 
1180
 
 
1181
 
 
1182
 
 
1183
 
 
1184
 
 
1185
 
 
1186
/*----------.
 
1187
| yyparse.  |
 
1188
`----------*/
 
1189
 
 
1190
#ifdef YYPARSE_PARAM
 
1191
#if (defined __STDC__ || defined __C99__FUNC__ \
 
1192
     || defined __cplusplus || defined _MSC_VER)
 
1193
int
 
1194
yyparse (void *YYPARSE_PARAM)
 
1195
#else
 
1196
int
 
1197
yyparse (YYPARSE_PARAM)
 
1198
    void *YYPARSE_PARAM;
 
1199
#endif
 
1200
#else /* ! YYPARSE_PARAM */
 
1201
#if (defined __STDC__ || defined __C99__FUNC__ \
 
1202
     || defined __cplusplus || defined _MSC_VER)
 
1203
int
 
1204
yyparse (void)
 
1205
#else
 
1206
int
 
1207
yyparse ()
 
1208
 
 
1209
#endif
 
1210
#endif
 
1211
{
 
1212
  /* The look-ahead symbol.  */
 
1213
int yychar;
 
1214
 
 
1215
/* The semantic value of the look-ahead symbol.  */
 
1216
YYSTYPE yylval;
 
1217
 
 
1218
/* Number of syntax errors so far.  */
656
1219
int yynerrs;
657
1220
 
658
 
#if YYLSP_NEEDED
659
 
# define YY_DECL_VARIABLES                      \
660
 
YY_DECL_NON_LSP_VARIABLES                       \
661
 
                                                \
662
 
/* Location data for the lookahead symbol.  */  \
663
 
YYLTYPE yylloc;
664
 
#else
665
 
# define YY_DECL_VARIABLES                      \
666
 
YY_DECL_NON_LSP_VARIABLES
667
 
#endif
668
 
 
669
 
 
670
 
/* If nonreentrant, generate the variables here. */
671
 
 
672
 
#if !YYPURE
673
 
YY_DECL_VARIABLES
674
 
#endif  /* !YYPURE */
675
 
 
676
 
int
677
 
yyparse (YYPARSE_PARAM_ARG)
678
 
     YYPARSE_PARAM_DECL
679
 
{
680
 
  /* If reentrant, generate the variables here. */
681
 
#if YYPURE
682
 
  YY_DECL_VARIABLES
683
 
#endif  /* !YYPURE */
684
 
 
685
 
  register int yystate;
686
 
  register int yyn;
 
1221
  int yystate;
 
1222
  int yyn;
687
1223
  int yyresult;
688
1224
  /* Number of tokens to shift before error messages enabled.  */
689
1225
  int yyerrstatus;
690
 
  /* Lookahead token as an internal (translated) token number.  */
691
 
  int yychar1 = 0;
 
1226
  /* Look-ahead token as an internal (translated) token number.  */
 
1227
  int yytoken = 0;
 
1228
#if YYERROR_VERBOSE
 
1229
  /* Buffer for error messages, and its allocated size.  */
 
1230
  char yymsgbuf[128];
 
1231
  char *yymsg = yymsgbuf;
 
1232
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 
1233
#endif
692
1234
 
693
1235
  /* Three stacks and their tools:
694
1236
     `yyss': related to states,
698
1240
     Refer to the stacks thru separate pointers, to allow yyoverflow
699
1241
     to reallocate them elsewhere.  */
700
1242
 
701
 
  /* The state stack. */
702
 
  short yyssa[YYINITDEPTH];
703
 
  short *yyss = yyssa;
704
 
  register short *yyssp;
 
1243
  /* The state stack.  */
 
1244
  yytype_int16 yyssa[YYINITDEPTH];
 
1245
  yytype_int16 *yyss = yyssa;
 
1246
  yytype_int16 *yyssp;
705
1247
 
706
1248
  /* The semantic value stack.  */
707
1249
  YYSTYPE yyvsa[YYINITDEPTH];
708
1250
  YYSTYPE *yyvs = yyvsa;
709
 
  register YYSTYPE *yyvsp;
710
 
 
711
 
#if YYLSP_NEEDED
712
 
  /* The location stack.  */
713
 
  YYLTYPE yylsa[YYINITDEPTH];
714
 
  YYLTYPE *yyls = yylsa;
715
 
  YYLTYPE *yylsp;
716
 
#endif
717
 
 
718
 
#if YYLSP_NEEDED
719
 
# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
720
 
#else
721
 
# define YYPOPSTACK   (yyvsp--, yyssp--)
722
 
#endif
 
1251
  YYSTYPE *yyvsp;
 
1252
 
 
1253
 
 
1254
 
 
1255
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
723
1256
 
724
1257
  YYSIZE_T yystacksize = YYINITDEPTH;
725
1258
 
726
 
 
727
1259
  /* The variables used to return semantic value and location from the
728
1260
     action routines.  */
729
1261
  YYSTYPE yyval;
730
 
#if YYLSP_NEEDED
731
 
  YYLTYPE yyloc;
732
 
#endif
733
 
 
734
 
  /* When reducing, the number of symbols on the RHS of the reduced
735
 
     rule. */
736
 
  int yylen;
 
1262
 
 
1263
 
 
1264
  /* The number of symbols on the RHS of the reduced rule.
 
1265
     Keep to zero when no symbol should be popped.  */
 
1266
  int yylen = 0;
737
1267
 
738
1268
  YYDPRINTF ((stderr, "Starting parse\n"));
739
1269
 
749
1279
 
750
1280
  yyssp = yyss;
751
1281
  yyvsp = yyvs;
752
 
#if YYLSP_NEEDED
753
 
  yylsp = yyls;
754
 
#endif
 
1282
 
755
1283
  goto yysetstate;
756
1284
 
757
1285
/*------------------------------------------------------------.
759
1287
`------------------------------------------------------------*/
760
1288
 yynewstate:
761
1289
  /* In all cases, when you get here, the value and location stacks
762
 
     have just been pushed. so pushing a state here evens the stacks.
763
 
     */
 
1290
     have just been pushed.  So pushing a state here evens the stacks.  */
764
1291
  yyssp++;
765
1292
 
766
1293
 yysetstate:
767
1294
  *yyssp = yystate;
768
1295
 
769
 
  if (yyssp >= yyss + yystacksize - 1)
 
1296
  if (yyss + yystacksize - 1 <= yyssp)
770
1297
    {
771
1298
      /* Get the current used size of the three stacks, in elements.  */
772
1299
      YYSIZE_T yysize = yyssp - yyss + 1;
773
1300
 
774
1301
#ifdef yyoverflow
775
1302
      {
776
 
        /* Give user a chance to reallocate the stack. Use copies of
 
1303
        /* Give user a chance to reallocate the stack.  Use copies of
777
1304
           these so that the &'s don't force the real ones into
778
1305
           memory.  */
779
1306
        YYSTYPE *yyvs1 = yyvs;
780
 
        short *yyss1 = yyss;
 
1307
        yytype_int16 *yyss1 = yyss;
 
1308
 
781
1309
 
782
1310
        /* Each stack pointer address is followed by the size of the
783
 
           data in use in that stack, in bytes.  */
784
 
# if YYLSP_NEEDED
785
 
        YYLTYPE *yyls1 = yyls;
786
 
        /* This used to be a conditional around just the two extra args,
787
 
           but that might be undefined if yyoverflow is a macro.  */
788
 
        yyoverflow ("parser stack overflow",
789
 
                    &yyss1, yysize * sizeof (*yyssp),
790
 
                    &yyvs1, yysize * sizeof (*yyvsp),
791
 
                    &yyls1, yysize * sizeof (*yylsp),
792
 
                    &yystacksize);
793
 
        yyls = yyls1;
794
 
# else
795
 
        yyoverflow ("parser stack overflow",
796
 
                    &yyss1, yysize * sizeof (*yyssp),
797
 
                    &yyvs1, yysize * sizeof (*yyvsp),
798
 
                    &yystacksize);
799
 
# endif
 
1311
           data in use in that stack, in bytes.  This used to be a
 
1312
           conditional around just the two extra args, but that might
 
1313
           be undefined if yyoverflow is a macro.  */
 
1314
        yyoverflow (YY_("memory exhausted"),
 
1315
                    &yyss1, yysize * sizeof (*yyssp),
 
1316
                    &yyvs1, yysize * sizeof (*yyvsp),
 
1317
 
 
1318
                    &yystacksize);
 
1319
 
800
1320
        yyss = yyss1;
801
1321
        yyvs = yyvs1;
802
1322
      }
803
1323
#else /* no yyoverflow */
804
1324
# ifndef YYSTACK_RELOCATE
805
 
      goto yyoverflowlab;
 
1325
      goto yyexhaustedlab;
806
1326
# else
807
1327
      /* Extend the stack our own way.  */
808
 
      if (yystacksize >= YYMAXDEPTH)
809
 
        goto yyoverflowlab;
 
1328
      if (YYMAXDEPTH <= yystacksize)
 
1329
        goto yyexhaustedlab;
810
1330
      yystacksize *= 2;
811
 
      if (yystacksize > YYMAXDEPTH)
 
1331
      if (YYMAXDEPTH < yystacksize)
812
1332
        yystacksize = YYMAXDEPTH;
813
1333
 
814
1334
      {
815
 
        short *yyss1 = yyss;
 
1335
        yytype_int16 *yyss1 = yyss;
816
1336
        union yyalloc *yyptr =
817
1337
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
818
1338
        if (! yyptr)
819
 
          goto yyoverflowlab;
 
1339
          goto yyexhaustedlab;
820
1340
        YYSTACK_RELOCATE (yyss);
821
1341
        YYSTACK_RELOCATE (yyvs);
822
 
# if YYLSP_NEEDED
823
 
        YYSTACK_RELOCATE (yyls);
824
 
# endif
825
 
# undef YYSTACK_RELOCATE
 
1342
 
 
1343
#  undef YYSTACK_RELOCATE
826
1344
        if (yyss1 != yyssa)
827
1345
          YYSTACK_FREE (yyss1);
828
1346
      }
831
1349
 
832
1350
      yyssp = yyss + yysize - 1;
833
1351
      yyvsp = yyvs + yysize - 1;
834
 
#if YYLSP_NEEDED
835
 
      yylsp = yyls + yysize - 1;
836
 
#endif
 
1352
 
837
1353
 
838
1354
      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
839
1355
                  (unsigned long int) yystacksize));
840
1356
 
841
 
      if (yyssp >= yyss + yystacksize - 1)
 
1357
      if (yyss + yystacksize - 1 <= yyssp)
842
1358
        YYABORT;
843
1359
    }
844
1360
 
846
1362
 
847
1363
  goto yybackup;
848
1364
 
849
 
 
850
1365
/*-----------.
851
1366
| yybackup.  |
852
1367
`-----------*/
853
1368
yybackup:
854
1369
 
855
 
/* Do appropriate processing given the current state.  */
856
 
/* Read a lookahead token if we need one and don't already have one.  */
857
 
/* yyresume: */
858
 
 
859
 
  /* First try to decide what to do without reference to lookahead token.  */
860
 
 
 
1370
  /* Do appropriate processing given the current state.  Read a
 
1371
     look-ahead token if we need one and don't already have one.  */
 
1372
 
 
1373
  /* First try to decide what to do without reference to look-ahead token.  */
861
1374
  yyn = yypact[yystate];
862
 
  if (yyn == YYFLAG)
 
1375
  if (yyn == YYPACT_NINF)
863
1376
    goto yydefault;
864
1377
 
865
 
  /* Not known => get a lookahead token if don't already have one.  */
866
 
 
867
 
  /* yychar is either YYEMPTY or YYEOF
868
 
     or a valid token in external form.  */
869
 
 
 
1378
  /* Not known => get a look-ahead token if don't already have one.  */
 
1379
 
 
1380
  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
870
1381
  if (yychar == YYEMPTY)
871
1382
    {
872
1383
      YYDPRINTF ((stderr, "Reading a token: "));
873
1384
      yychar = YYLEX;
874
1385
    }
875
1386
 
876
 
  /* Convert token to internal form (in yychar1) for indexing tables with */
877
 
 
878
 
  if (yychar <= 0)              /* This means end of input. */
 
1387
  if (yychar <= YYEOF)
879
1388
    {
880
 
      yychar1 = 0;
881
 
      yychar = YYEOF;           /* Don't call YYLEX any more */
882
 
 
 
1389
      yychar = yytoken = YYEOF;
883
1390
      YYDPRINTF ((stderr, "Now at end of input.\n"));
884
1391
    }
885
1392
  else
886
1393
    {
887
 
      yychar1 = YYTRANSLATE (yychar);
888
 
 
889
 
#if YYDEBUG
890
 
     /* We have to keep this `#if YYDEBUG', since we use variables
891
 
        which are defined only if `YYDEBUG' is set.  */
892
 
      if (yydebug)
893
 
        {
894
 
          YYFPRINTF (stderr, "Next token is %d (%s",
895
 
                     yychar, yytname[yychar1]);
896
 
          /* Give the individual parser a way to print the precise
897
 
             meaning of a token, for further debugging info.  */
898
 
# ifdef YYPRINT
899
 
          YYPRINT (stderr, yychar, yylval);
900
 
# endif
901
 
          YYFPRINTF (stderr, ")\n");
902
 
        }
903
 
#endif
 
1394
      yytoken = YYTRANSLATE (yychar);
 
1395
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
904
1396
    }
905
1397
 
906
 
  yyn += yychar1;
907
 
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 
1398
  /* If the proper action on seeing token YYTOKEN is to reduce or to
 
1399
     detect an error, take that action.  */
 
1400
  yyn += yytoken;
 
1401
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
908
1402
    goto yydefault;
909
 
 
910
1403
  yyn = yytable[yyn];
911
 
 
912
 
  /* yyn is what to do for this token type in this state.
913
 
     Negative => reduce, -yyn is rule number.
914
 
     Positive => shift, yyn is new state.
915
 
       New state is final state => don't bother to shift,
916
 
       just return success.
917
 
     0, or most negative number => error.  */
918
 
 
919
 
  if (yyn < 0)
 
1404
  if (yyn <= 0)
920
1405
    {
921
 
      if (yyn == YYFLAG)
 
1406
      if (yyn == 0 || yyn == YYTABLE_NINF)
922
1407
        goto yyerrlab;
923
1408
      yyn = -yyn;
924
1409
      goto yyreduce;
925
1410
    }
926
 
  else if (yyn == 0)
927
 
    goto yyerrlab;
928
1411
 
929
1412
  if (yyn == YYFINAL)
930
1413
    YYACCEPT;
931
1414
 
932
 
  /* Shift the lookahead token.  */
933
 
  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
934
 
              yychar, yytname[yychar1]));
935
 
 
936
 
  /* Discard the token being shifted unless it is eof.  */
937
 
  if (yychar != YYEOF)
938
 
    yychar = YYEMPTY;
939
 
 
940
 
  *++yyvsp = yylval;
941
 
#if YYLSP_NEEDED
942
 
  *++yylsp = yylloc;
943
 
#endif
944
 
 
945
1415
  /* Count tokens shifted since error; after three, turn off error
946
1416
     status.  */
947
1417
  if (yyerrstatus)
948
1418
    yyerrstatus--;
949
1419
 
 
1420
  /* Shift the look-ahead token.  */
 
1421
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
1422
 
 
1423
  /* Discard the shifted token unless it is eof.  */
 
1424
  if (yychar != YYEOF)
 
1425
    yychar = YYEMPTY;
 
1426
 
950
1427
  yystate = yyn;
 
1428
  *++yyvsp = yylval;
 
1429
 
951
1430
  goto yynewstate;
952
1431
 
953
1432
 
971
1450
  /* If YYLEN is nonzero, implement the default value of the action:
972
1451
     `$$ = $1'.
973
1452
 
974
 
     Otherwise, the following line sets YYVAL to the semantic value of
975
 
     the lookahead token.  This behavior is undocumented and Bison
 
1453
     Otherwise, the following line sets YYVAL to garbage.
 
1454
     This behavior is undocumented and Bison
976
1455
     users should not rely upon it.  Assigning to YYVAL
977
1456
     unconditionally makes the parser a bit smaller, and it avoids a
978
1457
     GCC warning that YYVAL may be used uninitialized.  */
979
1458
  yyval = yyvsp[1-yylen];
980
1459
 
981
 
#if YYLSP_NEEDED
982
 
  /* Similarly for the default location.  Let the user run additional
983
 
     commands if for instance locations are ranges.  */
984
 
  yyloc = yylsp[1-yylen];
985
 
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
986
 
#endif
987
 
 
988
 
#if YYDEBUG
989
 
  /* We have to keep this `#if YYDEBUG', since we use variables which
990
 
     are defined only if `YYDEBUG' is set.  */
991
 
  if (yydebug)
992
 
    {
993
 
      int yyi;
994
 
 
995
 
      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
996
 
                 yyn, yyrline[yyn]);
997
 
 
998
 
      /* Print the symbols being reduced, and their result.  */
999
 
      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1000
 
        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1001
 
      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1002
 
    }
1003
 
#endif
1004
 
 
1005
 
  switch (yyn) {
1006
 
 
1007
 
case 1:
1008
 
#line 153 "plural.y"
1009
 
{
1010
 
            if (yyvsp[0].exp == NULL)
 
1460
 
 
1461
  YY_REDUCE_PRINT (yyn);
 
1462
  switch (yyn)
 
1463
    {
 
1464
        case 2:
 
1465
#line 155 "plural.y"
 
1466
    {
 
1467
            if ((yyvsp[(1) - (1)].exp) == NULL)
1011
1468
              YYABORT;
1012
 
            ((struct parse_args *) arg)->res = yyvsp[0].exp;
1013
 
          }
1014
 
    break;
1015
 
case 2:
1016
 
#line 161 "plural.y"
1017
 
{
1018
 
            yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
1019
 
          }
1020
 
    break;
1021
 
case 3:
1022
 
#line 165 "plural.y"
1023
 
{
1024
 
            yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
1025
 
          }
1026
 
    break;
1027
 
case 4:
1028
 
#line 169 "plural.y"
1029
 
{
1030
 
            yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
1031
 
          }
1032
 
    break;
1033
 
case 5:
1034
 
#line 173 "plural.y"
1035
 
{
1036
 
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1037
 
          }
1038
 
    break;
1039
 
case 6:
1040
 
#line 177 "plural.y"
1041
 
{
1042
 
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1043
 
          }
1044
 
    break;
1045
 
case 7:
1046
 
#line 181 "plural.y"
1047
 
{
1048
 
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1049
 
          }
1050
 
    break;
1051
 
case 8:
1052
 
#line 185 "plural.y"
1053
 
{
1054
 
            yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1055
 
          }
1056
 
    break;
1057
 
case 9:
1058
 
#line 189 "plural.y"
1059
 
{
1060
 
            yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
1061
 
          }
1062
 
    break;
1063
 
case 10:
1064
 
#line 193 "plural.y"
1065
 
{
1066
 
            yyval.exp = new_exp_0 (var);
1067
 
          }
1068
 
    break;
1069
 
case 11:
1070
 
#line 197 "plural.y"
1071
 
{
1072
 
            if ((yyval.exp = new_exp_0 (num)) != NULL)
1073
 
              yyval.exp->val.num = yyvsp[0].num;
1074
 
          }
1075
 
    break;
1076
 
case 12:
1077
 
#line 202 "plural.y"
1078
 
{
1079
 
            yyval.exp = yyvsp[-1].exp;
1080
 
          }
1081
 
    break;
1082
 
}
1083
 
 
1084
 
#line 705 "bison.simple"
1085
 
 
1086
 
 
1087
 
  yyvsp -= yylen;
1088
 
  yyssp -= yylen;
1089
 
#if YYLSP_NEEDED
1090
 
  yylsp -= yylen;
1091
 
#endif
1092
 
 
1093
 
#if YYDEBUG
1094
 
  if (yydebug)
1095
 
    {
1096
 
      short *yyssp1 = yyss - 1;
1097
 
      YYFPRINTF (stderr, "state stack now");
1098
 
      while (yyssp1 != yyssp)
1099
 
        YYFPRINTF (stderr, " %d", *++yyssp1);
1100
 
      YYFPRINTF (stderr, "\n");
 
1469
            ((struct parse_args *) arg)->res = (yyvsp[(1) - (1)].exp);
 
1470
          }
 
1471
    break;
 
1472
 
 
1473
  case 3:
 
1474
#line 163 "plural.y"
 
1475
    {
 
1476
            (yyval.exp) = new_exp_3 (qmop, (yyvsp[(1) - (5)].exp), (yyvsp[(3) - (5)].exp), (yyvsp[(5) - (5)].exp));
 
1477
          }
 
1478
    break;
 
1479
 
 
1480
  case 4:
 
1481
#line 167 "plural.y"
 
1482
    {
 
1483
            (yyval.exp) = new_exp_2 (lor, (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1484
          }
 
1485
    break;
 
1486
 
 
1487
  case 5:
 
1488
#line 171 "plural.y"
 
1489
    {
 
1490
            (yyval.exp) = new_exp_2 (land, (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1491
          }
 
1492
    break;
 
1493
 
 
1494
  case 6:
 
1495
#line 175 "plural.y"
 
1496
    {
 
1497
            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1498
          }
 
1499
    break;
 
1500
 
 
1501
  case 7:
 
1502
#line 179 "plural.y"
 
1503
    {
 
1504
            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1505
          }
 
1506
    break;
 
1507
 
 
1508
  case 8:
 
1509
#line 183 "plural.y"
 
1510
    {
 
1511
            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1512
          }
 
1513
    break;
 
1514
 
 
1515
  case 9:
 
1516
#line 187 "plural.y"
 
1517
    {
 
1518
            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));
 
1519
          }
 
1520
    break;
 
1521
 
 
1522
  case 10:
 
1523
#line 191 "plural.y"
 
1524
    {
 
1525
            (yyval.exp) = new_exp_1 (lnot, (yyvsp[(2) - (2)].exp));
 
1526
          }
 
1527
    break;
 
1528
 
 
1529
  case 11:
 
1530
#line 195 "plural.y"
 
1531
    {
 
1532
            (yyval.exp) = new_exp_0 (var);
 
1533
          }
 
1534
    break;
 
1535
 
 
1536
  case 12:
 
1537
#line 199 "plural.y"
 
1538
    {
 
1539
            if (((yyval.exp) = new_exp_0 (num)) != NULL)
 
1540
              (yyval.exp)->val.num = (yyvsp[(1) - (1)].num);
 
1541
          }
 
1542
    break;
 
1543
 
 
1544
  case 13:
 
1545
#line 204 "plural.y"
 
1546
    {
 
1547
            (yyval.exp) = (yyvsp[(2) - (3)].exp);
 
1548
          }
 
1549
    break;
 
1550
 
 
1551
 
 
1552
/* Line 1267 of yacc.c.  */
 
1553
#line 1554 "plural.c"
 
1554
      default: break;
1101
1555
    }
1102
 
#endif
 
1556
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
1557
 
 
1558
  YYPOPSTACK (yylen);
 
1559
  yylen = 0;
 
1560
  YY_STACK_PRINT (yyss, yyssp);
1103
1561
 
1104
1562
  *++yyvsp = yyval;
1105
 
#if YYLSP_NEEDED
1106
 
  *++yylsp = yyloc;
1107
 
#endif
 
1563
 
1108
1564
 
1109
1565
  /* Now `shift' the result of the reduction.  Determine what state
1110
1566
     that goes to, based on the state we popped back to and the rule
1112
1568
 
1113
1569
  yyn = yyr1[yyn];
1114
1570
 
1115
 
  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1116
 
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 
1571
  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
 
1572
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1117
1573
    yystate = yytable[yystate];
1118
1574
  else
1119
 
    yystate = yydefgoto[yyn - YYNTBASE];
 
1575
    yystate = yydefgoto[yyn - YYNTOKENS];
1120
1576
 
1121
1577
  goto yynewstate;
1122
1578
 
1129
1585
  if (!yyerrstatus)
1130
1586
    {
1131
1587
      ++yynerrs;
1132
 
 
1133
 
#ifdef YYERROR_VERBOSE
1134
 
      yyn = yypact[yystate];
1135
 
 
1136
 
      if (yyn > YYFLAG && yyn < YYLAST)
1137
 
        {
1138
 
          YYSIZE_T yysize = 0;
1139
 
          char *yymsg;
1140
 
          int yyx, yycount;
1141
 
 
1142
 
          yycount = 0;
1143
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
1144
 
             YYCHECK.  */
1145
 
          for (yyx = yyn < 0 ? -yyn : 0;
1146
 
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1147
 
            if (yycheck[yyx + yyn] == yyx)
1148
 
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1149
 
          yysize += yystrlen ("parse error, unexpected ") + 1;
1150
 
          yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1151
 
          yymsg = (char *) YYSTACK_ALLOC (yysize);
1152
 
          if (yymsg != 0)
1153
 
            {
1154
 
              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1155
 
              yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1156
 
 
1157
 
              if (yycount < 5)
1158
 
                {
1159
 
                  yycount = 0;
1160
 
                  for (yyx = yyn < 0 ? -yyn : 0;
1161
 
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
1162
 
                       yyx++)
1163
 
                    if (yycheck[yyx + yyn] == yyx)
1164
 
                      {
1165
 
                        const char *yyq = ! yycount ? ", expecting " : " or ";
1166
 
                        yyp = yystpcpy (yyp, yyq);
1167
 
                        yyp = yystpcpy (yyp, yytname[yyx]);
1168
 
                        yycount++;
1169
 
                      }
1170
 
                }
1171
 
              yyerror (yymsg);
 
1588
#if ! YYERROR_VERBOSE
 
1589
      yyerror (YY_("syntax error"));
 
1590
#else
 
1591
      {
 
1592
        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
 
1593
        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
 
1594
          {
 
1595
            YYSIZE_T yyalloc = 2 * yysize;
 
1596
            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
 
1597
              yyalloc = YYSTACK_ALLOC_MAXIMUM;
 
1598
            if (yymsg != yymsgbuf)
1172
1599
              YYSTACK_FREE (yymsg);
1173
 
            }
1174
 
          else
1175
 
            yyerror ("parse error; also virtual memory exhausted");
1176
 
        }
1177
 
      else
1178
 
#endif /* defined (YYERROR_VERBOSE) */
1179
 
        yyerror ("parse error");
 
1600
            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
 
1601
            if (yymsg)
 
1602
              yymsg_alloc = yyalloc;
 
1603
            else
 
1604
              {
 
1605
                yymsg = yymsgbuf;
 
1606
                yymsg_alloc = sizeof yymsgbuf;
 
1607
              }
 
1608
          }
 
1609
 
 
1610
        if (0 < yysize && yysize <= yymsg_alloc)
 
1611
          {
 
1612
            (void) yysyntax_error (yymsg, yystate, yychar);
 
1613
            yyerror (yymsg);
 
1614
          }
 
1615
        else
 
1616
          {
 
1617
            yyerror (YY_("syntax error"));
 
1618
            if (yysize != 0)
 
1619
              goto yyexhaustedlab;
 
1620
          }
 
1621
      }
 
1622
#endif
1180
1623
    }
1181
 
  goto yyerrlab1;
1182
 
 
1183
 
 
1184
 
/*--------------------------------------------------.
1185
 
| yyerrlab1 -- error raised explicitly by an action |
1186
 
`--------------------------------------------------*/
1187
 
yyerrlab1:
 
1624
 
 
1625
 
 
1626
 
1188
1627
  if (yyerrstatus == 3)
1189
1628
    {
1190
 
      /* If just tried and failed to reuse lookahead token after an
 
1629
      /* If just tried and failed to reuse look-ahead token after an
1191
1630
         error, discard it.  */
1192
1631
 
1193
 
      /* return failure if at end of input */
1194
 
      if (yychar == YYEOF)
1195
 
        YYABORT;
1196
 
      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1197
 
                  yychar, yytname[yychar1]));
1198
 
      yychar = YYEMPTY;
 
1632
      if (yychar <= YYEOF)
 
1633
        {
 
1634
          /* Return failure if at end of input.  */
 
1635
          if (yychar == YYEOF)
 
1636
            YYABORT;
 
1637
        }
 
1638
      else
 
1639
        {
 
1640
          yydestruct ("Error: discarding",
 
1641
                      yytoken, &yylval);
 
1642
          yychar = YYEMPTY;
 
1643
        }
1199
1644
    }
1200
1645
 
1201
 
  /* Else will try to reuse lookahead token after shifting the error
 
1646
  /* Else will try to reuse look-ahead token after shifting the error
1202
1647
     token.  */
1203
 
 
1204
 
  yyerrstatus = 3;              /* Each real token shifted decrements this */
1205
 
 
1206
 
  goto yyerrhandle;
1207
 
 
1208
 
 
1209
 
/*-------------------------------------------------------------------.
1210
 
| yyerrdefault -- current state does not do anything special for the |
1211
 
| error token.                                                       |
1212
 
`-------------------------------------------------------------------*/
1213
 
yyerrdefault:
1214
 
#if 0
1215
 
  /* This is wrong; only states that explicitly want error tokens
1216
 
     should shift them.  */
1217
 
 
1218
 
  /* If its default is to accept any token, ok.  Otherwise pop it.  */
1219
 
  yyn = yydefact[yystate];
1220
 
  if (yyn)
1221
 
    goto yydefault;
1222
 
#endif
1223
 
 
1224
 
 
1225
 
/*---------------------------------------------------------------.
1226
 
| yyerrpop -- pop the current state because it cannot handle the |
1227
 
| error token                                                    |
1228
 
`---------------------------------------------------------------*/
1229
 
yyerrpop:
1230
 
  if (yyssp == yyss)
1231
 
    YYABORT;
1232
 
  yyvsp--;
1233
 
  yystate = *--yyssp;
1234
 
#if YYLSP_NEEDED
1235
 
  yylsp--;
1236
 
#endif
1237
 
 
1238
 
#if YYDEBUG
1239
 
  if (yydebug)
1240
 
    {
1241
 
      short *yyssp1 = yyss - 1;
1242
 
      YYFPRINTF (stderr, "Error: state stack now");
1243
 
      while (yyssp1 != yyssp)
1244
 
        YYFPRINTF (stderr, " %d", *++yyssp1);
1245
 
      YYFPRINTF (stderr, "\n");
1246
 
    }
1247
 
#endif
1248
 
 
1249
 
/*--------------.
1250
 
| yyerrhandle.  |
1251
 
`--------------*/
1252
 
yyerrhandle:
1253
 
  yyn = yypact[yystate];
1254
 
  if (yyn == YYFLAG)
1255
 
    goto yyerrdefault;
1256
 
 
1257
 
  yyn += YYTERROR;
1258
 
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1259
 
    goto yyerrdefault;
1260
 
 
1261
 
  yyn = yytable[yyn];
1262
 
  if (yyn < 0)
1263
 
    {
1264
 
      if (yyn == YYFLAG)
1265
 
        goto yyerrpop;
1266
 
      yyn = -yyn;
1267
 
      goto yyreduce;
1268
 
    }
1269
 
  else if (yyn == 0)
1270
 
    goto yyerrpop;
 
1648
  goto yyerrlab1;
 
1649
 
 
1650
 
 
1651
/*---------------------------------------------------.
 
1652
| yyerrorlab -- error raised explicitly by YYERROR.  |
 
1653
`---------------------------------------------------*/
 
1654
yyerrorlab:
 
1655
 
 
1656
  /* Pacify compilers like GCC when the user code never invokes
 
1657
     YYERROR and the label yyerrorlab therefore never appears in user
 
1658
     code.  */
 
1659
  if (/*CONSTCOND*/ 0)
 
1660
     goto yyerrorlab;
 
1661
 
 
1662
  /* Do not reclaim the symbols of the rule which action triggered
 
1663
     this YYERROR.  */
 
1664
  YYPOPSTACK (yylen);
 
1665
  yylen = 0;
 
1666
  YY_STACK_PRINT (yyss, yyssp);
 
1667
  yystate = *yyssp;
 
1668
  goto yyerrlab1;
 
1669
 
 
1670
 
 
1671
/*-------------------------------------------------------------.
 
1672
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
 
1673
`-------------------------------------------------------------*/
 
1674
yyerrlab1:
 
1675
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
 
1676
 
 
1677
  for (;;)
 
1678
    {
 
1679
      yyn = yypact[yystate];
 
1680
      if (yyn != YYPACT_NINF)
 
1681
        {
 
1682
          yyn += YYTERROR;
 
1683
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 
1684
            {
 
1685
              yyn = yytable[yyn];
 
1686
              if (0 < yyn)
 
1687
                break;
 
1688
            }
 
1689
        }
 
1690
 
 
1691
      /* Pop the current state because it cannot handle the error token.  */
 
1692
      if (yyssp == yyss)
 
1693
        YYABORT;
 
1694
 
 
1695
 
 
1696
      yydestruct ("Error: popping",
 
1697
                  yystos[yystate], yyvsp);
 
1698
      YYPOPSTACK (1);
 
1699
      yystate = *yyssp;
 
1700
      YY_STACK_PRINT (yyss, yyssp);
 
1701
    }
1271
1702
 
1272
1703
  if (yyn == YYFINAL)
1273
1704
    YYACCEPT;
1274
1705
 
1275
 
  YYDPRINTF ((stderr, "Shifting error token, "));
1276
 
 
1277
1706
  *++yyvsp = yylval;
1278
 
#if YYLSP_NEEDED
1279
 
  *++yylsp = yylloc;
1280
 
#endif
 
1707
 
 
1708
 
 
1709
  /* Shift the error token.  */
 
1710
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1281
1711
 
1282
1712
  yystate = yyn;
1283
1713
  goto yynewstate;
1297
1727
  yyresult = 1;
1298
1728
  goto yyreturn;
1299
1729
 
1300
 
/*---------------------------------------------.
1301
 
| yyoverflowab -- parser overflow comes here.  |
1302
 
`---------------------------------------------*/
1303
 
yyoverflowlab:
1304
 
  yyerror ("parser stack overflow");
 
1730
#ifndef yyoverflow
 
1731
/*-------------------------------------------------.
 
1732
| yyexhaustedlab -- memory exhaustion comes here.  |
 
1733
`-------------------------------------------------*/
 
1734
yyexhaustedlab:
 
1735
  yyerror (YY_("memory exhausted"));
1305
1736
  yyresult = 2;
1306
1737
  /* Fall through.  */
 
1738
#endif
1307
1739
 
1308
1740
yyreturn:
 
1741
  if (yychar != YYEOF && yychar != YYEMPTY)
 
1742
     yydestruct ("Cleanup: discarding lookahead",
 
1743
                 yytoken, &yylval);
 
1744
  /* Do not reclaim the symbols of the rule which action triggered
 
1745
     this YYABORT or YYACCEPT.  */
 
1746
  YYPOPSTACK (yylen);
 
1747
  YY_STACK_PRINT (yyss, yyssp);
 
1748
  while (yyssp != yyss)
 
1749
    {
 
1750
      yydestruct ("Cleanup: popping",
 
1751
                  yystos[*yyssp], yyvsp);
 
1752
      YYPOPSTACK (1);
 
1753
    }
1309
1754
#ifndef yyoverflow
1310
1755
  if (yyss != yyssa)
1311
1756
    YYSTACK_FREE (yyss);
1312
1757
#endif
1313
 
  return yyresult;
 
1758
#if YYERROR_VERBOSE
 
1759
  if (yymsg != yymsgbuf)
 
1760
    YYSTACK_FREE (yymsg);
 
1761
#endif
 
1762
  /* Make sure YYID is used.  */
 
1763
  return YYID (yyresult);
1314
1764
}
1315
 
#line 207 "plural.y"
 
1765
 
 
1766
 
 
1767
#line 209 "plural.y"
1316
1768
 
1317
1769
 
1318
1770
void
1490
1942
{
1491
1943
  /* Do nothing.  We don't print error messages here.  */
1492
1944
}
 
1945