Ignore:
Timestamp:
2005-10-07T10:33:14+13:00 (19 years ago)
Author:
jrm21
Message:

tidied up interaction between flex/bison and greenstone's z3950 client
classes. renamed parse.y to zparse.y to make it more obvious it's related
to that stuff.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsdl/src/recpt/zparse.tab.c

    r1941 r10705  
    1 
    2 /*  A Bison parser, made from zparse.y
    3     by GNU Bison version 1.28  */
    4 
    5 #define YYBISON 1  /* Identify Bison output.  */
    6 
    7 #define GSDLVERSION 257
    8 #define GENERAL_SECTION 258
    9 #define SEARCH_SECTION  259
    10 #define BROWSE_SECTION  260
    11 #define MACROS_SECTION  261
    12 #define MAINTAINER  262
    13 #define PUBLIC  263
    14 #define TRUE    264
    15 #define FALSE   265
    16 #define LANGUAGES   266
    17 #define EN  267
    18 #define FR  268
    19 #define MI  269
    20 #define ZH  270
    21 #define DE  271
    22 #define NAME    272
    23 #define STRING  273
    24 #define ICON    274
    25 #define SMALLICON   275
    26 #define ABOUT   276
    27 #define SEARCHTEXT  277
    28 #define DOCUMENT    278
    29 #define SECTION 279
    30 #define BROWSE  280
    31 #define TYPE    281
    32 #define FORMAT  282
    33 #define LIST    283
    34 #define SORTEDLIST  284
    35 #define SECTIONLIST 285
    36 #define SORTEDSECTIONLIST   286
    37 #define DATELIST    287
    38 #define ICONLINK    288
    39 #define TEXTLINK    289
    40 #define DOCUMENTIMAGES  290
    41 #define DOCUMENTHEADER  291
    42 #define DOCUMENTTEXT    292
    43 #define DOCUMENTBUTTONS 293
    44 #define DOCUMENTARROWSBOTTOM    294
    45 #define DATA    295
    46 
     1/* A Bison parser, made by GNU Bison 1.875.  */
     2
     3/* Skeleton parser for Yacc-like parsing with Bison,
     4   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
     5
     6   This program is free software; you can redistribute it and/or modify
     7   it under the terms of the GNU General Public License as published by
     8   the Free Software Foundation; either version 2, or (at your option)
     9   any later version.
     10
     11   This program is distributed in the hope that it will be useful,
     12   but WITHOUT ANY WARRANTY; without even the implied warranty of
     13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     14   GNU General Public License for more details.
     15
     16   You should have received a copy of the GNU General Public License
     17   along with this program; if not, write to the Free Software
     18   Foundation, Inc., 59 Temple Place - Suite 330,
     19   Boston, MA 02111-1307, USA.  */
     20
     21/* As a special exception, when this file is copied by Bison into a
     22   Bison output file, you may use that output file without restriction.
     23   This special exception was added by the Free Software Foundation
     24   in version 1.24 of Bison.  */
     25
     26/* Written by Richard Stallman by simplifying the original so called
     27   ``semantic'' parser.  */
     28
     29/* All symbols defined below should begin with yy or YY, to avoid
     30   infringing on user name space.  This should be done even for local
     31   variables, as they might otherwise be expanded by user macros.
     32   There are some unavoidable exceptions within include files to
     33   define necessary library symbols; they are noted "INFRINGES ON
     34   USER NAME SPACE" below.  */
     35
     36/* Identify Bison output.  */
     37#define YYBISON 1
     38
     39/* Skeleton name.  */
     40#define YYSKELETON_NAME "yacc.c"
     41
     42/* Pure parsers.  */
     43#define YYPURE 0
     44
     45/* Using locations.  */
     46#define YYLSP_NEEDED 0
     47
     48
     49
     50/* Tokens.  */
     51#ifndef YYTOKENTYPE
     52# define YYTOKENTYPE
     53   /* Put the tokens into the symbol table, so that GDB and other debuggers
     54      know about them.  */
     55   enum yytokentype {
     56     GSDLVERSION = 257,
     57     GENERAL_SECTION = 258,
     58     SEARCH_SECTION = 259,
     59     BROWSE_SECTION = 260,
     60     MACROS_SECTION = 261,
     61     MAINTAINER = 262,
     62     PUBLIC = 263,
     63     TRUE = 264,
     64     FALSE = 265,
     65     LANGUAGES = 266,
     66     EN = 267,
     67     FR = 268,
     68     MI = 269,
     69     ZH = 270,
     70     DE = 271,
     71     NAME = 272,
     72     STRING = 273,
     73     ICON = 274,
     74     SMALLICON = 275,
     75     ABOUT = 276,
     76     SEARCHTEXT = 277,
     77     DOCUMENT = 278,
     78     SECTION = 279,
     79     BROWSE = 280,
     80     TYPE = 281,
     81     FORMAT = 282,
     82     LIST = 283,
     83     SORTEDLIST = 284,
     84     SECTIONLIST = 285,
     85     SORTEDSECTIONLIST = 286,
     86     DATELIST = 287,
     87     ICONLINK = 288,
     88     TEXTLINK = 289,
     89     DOCUMENTIMAGES = 290,
     90     DOCUMENTHEADER = 291,
     91     DOCUMENTTEXT = 292,
     92     DOCUMENTBUTTONS = 293,
     93     DOCUMENTARROWSBOTTOM = 294,
     94     DATA = 295
     95   };
     96#endif
     97#define GSDLVERSION 257
     98#define GENERAL_SECTION 258
     99#define SEARCH_SECTION 259
     100#define BROWSE_SECTION 260
     101#define MACROS_SECTION 261
     102#define MAINTAINER 262
     103#define PUBLIC 263
     104#define TRUE 264
     105#define FALSE 265
     106#define LANGUAGES 266
     107#define EN 267
     108#define FR 268
     109#define MI 269
     110#define ZH 270
     111#define DE 271
     112#define NAME 272
     113#define STRING 273
     114#define ICON 274
     115#define SMALLICON 275
     116#define ABOUT 276
     117#define SEARCHTEXT 277
     118#define DOCUMENT 278
     119#define SECTION 279
     120#define BROWSE 280
     121#define TYPE 281
     122#define FORMAT 282
     123#define LIST 283
     124#define SORTEDLIST 284
     125#define SECTIONLIST 285
     126#define SORTEDSECTIONLIST 286
     127#define DATELIST 287
     128#define ICONLINK 288
     129#define TEXTLINK 289
     130#define DOCUMENTIMAGES 290
     131#define DOCUMENTHEADER 291
     132#define DOCUMENTTEXT 292
     133#define DOCUMENTBUTTONS 293
     134#define DOCUMENTARROWSBOTTOM 294
     135#define DATA 295
     136
     137
     138
     139
     140/* Copy the first part of user declarations.  */
    47141#line 27 "zparse.y"
    48142
    … …  
    52146#include <string.h>
    53147#include <ctype.h>
    54 #include "z3950cfg.h"
     148#include "z3950cfg.h" /* structure types, and #define of yyin/yyparse */
    55149
    56150#define YYDEBUG 1
    57151#define YYERROR_VERBOSE 1
    58 /* can't use default yyparse(), as this name is used elsewhere (eg mg)*/
    59 #define yyin    zconfigin
    60 #define yyparse zconfigparse
    61152char defLanguage=0;
    62153
    … …  
    81172
    82173
    83 #line 64 "zparse.y"
    84 typedef union {
     174
     175/* Enabling traces.  */
     176#ifndef YYDEBUG
     177# define YYDEBUG 0
     178#endif
     179
     180/* Enabling verbose error messages.  */
     181#ifdef YYERROR_VERBOSE
     182# undef YYERROR_VERBOSE
     183# define YYERROR_VERBOSE 1
     184#else
     185# define YYERROR_VERBOSE 0
     186#endif
     187
     188#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
     189#line 61 "zparse.y"
     190typedef union YYSTYPE {
    85191  char *string;
    86192  struct z3950cfg *cfg;
    … …  
    88194  int number;
    89195} YYSTYPE;
    90 #include <stdio.h>
    91 
    92 #ifndef __cplusplus
    93 #ifndef __STDC__
    94 #define const
    95 #endif
    96 #endif
    97 
    98 
    99 
    100 #define YYFINAL     37
    101 #define YYFLAG      -32768
    102 #define YYNTBASE    44
    103 
    104 #define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 56)
    105 
    106 static const char yytranslate[] = {     0,
    107      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    108      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    109      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    110      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    112      2,     2,     2,     2,     2,     2,     2,    42,     2,     2,
    113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    114      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    115      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    116      2,     2,     2,     2,    43,     2,     2,     2,     2,     2,
    117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    120      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    121      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    122      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    123      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    124      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    125      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    126      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    127      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    128      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    129      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    130      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    131      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    132      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
    133      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    134     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    135     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
    136     37,    38,    39,    40,    41
     196/* Line 191 of yacc.c.  */
     197#line 197 "zparse.tab.c"
     198# define yystype YYSTYPE /* obsolescent; will be withdrawn */
     199# define YYSTYPE_IS_DECLARED 1
     200# define YYSTYPE_IS_TRIVIAL 1
     201#endif
     202
     203
     204
     205/* Copy the second part of user declarations.  */
     206
     207
     208/* Line 214 of yacc.c.  */
     209#line 209 "zparse.tab.c"
     210
     211#if ! defined (yyoverflow) || YYERROR_VERBOSE
     212
     213/* The parser invokes alloca or malloc; define the necessary symbols.  */
     214
     215# if YYSTACK_USE_ALLOCA
     216#  define YYSTACK_ALLOC alloca
     217# else
     218#  ifndef YYSTACK_USE_ALLOCA
     219#   if defined (alloca) || defined (_ALLOCA_H)
     220#    define YYSTACK_ALLOC alloca
     221#   else
     222#    ifdef __GNUC__
     223#     define YYSTACK_ALLOC __builtin_alloca
     224#    endif
     225#   endif
     226#  endif
     227# endif
     228
     229# ifdef YYSTACK_ALLOC
     230   /* Pacify GCC's `empty if-body' warning. */
     231#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
     232# else
     233#  if defined (__STDC__) || defined (__cplusplus)
     234#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     235#   define YYSIZE_T size_t
     236#  endif
     237#  define YYSTACK_ALLOC malloc
     238#  define YYSTACK_FREE free
     239# endif
     240#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
     241
     242
     243#if (! defined (yyoverflow) \
     244     && (! defined (__cplusplus) \
     245     || (YYSTYPE_IS_TRIVIAL)))
     246
     247/* A type that is properly aligned for any stack member.  */
     248union yyalloc
     249{
     250  short yyss;
     251  YYSTYPE yyvs;
     252  };
     253
     254/* The size of the maximum gap between one aligned stack and the next.  */
     255# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
     256
     257/* The size of an array large to enough to hold all stacks, each with
     258   N elements.  */
     259# define YYSTACK_BYTES(N) \
     260     ((N) * (sizeof (short) + sizeof (YYSTYPE))             \
     261      + YYSTACK_GAP_MAXIMUM)
     262
     263/* Copy COUNT objects from FROM to TO.  The source and destination do
     264   not overlap.  */
     265# ifndef YYCOPY
     266#  if 1 < __GNUC__
     267#   define YYCOPY(To, From, Count) \
     268      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
     269#  else
     270#   define YYCOPY(To, From, Count)      \
     271      do                    \
     272    {                   \
     273      register YYSIZE_T yyi;        \
     274      for (yyi = 0; yyi < (Count); yyi++)   \
     275        (To)[yyi] = (From)[yyi];        \
     276    }                   \
     277      while (0)
     278#  endif
     279# endif
     280
     281/* Relocate STACK from its old location to the new one.  The
     282   local variables YYSIZE and YYSTACKSIZE give the old and new number of
     283   elements in the stack, and YYPTR gives the new location of the
     284   stack.  Advance YYPTR to a properly aligned location for the next
     285   stack.  */
     286# define YYSTACK_RELOCATE(Stack)                    \
     287    do                                  \
     288      {                                 \
     289    YYSIZE_T yynewbytes;                        \
     290    YYCOPY (&yyptr->Stack, Stack, yysize);              \
     291    Stack = &yyptr->Stack;                      \
     292    yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
     293    yyptr += yynewbytes / sizeof (*yyptr);              \
     294      }                                 \
     295    while (0)
     296
     297#endif
     298
     299#if defined (__STDC__) || defined (__cplusplus)
     300   typedef signed char yysigned_char;
     301#else
     302   typedef short yysigned_char;
     303#endif
     304
     305/* YYFINAL -- State number of the termination state. */
     306#define YYFINAL  4
     307/* YYLAST -- Last index in YYTABLE.  */
     308#define YYLAST   44
     309
     310/* YYNTOKENS -- Number of terminals. */
     311#define YYNTOKENS  44
     312/* YYNNTS -- Number of nonterminals. */
     313#define YYNNTS  13
     314/* YYNRULES -- Number of rules. */
     315#define YYNRULES  28
     316/* YYNRULES -- Number of states. */
     317#define YYNSTATES  37
     318
     319/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
     320#define YYUNDEFTOK  2
     321#define YYMAXUTOK   296
     322
     323#define YYTRANSLATE(YYX)                        \
     324  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
     325
     326/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
     327static const unsigned char yytranslate[] =
     328{
     329       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     330       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     331       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     332       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     333       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     334       2,     2,     2,     2,     2,     2,     2,     2,    42,     2,
     335       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     336       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     337       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     338       2,     2,     2,     2,     2,    43,     2,     2,     2,     2,
     339       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     340       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     341       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     342       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     343       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     344       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     345       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     346       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     347       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     348       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     349       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     350       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     351       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     352       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     353       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     354       2,     2,     2,     2,     2,     2,     1,     3,     4,     5,
     355       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     356      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     357      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
     358      36,    37,    38,    39,    40,    41,     2
    137359};
    138360
    139 #if YYDEBUG != 0
    140 static const short yyprhs[] = {     0,
    141      0,     3,     5,     7,     8,    11,    13,    22,    24,    26,
    142     27,    30,    31,    34,    37,    38,    41,    44,    45,    47,
    143     48,    50,    53,    57,    60,    64,    66
     361#if YYDEBUG
     362/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
     363   YYRHS.  */
     364static const unsigned char yyprhs[] =
     365{
     366       0,     0,     3,     6,     8,    10,    11,    14,    16,    25,
     367      27,    29,    30,    33,    34,    37,    40,    41,    44,    47,
     368      48,    50,    51,    53,    56,    60,    63,    67,    69
    144369};
    145370
    146 static const short yyrhs[] = {    45,
    147     46,     0,    45,     0,     3,     0,     0,    46,    47,     0,
    148     47,     0,    41,    41,    49,    41,    48,    50,    51,    52,
    149      0,     1,     0,    19,     0,     0,    42,    41,     0,     0,
    150     20,    19,     0,    20,    41,     0,     0,    21,    19,     0,
    151     21,    41,     0,     0,    53,     0,     0,    54,     0,    53,
    152     54,     0,    22,    55,    19,     0,    22,    19,     0,    41,
    153     43,    41,     0,    41,     0,     1,     0
     371/* YYRHS -- A `-1'-separated list of the rules' RHS. */
     372static const yysigned_char yyrhs[] =
     373{
     374      45,     0,    -1,    46,    47,    -1,    46,    -1,     3,    -1,
     375      -1,    47,    48,    -1,    48,    -1,    41,    41,    50,    41,
     376      49,    51,    52,    53,    -1,     1,    -1,    19,    -1,    -1,
     377      42,    41,    -1,    -1,    20,    19,    -1,    20,    41,    -1,
     378      -1,    21,    19,    -1,    21,    41,    -1,    -1,    54,    -1,
     379      -1,    55,    -1,    54,    55,    -1,    22,    56,    19,    -1,
     380      22,    19,    -1,    41,    43,    41,    -1,    41,    -1,     1,
     381      -1
    154382};
    155383
    156 #endif
    157 
    158 #if YYDEBUG != 0
    159 static const short yyrline[] = { 0,
    160    109,   110,   113,   114,   116,   117,   119,   140,   144,   145,
    161    150,   151,   154,   155,   158,   159,   160,   165,   167,   168,
    162    170,   172,   175,   186,   208,   216,   224
     384/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
     385static const unsigned char yyrline[] =
     386{
     387       0,   106,   106,   107,   110,   111,   113,   114,   116,   137,
     388     141,   142,   147,   148,   151,   152,   155,   156,   157,   162,
     389     164,   165,   167,   169,   172,   183,   205,   213,   221
    163390};
    164391#endif
    165392
    166 
    167 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
    168 
    169 static const char * const yytname[] = {   "$","error","$undefined.","GSDLVERSION",
    170 "GENERAL_SECTION","SEARCH_SECTION","BROWSE_SECTION","MACROS_SECTION","MAINTAINER",
    171 "PUBLIC","TRUE","FALSE","LANGUAGES","EN","FR","MI","ZH","DE","NAME","STRING",
    172 "ICON","SMALLICON","ABOUT","SEARCHTEXT","DOCUMENT","SECTION","BROWSE","TYPE",
    173 "FORMAT","LIST","SORTEDLIST","SECTIONLIST","SORTEDSECTIONLIST","DATELIST","ICONLINK",
    174 "TEXTLINK","DOCUMENTIMAGES","DOCUMENTHEADER","DOCUMENTTEXT","DOCUMENTBUTTONS",
    175 "DOCUMENTARROWSBOTTOM","DATA","':'","'_'","z3950","version","zserverlist","zserver",
    176 "name","port","icon","smallicon","about","aboutList","aboutLang","lang", NULL
     393#if YYDEBUG || YYERROR_VERBOSE
     394/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     395   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
     396static const char *const yytname[] =
     397{
     398  "$end", "error", "$undefined", "GSDLVERSION", "GENERAL_SECTION",
     399  "SEARCH_SECTION", "BROWSE_SECTION", "MACROS_SECTION", "MAINTAINER",
     400  "PUBLIC", "TRUE", "FALSE", "LANGUAGES", "EN", "FR", "MI", "ZH", "DE",
     401  "NAME", "STRING", "ICON", "SMALLICON", "ABOUT", "SEARCHTEXT",
     402  "DOCUMENT", "SECTION", "BROWSE", "TYPE", "FORMAT", "LIST", "SORTEDLIST",
     403  "SECTIONLIST", "SORTEDSECTIONLIST", "DATELIST", "ICONLINK", "TEXTLINK",
     404  "DOCUMENTIMAGES", "DOCUMENTHEADER", "DOCUMENTTEXT", "DOCUMENTBUTTONS",
     405  "DOCUMENTARROWSBOTTOM", "DATA", "':'", "'_'", "$accept", "z3950",
     406  "version", "zserverlist", "zserver", "name", "port", "icon",
     407  "smallicon", "about", "aboutList", "aboutLang", "lang", 0
    177408};
    178409#endif
    179410
    180 static const short yyr1[] = {     0,
    181     44,    44,    45,    45,    46,    46,    47,    47,    48,    48,
    182     49,    49,    50,    50,    50,    51,    51,    51,    52,    52,
    183     53,    53,    54,    54,    55,    55,    55
     411# ifdef YYPRINT
     412/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
     413   token YYLEX-NUM.  */
     414static const unsigned short yytoknum[] =
     415{
     416       0,   256,   296,   257,   258,   259,   260,   261,   262,   263,
     417     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
     418     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
     419     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
     420     294,   295,    58,    95
    184421};
    185 
    186 static const short yyr2[] = {     0,
    187      2,     1,     1,     0,     2,     1,     8,     1,     1,     0,
    188      2,     0,     2,     2,     0,     2,     2,     0,     1,     0,
    189      1,     2,     3,     2,     3,     1,     1
     422# endif
     423
     424/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
     425static const unsigned char yyr1[] =
     426{
     427       0,    44,    45,    45,    46,    46,    47,    47,    48,    48,
     428      49,    49,    50,    50,    51,    51,    51,    52,    52,    52,
     429      53,    53,    54,    54,    55,    55,    56,    56,    56
    190430};
    191431
    192 static const short yydefact[] = {     4,
    193      3,     0,     8,     0,     0,     6,    12,     5,     0,     0,
    194     11,    10,     9,    15,     0,    18,    13,    14,     0,    20,
    195     16,    17,     0,     7,    19,    21,    27,    24,    26,     0,
    196     22,     0,    23,    25,     0,     0,     0
     432/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
     433static const unsigned char yyr2[] =
     434{
     435       0,     2,     2,     1,     1,     0,     2,     1,     8,     1,
     436       1,     0,     2,     0,     2,     2,     0,     2,     2,     0,
     437       1,     0,     1,     2,     3,     2,     3,     1,     1
    197438};
    198439
    199 static const short yydefgoto[] = {    35,
    200      2,     5,     6,    14,    10,    16,    20,    24,    25,    26,
    201     30
     440/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
     441   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
     442   means the default is an error.  */
     443static const unsigned char yydefact[] =
     444{
     445       5,     4,     0,     0,     1,     9,     0,     0,     7,    13,
     446       6,     0,     0,    12,    11,    10,    16,     0,    19,    14,
     447      15,     0,    21,    17,    18,     0,     8,    20,    22,    28,
     448      25,    27,     0,    23,     0,    24,    26
    202449};
    203450
    204 static const short yypact[] = {     4,
    205 -32768,     0,-32768,   -33,     2,-32768,   -32,-32768,   -30,   -29,
    206 -32768,   -10,-32768,    -7,   -14,    -6,-32768,-32768,   -13,    -8,
    207 -32768,-32768,     3,-32768,    -8,-32768,-32768,-32768,   -27,    -2,
    208 -32768,   -23,-32768,-32768,    19,    20,-32768
     451/* YYDEFGOTO[NTERM-NUM]. */
     452static const yysigned_char yydefgoto[] =
     453{
     454      -1,     2,     3,     7,     8,    16,    12,    18,    22,    26,
     455      27,    28,    32
    209456};
    210457
    211 static const short yypgoto[] = {-32768,
    212 -32768,-32768,    16,-32768,-32768,-32768,-32768,-32768,-32768,    -1,
    213 -32768
     458/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     459   STATE-NUM.  */
     460#define YYPACT_NINF -33
     461static const yysigned_char yypact[] =
     462{
     463       4,   -33,     8,     0,   -33,   -33,   -32,     2,   -33,   -31,
     464     -33,   -29,   -28,   -33,    -9,   -33,    -6,   -14,    -5,   -33,
     465     -33,   -13,    -7,   -33,   -33,     3,   -33,    -7,   -33,   -33,
     466     -33,   -26,    -1,   -33,   -22,   -33,   -33
    214467};
    215468
    216 
    217 #define YYLAST      44
    218 
    219 
    220 static const short yytable[] = {    -2,
    221      3,    -1,     3,    27,    17,    21,     1,     7,    13,     9,
    222     11,    12,    15,    23,    19,    32,    33,    34,    36,    37,
    223      8,    28,     0,    31,     0,     0,    18,    22,     0,     0,
    224      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    225      4,     0,     4,    29
     469/* YYPGOTO[NTERM-NUM].  */
     470static const yysigned_char yypgoto[] =
     471{
     472     -33,   -33,   -33,   -33,    13,   -33,   -33,   -33,   -33,   -33,
     473     -33,    -4,   -33
    226474};
    227475
    228 static const short yycheck[] = {     0,
    229      1,     0,     1,     1,    19,    19,     3,    41,    19,    42,
    230     41,    41,    20,    22,    21,    43,    19,    41,     0,     0,
    231      5,    19,    -1,    25,    -1,    -1,    41,    41,    -1,    -1,
    232     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    233     41,    -1,    41,    41
     476/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     477   positive, shift that token.  If negative, reduce the rule which
     478   number is the opposite.  If zero, do what YYDEFACT says.
     479   If YYTABLE_NINF, syntax error.  */
     480#define YYTABLE_NINF -4
     481static const yysigned_char yytable[] =
     482{
     483      -3,     5,    -2,     5,    29,    19,    23,     1,     4,     9,
     484      15,    11,    13,    14,    17,    25,    21,    34,    35,    36,
     485      10,     0,    30,    33,     0,     0,     0,    20,    24,     0,
     486       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     487       0,     6,     0,     6,    31
    234488};
    235 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
    236 #line 3 "/usr/share/bison.simple"
    237 /* This file comes from bison-1.28.  */
    238 
    239 /* Skeleton output parser for bison,
    240    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
    241 
    242    This program is free software; you can redistribute it and/or modify
    243    it under the terms of the GNU General Public License as published by
    244    the Free Software Foundation; either version 2, or (at your option)
    245    any later version.
    246 
    247    This program is distributed in the hope that it will be useful,
    248    but WITHOUT ANY WARRANTY; without even the implied warranty of
    249    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    250    GNU General Public License for more details.
    251 
    252    You should have received a copy of the GNU General Public License
    253    along with this program; if not, write to the Free Software
    254    Foundation, Inc., 59 Temple Place - Suite 330,
    255    Boston, MA 02111-1307, USA.  */
    256 
    257 /* As a special exception, when this file is copied by Bison into a
    258    Bison output file, you may use that output file without restriction.
    259    This special exception was added by the Free Software Foundation
    260    in version 1.24 of Bison.  */
    261 
    262 /* This is the parser code that is written into each bison parser
    263   when the %semantic_parser declaration is not specified in the grammar.
    264   It was written by Richard Stallman by simplifying the hairy parser
    265   used when %semantic_parser is specified.  */
    266 
    267 #ifndef YYSTACK_USE_ALLOCA
    268 #ifdef alloca
    269 #define YYSTACK_USE_ALLOCA
    270 #else /* alloca not defined */
    271 #ifdef __GNUC__
    272 #define YYSTACK_USE_ALLOCA
    273 #define alloca __builtin_alloca
    274 #else /* not GNU C.  */
    275 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
    276 #define YYSTACK_USE_ALLOCA
    277 #include <alloca.h>
    278 #else /* not sparc */
    279 /* We think this test detects Watcom and Microsoft C.  */
    280 /* This used to test MSDOS, but that is a bad idea
    281    since that symbol is in the user namespace.  */
    282 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
    283 #if 0 /* No need for malloc.h, which pollutes the namespace;
    284      instead, just don't use alloca.  */
    285 #include <malloc.h>
    286 #endif
    287 #else /* not MSDOS, or __TURBOC__ */
    288 #if defined(_AIX)
    289 /* I don't know what this was needed for, but it pollutes the namespace.
    290    So I turned it off.   rms, 2 May 1997.  */
    291 /* #include <malloc.h>  */
    292  #pragma alloca
    293 #define YYSTACK_USE_ALLOCA
    294 #else /* not MSDOS, or __TURBOC__, or _AIX */
    295 #if 0
    296 #ifdef __hpux /* [email protected] says this works for HPUX 9.05 and up,
    297          and on HPUX 10.  Eventually we can turn this on.  */
    298 #define YYSTACK_USE_ALLOCA
    299 #define alloca __builtin_alloca
    300 #endif /* __hpux */
    301 #endif
    302 #endif /* not _AIX */
    303 #endif /* not MSDOS, or __TURBOC__ */
    304 #endif /* not sparc */
    305 #endif /* not GNU C */
    306 #endif /* alloca not defined */
    307 #endif /* YYSTACK_USE_ALLOCA not defined */
    308 
    309 #ifdef YYSTACK_USE_ALLOCA
    310 #define YYSTACK_ALLOC alloca
    311 #else
    312 #define YYSTACK_ALLOC malloc
    313 #endif
    314 
    315 /* Note: there must be only one dollar sign in this file.
    316    It is replaced by the list of actions, each action
    317    as one case of the switch.  */
     489
     490static const yysigned_char yycheck[] =
     491{
     492       0,     1,     0,     1,     1,    19,    19,     3,     0,    41,
     493      19,    42,    41,    41,    20,    22,    21,    43,    19,    41,
     494       7,    -1,    19,    27,    -1,    -1,    -1,    41,    41,    -1,
     495      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     496      -1,    41,    -1,    41,    41
     497};
     498
     499/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     500   symbol of state STATE-NUM.  */
     501static const unsigned char yystos[] =
     502{
     503       0,     3,    45,    46,     0,     1,    41,    47,    48,    41,
     504      48,    42,    50,    41,    41,    19,    49,    20,    51,    19,
     505      41,    21,    52,    19,    41,    22,    53,    54,    55,     1,
     506      19,    41,    56,    55,    43,    19,    41
     507};
     508
     509#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
     510# define YYSIZE_T __SIZE_TYPE__
     511#endif
     512#if ! defined (YYSIZE_T) && defined (size_t)
     513# define YYSIZE_T size_t
     514#endif
     515#if ! defined (YYSIZE_T)
     516# if defined (__STDC__) || defined (__cplusplus)
     517#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
     518#  define YYSIZE_T size_t
     519# endif
     520#endif
     521#if ! defined (YYSIZE_T)
     522# define YYSIZE_T unsigned int
     523#endif
    318524
    319525#define yyerrok     (yyerrstatus = 0)
    320526#define yyclearin   (yychar = YYEMPTY)
    321 #define YYEMPTY     -2
     527#define YYEMPTY     (-2)
    322528#define YYEOF       0
     529
    323530#define YYACCEPT    goto yyacceptlab
    324 #define YYABORT     goto yyabortlab
     531#define YYABORT     goto yyabortlab
    325532#define YYERROR     goto yyerrlab1
    326 /* Like YYERROR except do call yyerror.
    327    This remains here temporarily to ease the
    328    transition to the new meaning of YYERROR, for GCC.
     533
     534
     535/* Like YYERROR except do call yyerror.  This remains here temporarily
     536   to ease the transition to the new meaning of YYERROR, for GCC.
    329537   Once GCC version 2 has supplanted version 1, this can go.  */
     538
    330539#define YYFAIL      goto yyerrlab
     540
    331541#define YYRECOVERING()  (!!yyerrstatus)
    332 #define YYBACKUP(token, value) \
     542
     543#define YYBACKUP(Token, Value)                  \
    333544do                              \
    334545  if (yychar == YYEMPTY && yylen == 1)              \
    335     { yychar = (token), yylval = (value);           \
    336       yychar1 = YYTRANSLATE (yychar);               \
     546    {                               \
     547      yychar = (Token);                     \
     548      yylval = (Value);                     \
     549      yytoken = YYTRANSLATE (yychar);               \
    337550      YYPOPSTACK;                       \
    338551      goto yybackup;                        \
    339552    }                               \
    340553  else                              \
    341     { yyerror ("syntax error: cannot back up"); YYERROR; }  \
     554    {                               \
     555      yyerror ("syntax error: cannot back up");\
     556      YYERROR;                          \
     557    }                               \
    342558while (0)
    343559
    … …  
    345561#define YYERRCODE   256
    346562
    347 #ifndef YYPURE
    348 #define YYLEX       yylex()
    349 #endif
    350 
    351 #ifdef YYPURE
    352 #ifdef YYLSP_NEEDED
     563/* YYLLOC_DEFAULT -- Compute the default location (before the actions
     564   are run).  */
     565
     566#ifndef YYLLOC_DEFAULT
     567# define YYLLOC_DEFAULT(Current, Rhs, N)         \
     568  Current.first_line   = Rhs[1].first_line;      \
     569  Current.first_column = Rhs[1].first_column;    \
     570  Current.last_line    = Rhs[N].last_line;       \
     571  Current.last_column  = Rhs[N].last_column;
     572#endif
     573
     574/* YYLEX -- calling `yylex' with the right arguments.  */
     575
    353576#ifdef YYLEX_PARAM
    354 #define YYLEX       yylex(&yylval, &yylloc, YYLEX_PARAM)
     577# define YYLEX yylex (YYLEX_PARAM)
    355578#else
    356 #define YYLEX       yylex(&yylval, &yylloc)
    357 #endif
    358 #else /* not YYLSP_NEEDED */
    359 #ifdef YYLEX_PARAM
    360 #define YYLEX       yylex(&yylval, YYLEX_PARAM)
     579# define YYLEX yylex ()
     580#endif
     581
     582/* Enable debugging if requested.  */
     583#if YYDEBUG
     584
     585# ifndef YYFPRINTF
     586#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
     587#  define YYFPRINTF fprintf
     588# endif
     589
     590# define YYDPRINTF(Args)            \
     591do {                        \
     592  if (yydebug)                  \
     593    YYFPRINTF Args;             \
     594} while (0)
     595
     596# define YYDSYMPRINT(Args)          \
     597do {                        \
     598  if (yydebug)                  \
     599    yysymprint Args;                \
     600} while (0)
     601
     602# define YYDSYMPRINTF(Title, Token, Value, Location)        \
     603do {                                \
     604  if (yydebug)                          \
     605    {                               \
     606      YYFPRINTF (stderr, "%s ", Title);             \
     607      yysymprint (stderr,                   \
     608                  Token, Value);    \
     609      YYFPRINTF (stderr, "\n");                 \
     610    }                               \
     611} while (0)
     612
     613/*------------------------------------------------------------------.
     614| yy_stack_print -- Print the state stack from its BOTTOM up to its |
     615| TOP (cinluded).                                                   |
     616`------------------------------------------------------------------*/
     617
     618#if defined (__STDC__) || defined (__cplusplus)
     619static void
     620yy_stack_print (short *bottom, short *top)
    361621#else
    362 #define YYLEX       yylex(&yylval)
    363 #endif
    364 #endif /* not YYLSP_NEEDED */
    365 #endif
    366 
    367 /* If nonreentrant, generate the variables here */
    368 
    369 #ifndef YYPURE
    370 
    371 int yychar;         /*  the lookahead symbol        */
    372 YYSTYPE yylval;         /*  the semantic value of the       */
    373                 /*  lookahead symbol            */
    374 
    375 #ifdef YYLSP_NEEDED
    376 YYLTYPE yylloc;         /*  location data for the lookahead */
    377                 /*  symbol              */
    378 #endif
    379 
    380 int yynerrs;            /*  number of parse errors so far       */
    381 #endif  /* not YYPURE */
    382 
    383 #if YYDEBUG != 0
    384 int yydebug;            /*  nonzero means print parse trace */
    385 /* Since this is uninitialized, it does not stop multiple parsers
    386    from coexisting.  */
    387 #endif
    388 
    389 /*  YYINITDEPTH indicates the initial size of the parser's stacks   */
    390 
     622static void
     623yy_stack_print (bottom, top)
     624    short *bottom;
     625    short *top;
     626#endif
     627{
     628  YYFPRINTF (stderr, "Stack now");
     629  for (/* Nothing. */; bottom <= top; ++bottom)
     630    YYFPRINTF (stderr, " %d", *bottom);
     631  YYFPRINTF (stderr, "\n");
     632}
     633
     634# define YY_STACK_PRINT(Bottom, Top)                \
     635do {                                \
     636  if (yydebug)                          \
     637    yy_stack_print ((Bottom), (Top));               \
     638} while (0)
     639
     640
     641/*------------------------------------------------.
     642| Report that the YYRULE is going to be reduced.  |
     643`------------------------------------------------*/
     644
     645#if defined (__STDC__) || defined (__cplusplus)
     646static void
     647yy_reduce_print (int yyrule)
     648#else
     649static void
     650yy_reduce_print (yyrule)
     651    int yyrule;
     652#endif
     653{
     654  int yyi;
     655  unsigned int yylineno = yyrline[yyrule];
     656  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
     657             yyrule - 1, yylineno);
     658  /* Print the symbols being reduced, and their result.  */
     659  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     660    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
     661  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
     662}
     663
     664# define YY_REDUCE_PRINT(Rule)      \
     665do {                    \
     666  if (yydebug)              \
     667    yy_reduce_print (Rule);     \
     668} while (0)
     669
     670/* Nonzero means print parse trace.  It is left uninitialized so that
     671   multiple parsers can coexist.  */
     672int yydebug;
     673#else /* !YYDEBUG */
     674# define YYDPRINTF(Args)
     675# define YYDSYMPRINT(Args)
     676# define YYDSYMPRINTF(Title, Token, Value, Location)
     677# define YY_STACK_PRINT(Bottom, Top)
     678# define YY_REDUCE_PRINT(Rule)
     679#endif /* !YYDEBUG */
     680
     681
     682/* YYINITDEPTH -- initial size of the parser's stacks.  */
    391683#ifndef YYINITDEPTH
    392 #define YYINITDEPTH 200
    393 #endif
    394 
    395 /*  YYMAXDEPTH is the maximum size the stacks can grow to
    396     (effective only if the built-in stack extension method is used).  */
     684# define YYINITDEPTH 200
     685#endif
     686
     687/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     688   if the built-in stack extension method is used).
     689
     690   Do not make this value too large; the results are undefined if
     691   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
     692   evaluated with infinite-precision integer arithmetic.  */
    397693
    398694#if YYMAXDEPTH == 0
    399 #undef YYMAXDEPTH
     695# undef YYMAXDEPTH
    400696#endif
    401697
    402698#ifndef YYMAXDEPTH
    403 #define YYMAXDEPTH 10000
    404 #endif
    405 
    406 
    407 /* Define __yy_memcpy.  Note that the size argument
    408    should be passed with type unsigned int, because that is what the non-GCC
    409    definitions require.  With GCC, __builtin_memcpy takes an arg
    410    of type size_t, but it can handle unsigned int.  */
    411 
    412 #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
    413 #define __yy_memcpy(TO,FROM,COUNT)  __builtin_memcpy(TO,FROM,COUNT)
    414 #else               /* not GNU C or C++ */
    415 #ifndef __cplusplus
    416 
    417 /* This is the most reliable way to avoid incompatibilities
    418    in available built-in functions on various systems.  */
     699# define YYMAXDEPTH 10000
     700#endif
     701
     702
     703
     704
     705#if YYERROR_VERBOSE
     706
     707# ifndef yystrlen
     708#  if defined (__GLIBC__) && defined (_STRING_H)
     709#   define yystrlen strlen
     710#  else
     711/* Return the length of YYSTR.  */
     712static YYSIZE_T
     713#   if defined (__STDC__) || defined (__cplusplus)
     714yystrlen (const char *yystr)
     715#   else
     716yystrlen (yystr)
     717     const char *yystr;
     718#   endif
     719{
     720  register const char *yys = yystr;
     721
     722  while (*yys++ != '\0')
     723    continue;
     724
     725  return yys - yystr - 1;
     726}
     727#  endif
     728# endif
     729
     730# ifndef yystpcpy
     731#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
     732#   define yystpcpy stpcpy
     733#  else
     734/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     735   YYDEST.  */
     736static char *
     737#   if defined (__STDC__) || defined (__cplusplus)
     738yystpcpy (char *yydest, const char *yysrc)
     739#   else
     740yystpcpy (yydest, yysrc)
     741     char *yydest;
     742     const char *yysrc;
     743#   endif
     744{
     745  register char *yyd = yydest;
     746  register const char *yys = yysrc;
     747
     748  while ((*yyd++ = *yys++) != '\0')
     749    continue;
     750
     751  return yyd - 1;
     752}
     753#  endif
     754# endif
     755
     756#endif /* !YYERROR_VERBOSE */
     757
     758
     759
     760
     761#if YYDEBUG
     762/*--------------------------------.
     763| Print this symbol on YYOUTPUT.  |
     764`--------------------------------*/
     765
     766#if defined (__STDC__) || defined (__cplusplus)
    419767static void
    420 __yy_memcpy (to, from, count)
    421      char *to;
    422      char *from;
    423      unsigned int count;
    424 {
    425   register char *f = from;
    426   register char *t = to;
    427   register int i = count;
    428 
    429   while (i-- > 0)
    430     *t++ = *f++;
     768yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
     769#else
     770static void
     771yysymprint (yyoutput, yytype, yyvaluep)
     772    FILE *yyoutput;
     773    int yytype;
     774    YYSTYPE *yyvaluep;
     775#endif
     776{
     777  /* Pacify ``unused variable'' warnings.  */
     778  (void) yyvaluep;
     779
     780  if (yytype < YYNTOKENS)
     781    {
     782      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
     783# ifdef YYPRINT
     784      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
     785# endif
     786    }
     787  else
     788    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
     789
     790  switch (yytype)
     791    {
     792      default:
     793        break;
     794    }
     795  YYFPRINTF (yyoutput, ")");
    431796}
    432797
    433 #else /* __cplusplus */
    434 
    435 /* This is the most reliable way to avoid incompatibilities
    436    in available built-in functions on various systems.  */
     798#endif /* ! YYDEBUG */
     799/*-----------------------------------------------.
     800| Release the memory associated to this symbol.  |
     801`-----------------------------------------------*/
     802
     803#if defined (__STDC__) || defined (__cplusplus)
    437804static void
    438 __yy_memcpy (char *to, char *from, unsigned int count)
    439 {
    440   register char *t = to;
    441   register char *f = from;
    442   register int i = count;
    443 
    444   while (i-- > 0)
    445     *t++ = *f++;
     805yydestruct (int yytype, YYSTYPE *yyvaluep)
     806#else
     807static void
     808yydestruct (yytype, yyvaluep)
     809    int yytype;
     810    YYSTYPE *yyvaluep;
     811#endif
     812{
     813  /* Pacify ``unused variable'' warnings.  */
     814  (void) yyvaluep;
     815
     816  switch (yytype)
     817    {
     818
     819      default:
     820        break;
     821    }
    446822}
    447823
    448 #endif
    449 #endif
    450 
    451 
    452 #line 217 "/usr/share/bison.simple"
    453 
    454 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    455    into yyparse.  The argument should have type void *.
    456    It should actually point to an object.
    457    Grammar actions can access the variable by casting it
    458    to the proper pointer type.  */
     824
     825
     826/* Prevent warnings from -Wmissing-prototypes.  */
    459827
    460828#ifdef YYPARSE_PARAM
    461 #ifdef __cplusplus
    462 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
    463 #define YYPARSE_PARAM_DECL
    464 #else /* not __cplusplus */
    465 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
    466 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
    467 #endif /* not __cplusplus */
    468 #else /* not YYPARSE_PARAM */
    469 #define YYPARSE_PARAM_ARG
    470 #define YYPARSE_PARAM_DECL
    471 #endif /* not YYPARSE_PARAM */
    472 
    473 /* Prevent warning if -Wstrict-prototypes.  */
    474 #ifdef __GNUC__
     829# if defined (__STDC__) || defined (__cplusplus)
     830int yyparse (void *YYPARSE_PARAM);
     831# else
     832int yyparse ();
     833# endif
     834#else /* ! YYPARSE_PARAM */
     835#if defined (__STDC__) || defined (__cplusplus)
     836int yyparse (void);
     837#else
     838int yyparse ();
     839#endif
     840#endif /* ! YYPARSE_PARAM */
     841
     842
     843
     844/* The lookahead symbol.  */
     845int yychar;
     846
     847/* The semantic value of the lookahead symbol.  */
     848YYSTYPE yylval;
     849
     850/* Number of syntax errors so far.  */
     851int yynerrs;
     852
     853
     854
     855/*----------.
     856| yyparse.  |
     857`----------*/
     858
    475859#ifdef YYPARSE_PARAM
    476 int yyparse (void *);
     860# if defined (__STDC__) || defined (__cplusplus)
     861int yyparse (void *YYPARSE_PARAM)
     862# else
     863int yyparse (YYPARSE_PARAM)
     864  void *YYPARSE_PARAM;
     865# endif
     866#else /* ! YYPARSE_PARAM */
     867#if defined (__STDC__) || defined (__cplusplus)
     868int
     869yyparse (void)
    477870#else
    478 int yyparse (void);
    479 #endif
    480 #endif
    481 
    482871int
    483 yyparse(YYPARSE_PARAM_ARG)
    484      YYPARSE_PARAM_DECL
    485 {
     872yyparse ()
     873
     874#endif
     875#endif
     876{
     877 
    486878  register int yystate;
    487879  register int yyn;
     880  int yyresult;
     881  /* Number of tokens to shift before error messages enabled.  */
     882  int yyerrstatus;
     883  /* Lookahead token as an internal (translated) token number.  */
     884  int yytoken = 0;
     885
     886  /* Three stacks and their tools:
     887     `yyss': related to states,
     888     `yyvs': related to semantic values,
     889     `yyls': related to locations.
     890
     891     Refer to the stacks thru separate pointers, to allow yyoverflow
     892     to reallocate them elsewhere.  */
     893
     894  /* The state stack.  */
     895  short yyssa[YYINITDEPTH];
     896  short *yyss = yyssa;
    488897  register short *yyssp;
     898
     899  /* The semantic value stack.  */
     900  YYSTYPE yyvsa[YYINITDEPTH];
     901  YYSTYPE *yyvs = yyvsa;
    489902  register YYSTYPE *yyvsp;
    490   int yyerrstatus;  /*  number of tokens to shift before error messages enabled */
    491   int yychar1 = 0;      /*  lookahead token as an internal (translated) token number */
    492 
    493   short yyssa[YYINITDEPTH]; /*  the state stack         */
    494   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack        */
    495 
    496   short *yyss = yyssa;      /*  refer to the stacks thru separate pointers */
    497   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
    498 
    499 #ifdef YYLSP_NEEDED
    500   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack          */
    501   YYLTYPE *yyls = yylsa;
    502   YYLTYPE *yylsp;
    503 
    504 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
    505 #else
     903
     904
     905
    506906#define YYPOPSTACK   (yyvsp--, yyssp--)
    507 #endif
    508 
    509   int yystacksize = YYINITDEPTH;
    510   int yyfree_stacks = 0;
    511 
    512 #ifdef YYPURE
    513   int yychar;
    514   YYSTYPE yylval;
    515   int yynerrs;
    516 #ifdef YYLSP_NEEDED
    517   YYLTYPE yylloc;
    518 #endif
    519 #endif
    520 
    521   YYSTYPE yyval;        /*  the variable used to return     */
    522                 /*  semantic values from the action */
    523                 /*  routines                */
    524 
     907
     908  YYSIZE_T yystacksize = YYINITDEPTH;
     909
     910  /* The variables used to return semantic value and location from the
     911     action routines.  */
     912  YYSTYPE yyval;
     913
     914
     915  /* When reducing, the number of symbols on the RHS of the reduced
     916     rule.  */
    525917  int yylen;
    526918
    527 #if YYDEBUG != 0
    528   if (yydebug)
    529     fprintf(stderr, "Starting parse\n");
    530 #endif
     919  YYDPRINTF ((stderr, "Starting parse\n"));
    531920
    532921  yystate = 0;
    … …  
    540929     The wasted elements are never initialized.  */
    541930
    542   yyssp = yyss - 1;
     931  yyssp = yyss;
    543932  yyvsp = yyvs;
    544 #ifdef YYLSP_NEEDED
    545   yylsp = yyls;
    546 #endif
    547 
    548 /* Push a new state, which is found in  yystate  .  */
    549 /* In all cases, when you get here, the value and location stacks
    550    have just been pushed. so pushing a state here evens the stacks.  */
    551 yynewstate:
    552 
    553   *++yyssp = yystate;
    554 
    555   if (yyssp >= yyss + yystacksize - 1)
     933
     934  goto yysetstate;
     935
     936/*------------------------------------------------------------.
     937| yynewstate -- Push a new state, which is found in yystate.  |
     938`------------------------------------------------------------*/
     939 yynewstate:
     940  /* In all cases, when you get here, the value and location stacks
     941     have just been pushed. so pushing a state here evens the stacks.
     942     */
     943  yyssp++;
     944
     945 yysetstate:
     946  *yyssp = yystate;
     947
     948  if (yyss + yystacksize - 1 <= yyssp)
    556949    {
    557       /* Give user a chance to reallocate the stack */
    558       /* Use copies of these so that the &'s don't force the real ones into memory. */
    559       YYSTYPE *yyvs1 = yyvs;
    560       short *yyss1 = yyss;
    561 #ifdef YYLSP_NEEDED
    562       YYLTYPE *yyls1 = yyls;
    563 #endif
    564 
    565950      /* Get the current used size of the three stacks, in elements.  */
    566       int size = yyssp - yyss + 1;
     951      YYSIZE_T yysize = yyssp - yyss + 1;
    567952
    568953#ifdef yyoverflow
    569       /* Each stack pointer address is followed by the size of
    570      the data in use in that stack, in bytes.  */
    571 #ifdef YYLSP_NEEDED
    572       /* This used to be a conditional around just the two extra args,
    573      but that might be undefined if yyoverflow is a macro.  */
    574       yyoverflow("parser stack overflow",
    575          &yyss1, size * sizeof (*yyssp),
    576          &yyvs1, size * sizeof (*yyvsp),
    577          &yyls1, size * sizeof (*yylsp),
    578          &yystacksize);
    579 #else
    580       yyoverflow("parser stack overflow",
    581          &yyss1, size * sizeof (*yyssp),
    582          &yyvs1, size * sizeof (*yyvsp),
    583          &yystacksize);
    584 #endif
    585 
    586       yyss = yyss1; yyvs = yyvs1;
    587 #ifdef YYLSP_NEEDED
    588       yyls = yyls1;
    589 #endif
     954      {
     955    /* Give user a chance to reallocate the stack. Use copies of
     956       these so that the &'s don't force the real ones into
     957       memory.  */
     958    YYSTYPE *yyvs1 = yyvs;
     959    short *yyss1 = yyss;
     960
     961
     962    /* Each stack pointer address is followed by the size of the
     963       data in use in that stack, in bytes.  This used to be a
     964       conditional around just the two extra args, but that might
     965       be undefined if yyoverflow is a macro.  */
     966    yyoverflow ("parser stack overflow",
     967            &yyss1, yysize * sizeof (*yyssp),
     968            &yyvs1, yysize * sizeof (*yyvsp),
     969
     970            &yystacksize);
     971
     972    yyss = yyss1;
     973    yyvs = yyvs1;
     974      }
    590975#else /* no yyoverflow */
     976# ifndef YYSTACK_RELOCATE
     977      goto yyoverflowlab;
     978# else
    591979      /* Extend the stack our own way.  */
    592       if (yystacksize >= YYMAXDEPTH)
    593     {
    594       yyerror("parser stack overflow");
    595       if (yyfree_stacks)
    596         {
    597           free (yyss);
    598           free (yyvs);
    599 #ifdef YYLSP_NEEDED
    600           free (yyls);
    601 #endif
    602         }
    603       return 2;
    604     }
     980      if (YYMAXDEPTH <= yystacksize)
     981    goto yyoverflowlab;
    605982      yystacksize *= 2;
    606       if (yystacksize > YYMAXDEPTH)
     983      if (YYMAXDEPTH < yystacksize)
    607984    yystacksize = YYMAXDEPTH;
    608 #ifndef YYSTACK_USE_ALLOCA
    609       yyfree_stacks = 1;
    610 #endif
    611       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
    612       __yy_memcpy ((char *)yyss, (char *)yyss1,
    613            size * (unsigned int) sizeof (*yyssp));
    614       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
    615       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
    616            size * (unsigned int) sizeof (*yyvsp));
    617 #ifdef YYLSP_NEEDED
    618       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
    619       __yy_memcpy ((char *)yyls, (char *)yyls1,
    620            size * (unsigned int) sizeof (*yylsp));
    621 #endif
     985
     986      {
     987    short *yyss1 = yyss;
     988    union yyalloc *yyptr =
     989      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
     990    if (! yyptr)
     991      goto yyoverflowlab;
     992    YYSTACK_RELOCATE (yyss);
     993    YYSTACK_RELOCATE (yyvs);
     994
     995#  undef YYSTACK_RELOCATE
     996    if (yyss1 != yyssa)
     997      YYSTACK_FREE (yyss1);
     998      }
     999# endif
    6221000#endif /* no yyoverflow */
    6231001
    624       yyssp = yyss + size - 1;
    625       yyvsp = yyvs + size - 1;
    626 #ifdef YYLSP_NEEDED
    627       yylsp = yyls + size - 1;
    628 #endif
    629 
    630 #if YYDEBUG != 0
    631       if (yydebug)
    632     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
    633 #endif
    634 
    635       if (yyssp >= yyss + yystacksize - 1)
     1002      yyssp = yyss + yysize - 1;
     1003      yyvsp = yyvs + yysize - 1;
     1004
     1005
     1006      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
     1007          (unsigned long int) yystacksize));
     1008
     1009      if (yyss + yystacksize - 1 <= yyssp)
    6361010    YYABORT;
    6371011    }
    6381012
    639 #if YYDEBUG != 0
    640   if (yydebug)
    641     fprintf(stderr, "Entering state %d\n", yystate);
    642 #endif
     1013  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
    6431014
    6441015  goto yybackup;
    645  yybackup:
     1016
     1017/*-----------.
     1018| yybackup.  |
     1019`-----------*/
     1020yybackup:
    6461021
    6471022/* Do appropriate processing given the current state.  */
    … …  
    6521027
    6531028  yyn = yypact[yystate];
    654   if (yyn == YYFLAG)
     1029  if (yyn == YYPACT_NINF)
    6551030    goto yydefault;
    6561031
    6571032  /* Not known => get a lookahead token if don't already have one.  */
    6581033
    659   /* yychar is either YYEMPTY or YYEOF
    660      or a valid token in external form.  */
    661 
     1034  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
    6621035  if (yychar == YYEMPTY)
    6631036    {
    664 #if YYDEBUG != 0
    665       if (yydebug)
    666     fprintf(stderr, "Reading a token: ");
    667 #endif
     1037      YYDPRINTF ((stderr, "Reading a token: "));
    6681038      yychar = YYLEX;
    6691039    }
    6701040
    671   /* Convert token to internal form (in yychar1) for indexing tables with */
    672 
    673   if (yychar <= 0)      /* This means end of input. */
     1041  if (yychar <= YYEOF)
    6741042    {
    675       yychar1 = 0;
    676       yychar = YYEOF;       /* Don't call YYLEX any more */
    677 
    678 #if YYDEBUG != 0
    679       if (yydebug)
    680     fprintf(stderr, "Now at end of input.\n");
    681 #endif
     1043      yychar = yytoken = YYEOF;
     1044      YYDPRINTF ((stderr, "Now at end of input.\n"));
    6821045    }
    6831046  else
    6841047    {
    685       yychar1 = YYTRANSLATE(yychar);
    686 
    687 #if YYDEBUG != 0
    688       if (yydebug)
    689     {
    690       fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
    691       /* Give the individual parser a way to print the precise meaning
    692          of a token, for further debugging info.  */
    693 #ifdef YYPRINT
    694       YYPRINT (stderr, yychar, yylval);
    695 #endif
    696       fprintf (stderr, ")\n");
    697     }
    698 #endif
     1048      yytoken = YYTRANSLATE (yychar);
     1049      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
    6991050    }
    7001051
    701   yyn += yychar1;
    702   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
     1052  /* If the proper action on seeing token YYTOKEN is to reduce or to
     1053     detect an error, take that action.  */
     1054  yyn += yytoken;
     1055  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    7031056    goto yydefault;
    704 
    7051057  yyn = yytable[yyn];
    706 
    707   /* yyn is what to do for this token type in this state.
    708      Negative => reduce, -yyn is rule number.
    709      Positive => shift, yyn is new state.
    710        New state is final state => don't bother to shift,
    711        just return success.
    712      0, or most negative number => error.  */
    713 
    714   if (yyn < 0)
     1058  if (yyn <= 0)
    7151059    {
    716       if (yyn == YYFLAG)
     1060      if (yyn == 0 || yyn == YYTABLE_NINF)
    7171061    goto yyerrlab;
    7181062      yyn = -yyn;
    7191063      goto yyreduce;
    7201064    }
    721   else if (yyn == 0)
    722     goto yyerrlab;
    7231065
    7241066  if (yyn == YYFINAL)
    … …  
    7261068
    7271069  /* Shift the lookahead token.  */
    728 
    729 #if YYDEBUG != 0
    730   if (yydebug)
    731     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
    732 #endif
     1070  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
    7331071
    7341072  /* Discard the token being shifted unless it is eof.  */
    … …  
    7371075
    7381076  *++yyvsp = yylval;
    739 #ifdef YYLSP_NEEDED
    740   *++yylsp = yylloc;
    741 #endif
    742 
    743   /* count tokens shifted since error; after three, turn off error status.  */
    744   if (yyerrstatus) yyerrstatus--;
     1077
     1078
     1079  /* Count tokens shifted since error; after three, turn off error
     1080     status.  */
     1081  if (yyerrstatus)
     1082    yyerrstatus--;
    7451083
    7461084  yystate = yyn;
    7471085  goto yynewstate;
    7481086
    749 /* Do the default action for the current state.  */
     1087
     1088/*-----------------------------------------------------------.
     1089| yydefault -- do the default action for the current state.  |
     1090`-----------------------------------------------------------*/
    7501091yydefault:
    751 
    7521092  yyn = yydefact[yystate];
    7531093  if (yyn == 0)
    7541094    goto yyerrlab;
    755 
    756 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
     1095  goto yyreduce;
     1096
     1097
     1098/*-----------------------------.
     1099| yyreduce -- Do a reduction.  |
     1100`-----------------------------*/
    7571101yyreduce:
     1102  /* yyn is the number of a rule to reduce with.  */
    7581103  yylen = yyr2[yyn];
    759   if (yylen > 0)
    760     yyval = yyvsp[1-yylen]; /* implement default value of the action */
    761 
    762 #if YYDEBUG != 0
    763   if (yydebug)
     1104
     1105  /* If YYLEN is nonzero, implement the default value of the action:
     1106     `$$ = $1'.
     1107
     1108     Otherwise, the following line sets YYVAL to garbage.
     1109     This behavior is undocumented and Bison
     1110     users should not rely upon it.  Assigning to YYVAL
     1111     unconditionally makes the parser a bit smaller, and it avoids a
     1112     GCC warning that YYVAL may be used uninitialized.  */
     1113  yyval = yyvsp[1-yylen];
     1114
     1115
     1116  YY_REDUCE_PRINT (yyn);
     1117  switch (yyn)
    7641118    {
    765       int i;
    766 
    767       fprintf (stderr, "Reducing via rule %d (line %d), ",
    768            yyn, yyrline[yyn]);
    769 
    770       /* Print the symbols being reduced, and their result.  */
    771       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
    772     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
    773       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    774     }
    775 #endif
    776 
    777 
    778   switch (yyn) {
    779 
    780 case 1:
    781 #line 109 "zparse.y"
    782 {zserver_list=yyvsp[0].cfg;;
    783     break;}
    784 case 2:
     1119        case 2:
     1120#line 106 "zparse.y"
     1121    {zserver_list=yyvsp[0].cfg;}
     1122    break;
     1123
     1124  case 3:
     1125#line 107 "zparse.y"
     1126    {zserver_list=NULL;}
     1127    break;
     1128
     1129  case 4:
    7851130#line 110 "zparse.y"
    786 {zserver_list=NULL;;
    787     break;}
    788 case 3:
     1131    {;}
     1132    break;
     1133
     1134  case 5:
     1135#line 111 "zparse.y"
     1136    {fprintf(errfile,"No version - not GSDL config file?\n");return(1);}
     1137    break;
     1138
     1139  case 6:
    7891140#line 113 "zparse.y"
    790 {;;
    791     break;}
    792 case 4:
    793 #line 114 "zparse.y"
    794 {fprintf(errfile,"No version - not GSDL config file?\n");return(1);;
    795     break;}
    796 case 5:
    797 #line 116 "zparse.y"
    798 {if (yyvsp[0].cfg!=NULL) {yyvsp[0].cfg->next=yyvsp[-1].cfg;yyval.cfg=yyvsp[0].cfg;};
    799     break;}
    800 case 7:
    801 #line 120 "zparse.y"
    802 {
     1141    {if (yyvsp[0].cfg!=NULL) {yyvsp[0].cfg->next=yyvsp[-1].cfg;yyval.cfg=yyvsp[0].cfg;}}
     1142    break;
     1143
     1144  case 8:
     1145#line 117 "zparse.y"
     1146    {
    8031147             if (YYRECOVERING)
    8041148               {yyval.cfg=NULL;YYRECOVERING=0;}
    … …  
    8191163               yyval.cfg->next=NULL;
    8201164             }
    821            ;
    822     break;}
    823 case 8:
    824 #line 140 "zparse.y"
    825 {yyval.cfg=NULL;
    826           fprintf(errfile,"discarding zserver (line %d)\n",lineno);;
    827     break;}
    828 case 9:
    829 #line 144 "zparse.y"
    830 {;;
    831     break;}
    832 case 10:
    833 #line 145 "zparse.y"
    834 {errormsg("Database name needs to be followed by a short "
     1165           }
     1166    break;
     1167
     1168  case 9:
     1169#line 137 "zparse.y"
     1170    {yyval.cfg=NULL;
     1171          fprintf(errfile,"discarding zserver (line %d)\n",lineno);}
     1172    break;
     1173
     1174  case 10:
     1175#line 141 "zparse.y"
     1176    {;}
     1177    break;
     1178
     1179  case 11:
     1180#line 142 "zparse.y"
     1181    {errormsg("Database name needs to be followed by a short "
    8351182              "descriptive name (enclosed in \" marks)");
    8361183             yyval.string=NULL;
    837              YYRECOVERING=1;;
    838     break;}
    839 case 11:
    840 #line 150 "zparse.y"
    841 {yyval.number=atoi(yyvsp[0].string);;
    842     break;}
    843 case 12:
     1184             YYRECOVERING=1;}
     1185    break;
     1186
     1187  case 12:
     1188#line 147 "zparse.y"
     1189    {yyval.number=atoi(yyvsp[0].string);}
     1190    break;
     1191
     1192  case 13:
     1193#line 148 "zparse.y"
     1194    {yyval.number=210;}
     1195    break;
     1196
     1197  case 14:
    8441198#line 151 "zparse.y"
    845 {yyval.number=210;;
    846     break;}
    847 case 13:
    848 #line 154 "zparse.y"
    849 {yyval.string=yyvsp[0].string;;
    850     break;}
    851 case 14:
     1199    {yyval.string=yyvsp[0].string;}
     1200    break;
     1201
     1202  case 15:
     1203#line 152 "zparse.y"
     1204    {yyval.string=yyvsp[0].string;
     1205                  errormsg("Icon must be enclosed in quotes");
     1206          yylex();yylex();}
     1207    break;
     1208
     1209  case 16:
    8521210#line 155 "zparse.y"
    853 {yyval.string=yyvsp[0].string;
    854                   errormsg("Icon must be enclosed in quotes");
    855           yylex();yylex();;
    856     break;}
    857 case 15:
    858 #line 158 "zparse.y"
    859 {yyval.string=NULL;;
    860     break;}
    861 case 16:
    862 #line 159 "zparse.y"
    863 {yyval.string=yyvsp[0].string;;
    864     break;}
    865 case 17:
    866 #line 160 "zparse.y"
    867 {yyval.string=yyvsp[0].string;
     1211    {yyval.string=NULL;}
     1212    break;
     1213
     1214  case 17:
     1215#line 156 "zparse.y"
     1216    {yyval.string=yyvsp[0].string;}
     1217    break;
     1218
     1219  case 18:
     1220#line 157 "zparse.y"
     1221    {yyval.string=yyvsp[0].string;
    8681222          /* this is because of the ':' */
    8691223              errormsg("Smallicon must be enclosed in quotes.\n");
    8701224          yylex();yylex();
    871           ;
    872     break;}
    873 case 18:
     1225          }
     1226    break;
     1227
     1228  case 19:
     1229#line 162 "zparse.y"
     1230    {yyval.string=NULL;}
     1231    break;
     1232
     1233  case 20:
     1234#line 164 "zparse.y"
     1235    {defLanguage=0;}
     1236    break;
     1237
     1238  case 21:
    8741239#line 165 "zparse.y"
    875 {yyval.string=NULL;;
    876     break;}
    877 case 19:
     1240    {yyval.about=NULL;}
     1241    break;
     1242
     1243  case 22:
    8781244#line 167 "zparse.y"
    879 {defLanguage=0;;
    880     break;}
    881 case 20:
    882 #line 168 "zparse.y"
    883 {yyval.about=NULL;;
    884     break;}
    885 case 21:
    886 #line 170 "zparse.y"
    887 {;;
    888     break;}
    889 case 22:
    890 #line 172 "zparse.y"
    891 {yyval.about=yyvsp[0].about;yyvsp[0].about->next=yyvsp[-1].about;;
    892     break;}
    893 case 23:
    894 #line 176 "zparse.y"
    895 {
     1245    {;}
     1246    break;
     1247
     1248  case 23:
     1249#line 169 "zparse.y"
     1250    {yyval.about=yyvsp[0].about;yyvsp[0].about->next=yyvsp[-1].about;}
     1251    break;
     1252
     1253  case 24:
     1254#line 173 "zparse.y"
     1255    {
    8961256                   if((yyval.about=malloc(sizeof(struct z3950aboutlist)))
    8971257                  ==NULL) {
    … …  
    9021262                   yyval.about->text=yyvsp[0].string;
    9031263                   yyval.about->next=NULL;
    904                  ;
    905     break;}
    906 case 24:
    907 #line 187 "zparse.y"
    908 {
     1264                 }
     1265    break;
     1266
     1267  case 25:
     1268#line 184 "zparse.y"
     1269    {
    9091270                   if (defLanguage)
    9101271                         {
    … …  
    9211282                   yyval.about->text=yyvsp[0].string;
    9221283                   yyval.about->next=NULL;
    923                  ;
    924     break;}
    925 case 25:
    926 #line 209 "zparse.y"
    927 {
     1284                 }
     1285    break;
     1286
     1287  case 26:
     1288#line 206 "zparse.y"
     1289    {
    9281290                   yyval.string=malloc(strlen(yyvsp[-2].string)+strlen(yyvsp[0].string)+1);
    9291291                   strncpy(yyval.string,yyvsp[-2].string,strlen(yyvsp[-2].string));
    … …  
    9311293                   strncpy(yyval.string+strlen(yyvsp[-2].string)+1,yyvsp[0].string,strlen(yyvsp[0].string));
    9321294                   free(yyvsp[-2].string);free(yyvsp[0].string);
    933                  ;
    934     break;}
    935 case 26:
    936 #line 216 "zparse.y"
    937 {;;
    938     break;}
    939 case 27:
    940 #line 224 "zparse.y"
    941 {errormsg("missing language");;
    942     break;}
    943 }
    944    /* the action file gets copied in in place of this dollarsign */
    945 #line 543 "/usr/share/bison.simple"
     1295                 }
     1296    break;
     1297
     1298  case 27:
     1299#line 213 "zparse.y"
     1300    {;}
     1301    break;
     1302
     1303  case 28:
     1304#line 221 "zparse.y"
     1305    {errormsg("missing language");}
     1306    break;
     1307
     1308
     1309    }
     1310
     1311/* Line 999 of yacc.c.  */
     1312#line 1309 "zparse.tab.c"
    9461313
    9471314
    9481315  yyvsp -= yylen;
    9491316  yyssp -= yylen;
    950 #ifdef YYLSP_NEEDED
    951   yylsp -= yylen;
    952 #endif
    953 
    954 #if YYDEBUG != 0
    955   if (yydebug)
    956     {
    957       short *ssp1 = yyss - 1;
    958       fprintf (stderr, "state stack now");
    959       while (ssp1 != yyssp)
    960     fprintf (stderr, " %d", *++ssp1);
    961       fprintf (stderr, "\n");
    962     }
    963 #endif
     1317
     1318
     1319  YY_STACK_PRINT (yyss, yyssp);
    9641320
    9651321  *++yyvsp = yyval;
    9661322
    967 #ifdef YYLSP_NEEDED
    968   yylsp++;
    969   if (yylen == 0)
    970     {
    971       yylsp->first_line = yylloc.first_line;
    972       yylsp->first_column = yylloc.first_column;
    973       yylsp->last_line = (yylsp-1)->last_line;
    974       yylsp->last_column = (yylsp-1)->last_column;
    975       yylsp->text = 0;
    976     }
    977   else
    978     {
    979       yylsp->last_line = (yylsp+yylen-1)->last_line;
    980       yylsp->last_column = (yylsp+yylen-1)->last_column;
    981     }
    982 #endif
    983 
    984   /* Now "shift" the result of the reduction.
    985      Determine what state that goes to,
    986      based on the state we popped back to
    987      and the rule number reduced by.  */
     1323
     1324  /* Now `shift' the result of the reduction.  Determine what state
     1325     that goes to, based on the state we popped back to and the rule
     1326     number reduced by.  */
    9881327
    9891328  yyn = yyr1[yyn];
    9901329
    991   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
    992   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     1330  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
     1331  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    9931332    yystate = yytable[yystate];
    9941333  else
    995     yystate = yydefgoto[yyn - YYNTBASE];
     1334    yystate = yydefgoto[yyn - YYNTOKENS];
    9961335
    9971336  goto yynewstate;
    9981337
    999 yyerrlab:   /* here on detecting error */
    1000 
    1001   if (! yyerrstatus)
    1002     /* If not already recovering from an error, report this error.  */
     1338
     1339/*------------------------------------.
     1340| yyerrlab -- here on detecting error |
     1341`------------------------------------*/
     1342yyerrlab:
     1343  /* If not already recovering from an error, report this error.  */
     1344  if (!yyerrstatus)
    10031345    {
    10041346      ++yynerrs;
    1005 
    1006 #ifdef YYERROR_VERBOSE
     1347#if YYERROR_VERBOSE
    10071348      yyn = yypact[yystate];
    10081349
    1009       if (yyn > YYFLAG && yyn < YYLAST)
     1350      if (YYPACT_NINF < yyn && yyn < YYLAST)
    10101351    {
    1011       int size = 0;
    1012       char *msg;
    1013       int x, count;
    1014 
    1015       count = 0;
    1016       /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
    1017       for (x = (yyn < 0 ? -yyn : 0);
    1018            x < (sizeof(yytname) / sizeof(char *)); x++)
    1019         if (yycheck[x + yyn] == x)
    1020           size += strlen(yytname[x]) + 15, count++;
    1021       msg = (char *) malloc(size + 15);
    1022       if (msg != 0)
     1352      YYSIZE_T yysize = 0;
     1353      int yytype = YYTRANSLATE (yychar);
     1354      char *yymsg;
     1355      int yyx, yycount;
     1356
     1357      yycount = 0;
     1358      /* Start YYX at -YYN if negative to avoid negative indexes in
     1359         YYCHECK.  */
     1360      for (yyx = yyn < 0 ? -yyn : 0;
     1361           yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
     1362        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
     1363          yysize += yystrlen (yytname[yyx]) + 15, yycount++;
     1364      yysize += yystrlen ("syntax error, unexpected ") + 1;
     1365      yysize += yystrlen (yytname[yytype]);
     1366      yymsg = (char *) YYSTACK_ALLOC (yysize);
     1367      if (yymsg != 0)
    10231368        {
    1024           strcpy(msg, "parse error");
    1025 
    1026           if (count < 5)
     1369          char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
     1370          yyp = yystpcpy (yyp, yytname[yytype]);
     1371
     1372          if (yycount < 5)
    10271373        {
    1028           count = 0;
    1029           for (x = (yyn < 0 ? -yyn : 0);
    1030                x < (sizeof(yytname) / sizeof(char *)); x++)
    1031             if (yycheck[x + yyn] == x)
     1374          yycount = 0;
     1375          for (yyx = yyn < 0 ? -yyn : 0;
     1376               yyx < (int) (sizeof (yytname) / sizeof (char *));
     1377               yyx++)
     1378            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
    10321379              {
    1033             strcat(msg, count == 0 ? ", expecting `" : " or `");
    1034             strcat(msg, yytname[x]);
    1035             strcat(msg, "'");
    1036             count++;
     1380            const char *yyq = ! yycount ? ", expecting " : " or ";
     1381            yyp = yystpcpy (yyp, yyq);
     1382            yyp = yystpcpy (yyp, yytname[yyx]);
     1383            yycount++;
    10371384              }
    10381385        }
    1039           yyerror(msg);
    1040           free(msg);
     1386          yyerror (yymsg);
     1387          YYSTACK_FREE (yymsg);
    10411388        }
    10421389      else
    1043         yyerror ("parse error; also virtual memory exceeded");
     1390        yyerror ("syntax error; also virtual memory exhausted");
    10441391    }
    10451392      else
    10461393#endif /* YYERROR_VERBOSE */
    1047     yyerror("parse error");
     1394    yyerror ("syntax error");
    10481395    }
    10491396
    1050   goto yyerrlab1;
    1051 yyerrlab1:   /* here on error raised explicitly by an action */
     1397
    10521398
    10531399  if (yyerrstatus == 3)
    10541400    {
    1055       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
    1056 
    1057       /* return failure if at end of input */
     1401      /* If just tried and failed to reuse lookahead token after an
     1402     error, discard it.  */
     1403
     1404      /* Return failure if at end of input.  */
    10581405      if (yychar == YYEOF)
     1406        {
     1407      /* Pop the error token.  */
     1408          YYPOPSTACK;
     1409      /* Pop the rest of the stack.  */
     1410      while (yyss < yyssp)
     1411        {
     1412          YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
     1413          yydestruct (yystos[*yyssp], yyvsp);
     1414          YYPOPSTACK;
     1415        }
     1416      YYABORT;
     1417        }
     1418
     1419      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
     1420      yydestruct (yytoken, &yylval);
     1421      yychar = YYEMPTY;
     1422
     1423    }
     1424
     1425  /* Else will try to reuse lookahead token after shifting the error
     1426     token.  */
     1427  goto yyerrlab1;
     1428
     1429
     1430/*----------------------------------------------------.
     1431| yyerrlab1 -- error raised explicitly by an action.  |
     1432`----------------------------------------------------*/
     1433yyerrlab1:
     1434  yyerrstatus = 3;  /* Each real token shifted decrements this.  */
     1435
     1436  for (;;)
     1437    {
     1438      yyn = yypact[yystate];
     1439      if (yyn != YYPACT_NINF)
     1440    {
     1441      yyn += YYTERROR;
     1442      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
     1443        {
     1444          yyn = yytable[yyn];
     1445          if (0 < yyn)
     1446        break;
     1447        }
     1448    }
     1449
     1450      /* Pop the current state because it cannot handle the error token.  */
     1451      if (yyssp == yyss)
    10591452    YYABORT;
    10601453
    1061 #if YYDEBUG != 0
    1062       if (yydebug)
    1063     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
    1064 #endif
    1065 
    1066       yychar = YYEMPTY;
     1454      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
     1455      yydestruct (yystos[yystate], yyvsp);
     1456      yyvsp--;
     1457      yystate = *--yyssp;
     1458
     1459      YY_STACK_PRINT (yyss, yyssp);
    10671460    }
    1068 
    1069   /* Else will try to reuse lookahead token
    1070      after shifting the error token.  */
    1071 
    1072   yyerrstatus = 3;      /* Each real token shifted decrements this */
    1073 
    1074   goto yyerrhandle;
    1075 
    1076 yyerrdefault:  /* current state does not do anything special for the error token. */
    1077 
    1078 #if 0
    1079   /* This is wrong; only states that explicitly want error tokens
    1080      should shift them.  */
    1081   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
    1082   if (yyn) goto yydefault;
    1083 #endif
    1084 
    1085 yyerrpop:   /* pop the current state because it cannot handle the error token */
    1086 
    1087   if (yyssp == yyss) YYABORT;
    1088   yyvsp--;
    1089   yystate = *--yyssp;
    1090 #ifdef YYLSP_NEEDED
    1091   yylsp--;
    1092 #endif
    1093 
    1094 #if YYDEBUG != 0
    1095   if (yydebug)
    1096     {
    1097       short *ssp1 = yyss - 1;
    1098       fprintf (stderr, "Error: state stack now");
    1099       while (ssp1 != yyssp)
    1100     fprintf (stderr, " %d", *++ssp1);
    1101       fprintf (stderr, "\n");
    1102     }
    1103 #endif
    1104 
    1105 yyerrhandle:
    1106 
    1107   yyn = yypact[yystate];
    1108   if (yyn == YYFLAG)
    1109     goto yyerrdefault;
    1110 
    1111   yyn += YYTERROR;
    1112   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    1113     goto yyerrdefault;
    1114 
    1115   yyn = yytable[yyn];
    1116   if (yyn < 0)
    1117     {
    1118       if (yyn == YYFLAG)
    1119     goto yyerrpop;
    1120       yyn = -yyn;
    1121       goto yyreduce;
    1122     }
    1123   else if (yyn == 0)
    1124     goto yyerrpop;
    11251461
    11261462  if (yyn == YYFINAL)
    11271463    YYACCEPT;
    11281464
    1129 #if YYDEBUG != 0
    1130   if (yydebug)
    1131     fprintf(stderr, "Shifting error token, ");
    1132 #endif
     1465  YYDPRINTF ((stderr, "Shifting error token, "));
    11331466
    11341467  *++yyvsp = yylval;
    1135 #ifdef YYLSP_NEEDED
    1136   *++yylsp = yylloc;
    1137 #endif
     1468
    11381469
    11391470  yystate = yyn;
    11401471  goto yynewstate;
    11411472
    1142  yyacceptlab:
    1143   /* YYACCEPT comes here.  */
    1144   if (yyfree_stacks)
    1145     {
    1146       free (yyss);
    1147       free (yyvs);
    1148 #ifdef YYLSP_NEEDED
    1149       free (yyls);
    1150 #endif
    1151     }
    1152   return 0;
    1153 
    1154  yyabortlab:
    1155   /* YYABORT comes here.  */
    1156   if (yyfree_stacks)
    1157     {
    1158       free (yyss);
    1159       free (yyvs);
    1160 #ifdef YYLSP_NEEDED
    1161       free (yyls);
    1162 #endif
    1163     }
    1164   return 1;
     1473
     1474/*-------------------------------------.
     1475| yyacceptlab -- YYACCEPT comes here.  |
     1476`-------------------------------------*/
     1477yyacceptlab:
     1478  yyresult = 0;
     1479  goto yyreturn;
     1480
     1481/*-----------------------------------.
     1482| yyabortlab -- YYABORT comes here.  |
     1483`-----------------------------------*/
     1484yyabortlab:
     1485  yyresult = 1;
     1486  goto yyreturn;
     1487
     1488#ifndef yyoverflow
     1489/*----------------------------------------------.
     1490| yyoverflowlab -- parser overflow comes here.  |
     1491`----------------------------------------------*/
     1492yyoverflowlab:
     1493  yyerror ("parser stack overflow");
     1494  yyresult = 2;
     1495  /* Fall through.  */
     1496#endif
     1497
     1498yyreturn:
     1499#ifndef yyoverflow
     1500  if (yyss != yyssa)
     1501    YYSTACK_FREE (yyss);
     1502#endif
     1503  return yyresult;
    11651504}
    1166 #line 233 "zparse.y"
     1505
     1506
     1507#line 106 "zparse.y"
    11671508
    11681509/*int strncasecmp (const char *, const char *,size_t);*/
    … …  
    11881529}
    11891530* */
     1531
Note: See TracChangeset for help on using the changeset viewer.