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