
/*  A Bison parser, made from ./fconfig.y
    by GNU Bison version 1.28  */

#define YYBISON 1  /* Identify Bison output.  */

#define yyparse fconfparse
#define yylex fconflex
#define yyerror fconferror
#define yylval fconflval
#define yychar fconfchar
#define yydebug fconfdebug
#define yynerrs fconfnerrs
#define	FIELD	257
#define	STRINGTYPE	258
#define	QDEFAULT	259
#define	MATCHING	260
#define	ENUM	261
#define	MULTIENUMTOK	262
#define	VALUES	263
#define	DEFAULT	264
#define	EXACT_REGEXP	265
#define	INEXACT_REGEXP	266
#define	ALL	267
#define	FORMAT	268
#define	ENUMSEPARATORSTOK	269
#define	MULTITEXTTYPE	270
#define	DATETYPE	271
#define	ENUM_IN_FILE	272
#define	MULTI_ENUM_IN_FILE	273
#define	PATHTOK	274
#define	FIELDSTOK	275
#define	KEYTOK	276
#define	QSTRING	277
#define	INTVAL	278
#define	TEXTSEARCH	279
#define	QUERYTOK	280
#define	FORMATTOK	281
#define	INDEXTOK	282
#define	SEPARATORTOK	283
#define	RESTRICTEDTOK	284
#define	NOSPACESTOK	285
#define	INTEGERTOK	286
#define	INPUTDEFAULTTOK	287
#define	BUILTINTOK	288
#define	ALLOWANYVALUETOK	289
#define	REQUIRETOK	290
#define	APPENDFIELDTOK	291
#define	SETFIELDTOK	292
#define	CHANGETOK	293
#define	DESCRIPTIONTOK	294
#define	INPUTTOK	295
#define	DATABASEINFOTOK	296
#define	DEBUGMODETOK	297
#define	KEEPRECTOK	298
#define	NOTIFYEXPTOK	299
#define	LIBEXECDIRTOK	300
#define	SUBMITTERACKTOK	301
#define	BUSINESSDAYTOK	302
#define	BUSINESSWEEKTOK	303
#define	CREATECATEGORYDIRSTOK	304
#define	FALSETOK	305
#define	TRUETOK	306
#define	MAILFORMATTOK	307
#define	TOADDRESSESTOK	308
#define	FROMADDRESSTOK	309
#define	REPLYTOTOK	310
#define	FIXEDTOK	311
#define	BODYTOK	312
#define	HEADERTOK	313
#define	AUDITTRAILFMTTOK	314
#define	ADDAUDITTRAILTOK	315
#define	REQUIRECHANGEREASONTOK	316
#define	READONLYTOK	317
#define	BINARYINDEXTOK	318
#define	RAWTOK	319
#define	BADTOK	320
#define	AUXFLAGSTOK	321
#define	PRLISTTOK	322
#define	MAXPRSTOK	323
#define	EDITONLYTOK	324
#define	VIRTUALFORMATTOK	325
#define	CATPERMSTOK	326

#line 1 "./fconfig.y"

#include "gnats.h"
#include "index.h"
#include "field.h"
  extern DatabaseInfo databaseBeingDefined;
  static FieldDef currField;
  static ChangeActions currChange;
  static FieldEdit *currEdit;
  static QueryFormat *qformat;
  static FieldList requiredFlds;
  static InputTemplate *inputTemplate;
  static MailMessageFormat mailFormat;
  IndexDesc indexEntry;
  static int badFile;
  struct qstring;

  extern char *takeQString (struct qstring *str);
  extern char *qStrVal (struct qstring *str);

#line 21 "./fconfig.y"
typedef union {
  int intval;
  char *sval;
  struct qstring *qstr;
  AdmFieldDesc *adm_field_des;
  FieldList flist;
  StringList *stringlist;
  InputTemplate *inputlist;
  MailAddress *mailaddr;
  MailAddressList *mailaddrlist;
} YYSTYPE;
#include <stdio.h>

#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif



#define	YYFINAL		348
#define	YYFLAG		-32768
#define	YYNTBASE	77

#define YYTRANSLATE(x) ((unsigned)(x) <= 326 ? yytranslate[x] : 165)

static const char yytranslate[] = {     0,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,    75,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,    73,    76,    74,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
    47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
    67,    68,    69,    70,    71,    72
};

#if YYDEBUG != 0
static const short yyprhs[] = {     0,
     0,     2,     4,    13,    18,    23,    24,    26,    28,    31,
    34,    37,    40,    43,    46,    51,    56,    59,    62,    64,
    66,    68,    69,    71,    74,    79,    84,    87,    89,    92,
    94,    96,    98,   100,   103,   105,   107,   110,   112,   115,
   118,   120,   126,   132,   134,   137,   142,   147,   152,   157,
   162,   167,   168,   171,   175,   179,   183,   185,   186,   188,
   191,   196,   201,   204,   207,   209,   212,   214,   216,   219,
   221,   227,   232,   234,   236,   237,   239,   241,   244,   245,
   249,   253,   254,   258,   261,   263,   266,   268,   271,   273,
   276,   281,   286,   288,   290,   293,   295,   298,   301,   308,
   313,   315,   317,   319,   322,   324,   327,   330,   333,   335,
   338,   340,   343,   346,   348,   350,   352,   355,   357,   360,
   362,   367,   369,   371,   374,   375,   377,   379,   382,   387,
   392,   395,   398,   401,   404,   406,   409,   412,   413,   415,
   417,   420,   425,   430,   432,   435,   437,   442,   447,   449,
   451,   453,   456,   459,   464,   469,   471,   473,   476,   479,
   482,   487,   492,   495,   496,   501,   506,   508,   511,   516,
   521,   523,   526,   528,   531,   536,   541,   544,   546,   549,
   551,   553,   558,   563,   568,   571,   574,   578,   582,   584,
   586,   589,   592,   594,   596,   600,   602
};

static const short yyrhs[] = {    78,
     0,    80,     0,    79,    84,   127,   164,   151,    95,   139,
   145,     0,    42,    73,    81,    74,     0,    42,    73,    80,
    74,     0,     0,     1,     0,    82,     0,    81,    82,     0,
    43,    83,     0,    44,    83,     0,    45,    83,     0,    46,
    23,     0,    47,    83,     0,    48,    24,    75,    24,     0,
    49,    24,    75,    24,     0,    50,    83,     0,    72,    23,
     0,    51,     0,    52,     0,    85,     0,     0,    86,     0,
    85,    86,     0,    87,    73,    88,    74,     0,    87,    73,
    80,    74,     0,     3,    23,     0,    89,     0,    88,    89,
     0,    91,     0,   125,     0,   124,     0,    90,     0,    71,
   158,     0,    92,     0,    94,     0,    16,   109,     0,    17,
     0,    32,   109,     0,    68,   110,     0,     4,     0,     4,
     6,    73,    93,    74,     0,     4,     6,    73,    80,    74,
     0,    23,     0,    93,    23,     0,     7,    73,   112,    74,
     0,    18,    73,   117,    74,     0,    19,    73,   119,    74,
     0,     8,    73,   113,    74,     0,     7,    73,    80,    74,
     0,    18,    73,    80,    74,     0,     0,    95,    96,     0,
    98,   100,    74,     0,    98,   100,    74,     0,    39,    99,
    73,     0,    23,     0,     0,   101,     0,   100,   101,     0,
    36,    73,   102,    74,     0,    36,    73,    80,    74,     0,
    38,   104,     0,    37,   104,     0,    61,     0,    60,   158,
     0,    62,     0,   103,     0,   102,   103,     0,    23,     0,
   105,    73,   106,   107,    74,     0,   105,    73,    80,    74,
     0,    23,     0,    23,     0,     0,   108,     0,    23,     0,
   108,    23,     0,     0,    73,   121,    74,     0,    73,    80,
    74,     0,     0,    73,   111,    74,     0,    69,    24,     0,
   115,     0,   112,   115,     0,   114,     0,   113,   114,     0,
   115,     0,    15,    23,     0,     9,    73,   116,    74,     0,
     9,    73,    80,    74,     0,   121,     0,    23,     0,   116,
    23,     0,   118,     0,   117,   118,     0,    20,    23,     0,
    21,    73,   122,    74,    22,    23,     0,    21,    73,    80,
    74,     0,   121,     0,    35,     0,   120,     0,   117,   120,
     0,   118,     0,    15,    23,     0,    10,    23,     0,    33,
    23,     0,   123,     0,   122,   123,     0,    23,     0,     5,
    11,     0,     5,    12,     0,    25,     0,    30,     0,    31,
     0,    34,    23,     0,    97,     0,    40,    23,     0,    63,
     0,    67,    73,   126,    74,     0,    70,     0,    23,     0,
   126,    23,     0,     0,   128,     0,   129,     0,   128,   129,
     0,   130,    73,   131,    74,     0,   130,    73,    80,    74,
     0,    26,    23,     0,   132,   133,     0,   134,   132,     0,
    21,    13,     0,   136,     0,   135,   136,     0,   136,   135,
     0,     0,   134,     0,    65,     0,    27,    23,     0,    21,
    73,   137,    74,     0,    21,    73,    80,    74,     0,   138,
     0,   137,   138,     0,    23,     0,   140,    73,   141,    74,
     0,   140,    73,    80,    74,     0,    80,     0,    28,     0,
   142,     0,   141,   142,     0,    20,    23,     0,    21,    73,
   143,    74,     0,    21,    73,    80,    74,     0,   144,     0,
   138,     0,   143,   138,     0,    29,    23,     0,    64,    83,
     0,    41,    73,   146,    74,     0,    41,    73,    80,    74,
     0,   149,   147,     0,     0,    36,    73,   148,    74,     0,
    36,    73,    80,    74,     0,   138,     0,   148,   138,     0,
    21,    73,   150,    74,     0,    21,    73,    80,    74,     0,
    23,     0,   150,    23,     0,   152,     0,   151,   152,     0,
   153,    73,   154,    74,     0,   153,    73,    80,    74,     0,
    53,    23,     0,   155,     0,   154,   155,     0,   156,     0,
   157,     0,    54,    73,   160,    74,     0,    55,    73,   161,
    74,     0,    56,    73,   160,    74,     0,    58,   158,     0,
    59,   158,     0,   159,   131,    74,     0,   159,    80,    74,
     0,    73,     0,   161,     0,   160,   161,     0,    57,    23,
     0,   162,     0,   163,     0,   162,    76,   163,     0,    23,
     0,    60,   158,     0
};

#endif

#if YYDEBUG != 0
static const short yyrline[] = { 0,
    62,    63,    66,    69,    70,    71,    76,    78,    79,    82,
    85,    88,    91,    94,    97,   100,   103,   106,   111,   112,
   115,   116,   121,   122,   125,   128,   133,   148,   149,   152,
   153,   154,   155,   158,   164,   165,   166,   170,   174,   178,
   184,   187,   190,   193,   197,   203,   207,   212,   217,   226,
   227,   230,   231,   234,   240,   251,   260,   263,   268,   269,
   272,   273,   274,   278,   283,   286,   290,   295,   296,   299,
   307,   308,   311,   322,   327,   330,   334,   339,   346,   347,
   348,   351,   352,   355,   359,   360,   363,   364,   367,   368,
   373,   374,   375,   378,   382,   388,   389,   392,   395,   422,
   423,   424,   429,   430,   433,   434,   439,   442,   447,   452,
   459,   467,   470,   475,   478,   481,   484,   494,   495,   498,
   501,   504,   509,   513,   519,   520,   523,   524,   527,   531,
   537,   547,   548,   551,   552,   553,   554,   557,   558,   561,
   566,   571,   572,   575,   578,   584,   598,   602,   606,   609,
   614,   615,   618,   621,   622,   623,   626,   629,   634,   637,
   642,   643,   645,   650,   651,   654,   660,   663,   669,   673,
   678,   700,   727,   728,   731,   735,   741,   755,   756,   759,
   763,   767,   770,   773,   778,   781,   784,   785,   791,   801,
   806,   816,   821,   828,   831,   841,   847
};
#endif


#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

static const char * const yytname[] = {   "$","error","$undefined.","FIELD",
"STRINGTYPE","QDEFAULT","MATCHING","ENUM","MULTIENUMTOK","VALUES","DEFAULT",
"EXACT_REGEXP","INEXACT_REGEXP","ALL","FORMAT","ENUMSEPARATORSTOK","MULTITEXTTYPE",
"DATETYPE","ENUM_IN_FILE","MULTI_ENUM_IN_FILE","PATHTOK","FIELDSTOK","KEYTOK",
"QSTRING","INTVAL","TEXTSEARCH","QUERYTOK","FORMATTOK","INDEXTOK","SEPARATORTOK",
"RESTRICTEDTOK","NOSPACESTOK","INTEGERTOK","INPUTDEFAULTTOK","BUILTINTOK","ALLOWANYVALUETOK",
"REQUIRETOK","APPENDFIELDTOK","SETFIELDTOK","CHANGETOK","DESCRIPTIONTOK","INPUTTOK",
"DATABASEINFOTOK","DEBUGMODETOK","KEEPRECTOK","NOTIFYEXPTOK","LIBEXECDIRTOK",
"SUBMITTERACKTOK","BUSINESSDAYTOK","BUSINESSWEEKTOK","CREATECATEGORYDIRSTOK",
"FALSETOK","TRUETOK","MAILFORMATTOK","TOADDRESSESTOK","FROMADDRESSTOK","REPLYTOTOK",
"FIXEDTOK","BODYTOK","HEADERTOK","AUDITTRAILFMTTOK","ADDAUDITTRAILTOK","REQUIRECHANGEREASONTOK",
"READONLYTOK","BINARYINDEXTOK","RAWTOK","BADTOK","AUXFLAGSTOK","PRLISTTOK","MAXPRSTOK",
"EDITONLYTOK","VIRTUALFORMATTOK","CATPERMSTOK","'{'","'}'","'-'","'|'","config",
"configEnts","databaseInfo","parseError","databaseInfoList","databaseInfoEnt",
"booleanVal","fieldDecStmt","fieldDecList","fieldDec","startFieldDec","fieldDataList",
"fieldData","virtualFieldFormat","fieldDataType","stringType","regexpList","enumType",
"globalChangeEnts","globalChangeEnt","changeClause","changeHeader","optChangeExpr",
"changeOpts","changeOpt","reqFieldNameList","reqFieldNameEnt","fieldEditOpts",
"fieldEditName","fieldEditFormat","optFieldEditFieldList","fieldEditFieldList",
"optSimple","prListOpts","prListOptList","enumcontents","multienumcontents",
"multiEnumItem","enumItem","enumValueList","enumFileContents","enumFileItem",
"multiEnumFileContents","multiEnumFileItem","defaultFieldVal","enumFieldList",
"enumFieldMember","queryDefault","miscOptions","auxFlagsList","optQueryList",
"queryList","query","queryBegin","queryFmt","queryFieldDesc","optQueryOpts",
"queryOpts","queryPrintf","queryfields","queryFieldsList","FieldListMember",
"indexDescription","indexheader","indexlist","indexEnt","indexFieldList","indexSep",
"inputDescription","inputEnt","requiredFields","requiredFieldsList","inputFields",
"inputFieldsList","mailFormatList","mailFormat","mailFormatHeader","mailFormatBody",
"mailFormatEnt","bodyFormat","headerFormat","plainFormat","plainFormatHeader",
"mailAddressList","mailAddress","mailAddressTries","MailAddressMember","auditTrailFmt", NULL
};
#endif

static const short yyr1[] = {     0,
    77,    77,    78,    79,    79,    79,    80,    81,    81,    82,
    82,    82,    82,    82,    82,    82,    82,    82,    83,    83,
    84,    84,    85,    85,    86,    86,    87,    88,    88,    89,
    89,    89,    89,    90,    91,    91,    91,    91,    91,    91,
    92,    92,    92,    93,    93,    94,    94,    94,    94,    94,
    94,    95,    95,    96,    97,    98,    99,    99,   100,   100,
   101,   101,   101,   101,   101,   101,   101,   102,   102,   103,
   104,   104,   105,   106,   107,   107,   108,   108,   109,   109,
   109,   110,   110,   111,   112,   112,   113,   113,   114,   114,
   115,   115,   115,   116,   116,   117,   117,   118,   118,   118,
   118,   118,   119,   119,   120,   120,   121,   121,   122,   122,
   123,   124,   124,   125,   125,   125,   125,   125,   125,   125,
   125,   125,   126,   126,   127,   127,   128,   128,   129,   129,
   130,   131,   131,   132,   132,   132,   132,   133,   133,   134,
   135,   136,   136,   137,   137,   138,   139,   139,   139,   140,
   141,   141,   142,   142,   142,   142,   143,   143,   144,   144,
   145,   145,   146,   147,   147,   147,   148,   148,   149,   149,
   150,   150,   151,   151,   152,   152,   153,   154,   154,   155,
   155,   155,   155,   155,   156,   157,   158,   158,   159,   160,
   160,   161,   161,   162,   162,   163,   164
};

static const short yyr2[] = {     0,
     1,     1,     8,     4,     4,     0,     1,     1,     2,     2,
     2,     2,     2,     2,     4,     4,     2,     2,     1,     1,
     1,     0,     1,     2,     4,     4,     2,     1,     2,     1,
     1,     1,     1,     2,     1,     1,     2,     1,     2,     2,
     1,     5,     5,     1,     2,     4,     4,     4,     4,     4,
     4,     0,     2,     3,     3,     3,     1,     0,     1,     2,
     4,     4,     2,     2,     1,     2,     1,     1,     2,     1,
     5,     4,     1,     1,     0,     1,     1,     2,     0,     3,
     3,     0,     3,     2,     1,     2,     1,     2,     1,     2,
     4,     4,     1,     1,     2,     1,     2,     2,     6,     4,
     1,     1,     1,     2,     1,     2,     2,     2,     1,     2,
     1,     2,     2,     1,     1,     1,     2,     1,     2,     1,
     4,     1,     1,     2,     0,     1,     1,     2,     4,     4,
     2,     2,     2,     2,     1,     2,     2,     0,     1,     1,
     2,     4,     4,     1,     2,     1,     4,     4,     1,     1,
     1,     2,     2,     4,     4,     1,     1,     2,     2,     2,
     4,     4,     2,     0,     4,     4,     1,     2,     4,     4,
     1,     2,     1,     2,     4,     4,     2,     1,     2,     1,
     1,     4,     4,     4,     2,     2,     3,     3,     1,     1,
     2,     2,     1,     1,     3,     1,     2
};

static const short yydefact[] = {     0,
     7,     0,     1,    22,     2,     0,     0,   125,    21,    23,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     8,    27,     0,     0,   126,   127,     0,    24,
     0,    19,    20,    10,    11,    12,    13,    14,     0,     0,
    17,    18,     5,     4,     9,   131,     0,     0,   128,     0,
    41,     0,     0,     0,    79,    38,     0,     0,   114,   115,
   116,    79,     0,    58,     0,   120,     0,    82,   122,     0,
     0,     0,    28,    33,    30,    35,    36,   118,     0,    32,
    31,     0,     0,   189,   197,     0,     0,    52,   173,     0,
     0,     0,   140,     0,     0,   138,     0,     0,   135,     0,
   112,   113,     0,     0,     0,    37,     0,     0,    39,   117,
    57,     0,   119,     0,     0,    40,    34,    26,    25,    29,
     0,     0,     0,     0,    65,    67,     0,    59,    15,    16,
     0,     0,   177,     0,   174,     0,   134,     0,   141,   130,
   129,   132,   139,   133,     0,   136,   137,     0,     0,     0,
     0,     0,     0,    85,    93,     0,     0,    87,    89,     0,
     0,     0,     0,   102,     0,     0,    96,   101,     0,     0,
    96,     0,   103,    56,   123,     0,     0,     0,     0,    73,
    64,     0,    63,    66,    55,    60,   188,   187,   150,   149,
    53,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,   178,   180,   181,   146,     0,     0,   144,    44,     0,
     0,     0,   107,   108,    50,    46,    86,    90,    49,    88,
    81,    80,    98,     0,    51,    47,    97,   106,    97,   104,
    48,   124,   121,    84,    83,    70,     0,     0,    68,     0,
     0,     0,     3,     0,     0,     0,     0,   185,   186,   176,
   175,   179,   143,   142,   145,    43,    45,    42,    94,     0,
     0,   111,     0,     0,   109,    62,    61,    69,    74,     0,
    75,    54,     0,     0,     0,     0,     0,     0,     0,   151,
   156,   196,     0,     0,   190,   193,   194,     0,     0,    92,
    95,    91,   100,     0,   110,    72,    77,     0,    76,     0,
     0,     0,   164,   153,     0,   159,   160,   148,   147,   152,
   192,   182,   191,     0,   183,   184,     0,    71,    78,     0,
   162,   161,     0,   163,     0,   157,     0,   195,    99,   171,
     0,     0,     0,   155,   154,   158,   170,   172,   169,     0,
   167,     0,   166,   165,   168,     0,     0,     0
};

static const short yydefgoto[] = {   346,
     3,     4,     5,    22,    23,    34,     8,     9,    10,    11,
    72,    73,    74,    75,    76,   211,    77,   134,   191,    78,
    79,   112,   127,   128,   238,   239,   181,   182,   271,   298,
   299,   106,   116,   178,   153,   157,   158,   159,   261,   166,
   167,   172,   173,   155,   264,   265,    80,    81,   176,    26,
    27,    28,    29,    95,    96,   142,    97,    98,    99,   207,
   208,   193,   194,   279,   280,   327,   281,   243,   302,   324,
   342,   303,   332,    88,    89,    90,   201,   202,   203,   204,
    85,    86,   284,   285,   286,   287,    48
};

static const short yypact[] = {    23,
-32768,   -52,-32768,    25,-32768,     7,     9,    12,    25,-32768,
    -9,   -15,   -15,   -15,    71,   -15,    80,    82,   -15,    85,
    36,   212,-32768,-32768,    96,    61,    12,-32768,    54,-32768,
   140,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    94,   119,
-32768,-32768,-32768,-32768,-32768,-32768,    79,    70,-32768,    21,
   154,   175,   108,   124,   127,-32768,   129,   131,-32768,-32768,
-32768,   127,   190,   213,   214,-32768,   162,   169,-32768,    79,
   171,   159,-32768,-32768,-32768,-32768,-32768,-32768,   187,-32768,
-32768,   219,   228,-32768,-32768,    21,   240,    70,-32768,   193,
    14,   245,-32768,   196,   197,   207,     2,   259,   256,   215,
-32768,-32768,   152,   186,   106,-32768,   211,   254,-32768,-32768,
-32768,   217,-32768,   262,   222,-32768,-32768,-32768,-32768,-32768,
   220,   269,   269,    79,-32768,-32768,    76,-32768,-32768,-32768,
   221,   224,-32768,   181,-32768,    34,-32768,    95,-32768,-32768,
-32768,-32768,-32768,-32768,   229,-32768,-32768,   132,   230,   271,
   273,   226,     8,-32768,-32768,   278,     0,-32768,-32768,   231,
   232,   281,   234,-32768,   235,    10,-32768,-32768,   285,   254,
   236,   237,-32768,-32768,-32768,    17,   288,   239,   182,-32768,
-32768,   242,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   187,   275,   244,   246,   247,   248,    79,    79,   249,
   223,-32768,-32768,-32768,-32768,   251,    24,-32768,-32768,   252,
    46,   191,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,   227,-32768,-32768,-32768,-32768,   236,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,   255,    48,-32768,   250,
   179,   257,-32768,    38,    86,    86,    86,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   258,
    50,-32768,   260,    52,-32768,-32768,-32768,-32768,-32768,   261,
   295,-32768,   167,   299,   263,   301,   -15,   264,    41,-32768,
-32768,-32768,   305,   -11,-32768,   265,-32768,   266,    11,-32768,
-32768,-32768,-32768,   309,-32768,-32768,-32768,   268,   310,   270,
   272,   274,   303,-32768,    95,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,   314,-32768,-32768,   321,-32768,-32768,   253,
-32768,-32768,   276,-32768,   277,-32768,    55,-32768,-32768,-32768,
   279,    72,    95,-32768,-32768,-32768,-32768,-32768,-32768,   280,
-32768,    77,-32768,-32768,-32768,   345,   347,-32768
};

static const short yypgoto[] = {-32768,
-32768,-32768,    -6,-32768,   328,   -12,-32768,-32768,   343,-32768,
-32768,   283,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   225,-32768,   164,  -124,-32768,   120,   238,-32768,-32768,-32768,
-32768,   298,-32768,-32768,-32768,-32768,   200,   -87,-32768,   267,
   -89,-32768,   192,   -94,-32768,    99,-32768,-32768,-32768,-32768,
-32768,   337,-32768,   282,   284,-32768,   286,   287,   289,-32768,
  -202,-32768,-32768,-32768,    87,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,   290,-32768,-32768,   166,-32768,-32768,
   -64,-32768,   118,  -135,-32768,    56,-32768
};


#define	YYLAST		387


static const short yytable[] = {    21,
    35,    36,   186,    38,   255,   117,    41,     1,   149,   150,
   161,   282,   168,   168,   156,   154,   149,   150,   171,   150,
     6,     1,    91,     1,    71,    -6,   137,     7,    92,   162,
   163,    24,   151,   282,     1,    32,    33,    25,     1,   232,
   151,    91,   151,    94,   164,   283,   205,    92,    -6,    12,
    13,    14,    15,    16,    17,    18,    19,   274,   275,   184,
   274,   275,   312,    31,     2,   217,   276,   283,   257,   276,
   236,   168,   291,   219,   262,   168,   227,   205,    20,   131,
   229,   216,    -6,   226,   316,    93,   138,   195,   196,   197,
   233,   198,   199,    37,   338,     1,   152,   254,   160,   205,
   165,   277,   326,    39,   277,    40,     1,    42,   282,    43,
   288,   121,   122,   123,   309,   150,   186,   205,    46,   258,
    47,   267,    87,   292,   336,   294,    50,   190,   335,   200,
   341,   206,     1,   248,   249,   124,   125,   126,   151,   345,
     1,   210,   283,    51,    52,   339,    53,    54,   313,   185,
   344,    84,     1,   313,   209,    55,    56,    57,    58,   100,
   149,   150,    51,    52,    59,    53,    54,     1,    82,    60,
    61,    62,   237,    63,    55,    56,    57,    58,    64,    65,
   103,     1,     1,    59,   151,   101,   102,   300,    60,    61,
    62,     1,    63,    83,   149,   150,   104,    64,    65,   105,
   156,   107,    66,   108,   236,   260,    67,    68,   189,    69,
    70,     1,   110,   259,   121,   122,   123,   263,   151,    64,
   150,    66,   121,   122,   123,    67,    68,     1,    69,    70,
   162,   163,   119,   270,   114,   111,   113,   278,   124,   125,
   126,   115,   129,   151,   118,   164,   124,   125,   126,   262,
     1,   130,   272,     1,    12,    13,    14,    15,    16,    17,
    18,    19,   133,   150,   307,   136,   301,   139,   169,   140,
   141,    93,   269,   162,   163,   330,   195,   196,   197,   145,
   198,   199,    92,    20,   175,    44,   151,   148,   164,   174,
   177,   180,   179,   213,   187,   214,   251,   188,   325,   215,
   218,   138,   212,   223,   221,   222,   224,   228,   225,  -105,
   231,   234,   235,   331,   240,   242,   244,   297,   245,   246,
   247,   304,   250,   306,   253,   256,   340,   311,   266,   273,
   317,   290,   319,   293,   296,   305,   282,   308,   323,   315,
   314,   318,   320,   329,   347,   321,   348,   322,   333,    45,
   334,    30,   337,   343,   120,   241,   220,   268,   192,   109,
   183,   230,   295,    49,   289,   310,   252,   132,     0,   328,
     0,     0,     0,     0,   170,     0,     0,   135,     0,     0,
   144,   143,     0,     0,     0,   147,   146
};

static const short yycheck[] = {     6,
    13,    14,   127,    16,   207,    70,    19,     1,     9,    10,
   105,    23,   107,   108,    15,   103,     9,    10,   108,    10,
    73,     1,    21,     1,    31,     3,    13,     3,    27,    20,
    21,    23,    33,    23,     1,    51,    52,    26,     1,    23,
    33,    21,    33,    50,    35,    57,    23,    27,    26,    43,
    44,    45,    46,    47,    48,    49,    50,    20,    21,   124,
    20,    21,    74,    73,    42,   153,    29,    57,    23,    29,
    23,   166,    23,    74,    23,   170,   166,    23,    72,    86,
   170,    74,    60,    74,    74,    65,    73,    54,    55,    56,
    74,    58,    59,    23,    23,     1,   103,    74,   105,    23,
   107,    64,   305,    24,    64,    24,     1,    23,    23,    74,
   246,    36,    37,    38,    74,    10,   241,    23,    23,    74,
    60,    74,    53,    74,   327,    74,    73,   134,    74,   136,
   333,   138,     1,   198,   199,    60,    61,    62,    33,   342,
     1,   148,    57,     4,     5,    74,     7,     8,   284,    74,
    74,    73,     1,   289,    23,    16,    17,    18,    19,     6,
     9,    10,     4,     5,    25,     7,     8,     1,    75,    30,
    31,    32,   179,    34,    16,    17,    18,    19,    39,    40,
    73,     1,     1,    25,    33,    11,    12,    21,    30,    31,
    32,     1,    34,    75,     9,    10,    73,    39,    40,    73,
    15,    73,    63,    73,    23,   212,    67,    68,    28,    70,
    71,     1,    23,    23,    36,    37,    38,   224,    33,    39,
    10,    63,    36,    37,    38,    67,    68,     1,    70,    71,
    20,    21,    74,   240,    73,    23,    23,   244,    60,    61,
    62,    73,    24,    33,    74,    35,    60,    61,    62,    23,
     1,    24,    74,     1,    43,    44,    45,    46,    47,    48,
    49,    50,    23,    10,   277,    73,   273,    23,    15,    74,
    74,    65,    23,    20,    21,    23,    54,    55,    56,    21,
    58,    59,    27,    72,    23,    74,    33,    73,    35,    73,
    69,    23,    73,    23,    74,    23,    74,    74,   305,    74,
    23,    73,    73,    23,    74,    74,    73,    23,    74,    74,
    74,    24,    74,   320,    73,    41,    73,    23,    73,    73,
    73,    23,    74,    23,    74,    74,   333,    23,    74,    73,
    22,    74,    23,    74,    74,    73,    23,    74,    36,    74,
    76,    74,    73,    23,     0,    74,     0,    74,    73,    22,
    74,     9,    74,    74,    72,   192,   157,   238,   134,    62,
   123,   170,   264,    27,   247,   279,   201,    86,    -1,   314,
    -1,    -1,    -1,    -1,   108,    -1,    -1,    88,    -1,    -1,
    97,    96,    -1,    -1,    -1,    99,    98
};
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/usr/lib/bison.simple"
/* This file comes from bison-1.28.  */

/* Skeleton output parser for bison,
   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* As a special exception, when this file is copied by Bison into a
   Bison output file, you may use that output file without restriction.
   This special exception was added by the Free Software Foundation
   in version 1.24 of Bison.  */

/* This is the parser code that is written into each bison parser
  when the %semantic_parser declaration is not specified in the grammar.
  It was written by Richard Stallman by simplifying the hairy parser
  used when %semantic_parser is specified.  */

#ifndef YYSTACK_USE_ALLOCA
#ifdef alloca
#define YYSTACK_USE_ALLOCA
#else /* alloca not defined */
#ifdef __GNUC__
#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#else /* not GNU C.  */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
#define YYSTACK_USE_ALLOCA
#include <alloca.h>
#else /* not sparc */
/* We think this test detects Watcom and Microsoft C.  */
/* This used to test MSDOS, but that is a bad idea
   since that symbol is in the user namespace.  */
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
#if 0 /* No need for malloc.h, which pollutes the namespace;
	 instead, just don't use alloca.  */
#include <malloc.h>
#endif
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
/* I don't know what this was needed for, but it pollutes the namespace.
   So I turned it off.   rms, 2 May 1997.  */
/* #include <malloc.h>  */
 #pragma alloca
#define YYSTACK_USE_ALLOCA
#else /* not MSDOS, or __TURBOC__, or _AIX */
#if 0
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
		 and on HPUX 10.  Eventually we can turn this on.  */
#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#endif /* __hpux */
#endif
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc */
#endif /* not GNU C */
#endif /* alloca not defined */
#endif /* YYSTACK_USE_ALLOCA not defined */

#ifdef YYSTACK_USE_ALLOCA
#define YYSTACK_ALLOC alloca
#else
#define YYSTACK_ALLOC malloc
#endif

/* Note: there must be only one dollar sign in this file.
   It is replaced by the list of actions, each action
   as one case of the switch.  */

#define yyerrok		(yyerrstatus = 0)
#define yyclearin	(yychar = YYEMPTY)
#define YYEMPTY		-2
#define YYEOF		0
#define YYACCEPT	goto yyacceptlab
#define YYABORT 	goto yyabortlab
#define YYERROR		goto yyerrlab1
/* Like YYERROR except do call yyerror.
   This remains here temporarily to ease the
   transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define YYFAIL		goto yyerrlab
#define YYRECOVERING()  (!!yyerrstatus)
#define YYBACKUP(token, value) \
do								\
  if (yychar == YYEMPTY && yylen == 1)				\
    { yychar = (token), yylval = (value);			\
      yychar1 = YYTRANSLATE (yychar);				\
      YYPOPSTACK;						\
      goto yybackup;						\
    }								\
  else								\
    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
while (0)

#define YYTERROR	1
#define YYERRCODE	256

#ifndef YYPURE
#define YYLEX		yylex()
#endif

#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX		yylex(&yylval, &yylloc)
#endif
#else /* not YYLSP_NEEDED */
#ifdef YYLEX_PARAM
#define YYLEX		yylex(&yylval, YYLEX_PARAM)
#else
#define YYLEX		yylex(&yylval)
#endif
#endif /* not YYLSP_NEEDED */
#endif

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int	yychar;			/*  the lookahead symbol		*/
YYSTYPE	yylval;			/*  the semantic value of the		*/
				/*  lookahead symbol			*/

#ifdef YYLSP_NEEDED
YYLTYPE yylloc;			/*  location data for the lookahead	*/
				/*  symbol				*/
#endif

int yynerrs;			/*  number of parse errors so far       */
#endif  /* not YYPURE */

#if YYDEBUG != 0
int yydebug;			/*  nonzero means print parse trace	*/
/* Since this is uninitialized, it does not stop multiple parsers
   from coexisting.  */
#endif

/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/

#ifndef	YYINITDEPTH
#define YYINITDEPTH 200
#endif

/*  YYMAXDEPTH is the maximum size the stacks can grow to
    (effective only if the built-in stack extension method is used).  */

#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif

/* Define __yy_memcpy.  Note that the size argument
   should be passed with type unsigned int, because that is what the non-GCC
   definitions require.  With GCC, __builtin_memcpy takes an arg
   of type size_t, but it can handle unsigned int.  */

#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
#else				/* not GNU C or C++ */
#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__yy_memcpy (to, from, count)
     char *to;
     char *from;
     unsigned int count;
{
  register char *f = from;
  register char *t = to;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__yy_memcpy (char *to, char *from, unsigned int count)
{
  register char *t = to;
  register char *f = from;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#endif
#endif

#line 217 "/usr/lib/bison.simple"

/* The user can define YYPARSE_PARAM as the name of an argument to be passed
   into yyparse.  The argument should have type void *.
   It should actually point to an object.
   Grammar actions can access the variable by casting it
   to the proper pointer type.  */

#ifdef YYPARSE_PARAM
#ifdef __cplusplus
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else /* not __cplusplus */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#endif /* not __cplusplus */
#else /* not YYPARSE_PARAM */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
#ifdef YYPARSE_PARAM
int yyparse (void *);
#else
int yyparse (void);
#endif
#endif

int
yyparse(YYPARSE_PARAM_ARG)
     YYPARSE_PARAM_DECL
{
  register int yystate;
  register int yyn;
  register short *yyssp;
  register YYSTYPE *yyvsp;
  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */

  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/

  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED
  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
  YYLTYPE *yyls = yylsa;
  YYLTYPE *yylsp;

#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK   (yyvsp--, yyssp--)
#endif

  int yystacksize = YYINITDEPTH;
  int yyfree_stacks = 0;

#ifdef YYPURE
  int yychar;
  YYSTYPE yylval;
  int yynerrs;
#ifdef YYLSP_NEEDED
  YYLTYPE yylloc;
#endif
#endif

  YYSTYPE yyval;		/*  the variable used to return		*/
				/*  semantic values from the action	*/
				/*  routines				*/

  int yylen;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Starting parse\n");
#endif

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss - 1;
  yyvsp = yyvs;
#ifdef YYLSP_NEEDED
  yylsp = yyls;
#endif

/* Push a new state, which is found in  yystate  .  */
/* In all cases, when you get here, the value and location stacks
   have just been pushed. so pushing a state here evens the stacks.  */
yynewstate:

  *++yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* Give user a chance to reallocate the stack */
      /* Use copies of these so that the &'s don't force the real ones into memory. */
      YYSTYPE *yyvs1 = yyvs;
      short *yyss1 = yyss;
#ifdef YYLSP_NEEDED
      YYLTYPE *yyls1 = yyls;
#endif

      /* Get the current used size of the three stacks, in elements.  */
      int size = yyssp - yyss + 1;

#ifdef yyoverflow
      /* Each stack pointer address is followed by the size of
	 the data in use in that stack, in bytes.  */
#ifdef YYLSP_NEEDED
      /* This used to be a conditional around just the two extra args,
	 but that might be undefined if yyoverflow is a macro.  */
      yyoverflow("parser stack overflow",
		 &yyss1, size * sizeof (*yyssp),
		 &yyvs1, size * sizeof (*yyvsp),
		 &yyls1, size * sizeof (*yylsp),
		 &yystacksize);
#else
      yyoverflow("parser stack overflow",
		 &yyss1, size * sizeof (*yyssp),
		 &yyvs1, size * sizeof (*yyvsp),
		 &yystacksize);
#endif

      yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
      yyls = yyls1;
#endif
#else /* no yyoverflow */
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
	{
	  yyerror("parser stack overflow");
	  if (yyfree_stacks)
	    {
	      free (yyss);
	      free (yyvs);
#ifdef YYLSP_NEEDED
	      free (yyls);
#endif
	    }
	  return 2;
	}
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
	yystacksize = YYMAXDEPTH;
#ifndef YYSTACK_USE_ALLOCA
      yyfree_stacks = 1;
#endif
      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
      __yy_memcpy ((char *)yyss, (char *)yyss1,
		   size * (unsigned int) sizeof (*yyssp));
      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
		   size * (unsigned int) sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
      __yy_memcpy ((char *)yyls, (char *)yyls1,
		   size * (unsigned int) sizeof (*yylsp));
#endif
#endif /* no yyoverflow */

      yyssp = yyss + size - 1;
      yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
      yylsp = yyls + size - 1;
#endif

#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif

      if (yyssp >= yyss + yystacksize - 1)
	YYABORT;
    }

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Entering state %d\n", yystate);
#endif

  goto yybackup;
 yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* yychar is either YYEMPTY or YYEOF
     or a valid token in external form.  */

  if (yychar == YYEMPTY)
    {
#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Reading a token: ");
#endif
      yychar = YYLEX;
    }

  /* Convert token to internal form (in yychar1) for indexing tables with */

  if (yychar <= 0)		/* This means end of input. */
    {
      yychar1 = 0;
      yychar = YYEOF;		/* Don't call YYLEX any more */

#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0
      if (yydebug)
	{
	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
	  /* Give the individual parser a way to print the precise meaning
	     of a token, for further debugging info.  */
#ifdef YYPRINT
	  YYPRINT (stderr, yychar, yylval);
#endif
	  fprintf (stderr, ")\n");
	}
#endif
    }

  yyn += yychar1;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
    goto yydefault;

  yyn = yytable[yyn];

  /* yyn is what to do for this token type in this state.
     Negative => reduce, -yyn is rule number.
     Positive => shift, yyn is new state.
       New state is final state => don't bother to shift,
       just return success.
     0, or most negative number => error.  */

  if (yyn < 0)
    {
      if (yyn == YYFLAG)
	goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrlab;

  if (yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  *++yyvsp = yylval;
#ifdef YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  /* count tokens shifted since error; after three, turn off error status.  */
  if (yyerrstatus) yyerrstatus--;

  yystate = yyn;
  goto yynewstate;

/* Do the default action for the current state.  */
yydefault:

  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;

/* Do a reduction.  yyn is the number of a rule to reduce with.  */
yyreduce:
  yylen = yyr2[yyn];
  if (yylen > 0)
    yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
  if (yydebug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
	       yyn, yyrline[yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    }
#endif


  switch (yyn) {

case 6:
#line 71 "./fconfig.y"
{
		    fconferror ("Missing/bad database info section");
		;
    break;}
case 7:
#line 76 "./fconfig.y"
{ badFile = 1; ;
    break;}
case 10:
#line 82 "./fconfig.y"
{ 
		    setDebugMode (databaseBeingDefined, yyvsp[0].intval);
		;
    break;}
case 11:
#line 85 "./fconfig.y"
{
		    setKeepReceivedHeaders (databaseBeingDefined, yyvsp[0].intval);
		;
    break;}
case 12:
#line 88 "./fconfig.y"
{
		    setNotifyExpire (databaseBeingDefined, yyvsp[0].intval);
		;
    break;}
case 13:
#line 91 "./fconfig.y"
{
		    setBinDir (databaseBeingDefined, qStrVal (yyvsp[0].qstr)); 
		;
    break;}
case 14:
#line 94 "./fconfig.y"
{
		    setSubmitterAck (databaseBeingDefined, yyvsp[0].intval); 
		;
    break;}
case 15:
#line 97 "./fconfig.y"
{
		  setBusinessDay (databaseBeingDefined, yyvsp[-2].intval, yyvsp[0].intval);
		;
    break;}
case 16:
#line 100 "./fconfig.y"
{
		    setBusinessWeek(databaseBeingDefined,yyvsp[-2].intval, yyvsp[0].intval);
		;
    break;}
case 17:
#line 103 "./fconfig.y"
{
		    setCreateCategoryDirs (databaseBeingDefined, yyvsp[0].intval);
		;
    break;}
case 18:
#line 106 "./fconfig.y"
{
		    setCategoryDirPerms (databaseBeingDefined, qStrVal (yyvsp[0].qstr));
		;
    break;}
case 19:
#line 111 "./fconfig.y"
{ yyval.intval = 0; ;
    break;}
case 20:
#line 112 "./fconfig.y"
{ yyval.intval = 1; ;
    break;}
case 22:
#line 116 "./fconfig.y"
{
		    fconferror ("Missing/bad field declarations");
		;
    break;}
case 25:
#line 125 "./fconfig.y"
{
		    currField = NULL;
		;
    break;}
case 26:
#line 128 "./fconfig.y"
{
		    currField = NULL;
		;
    break;}
case 27:
#line 133 "./fconfig.y"
{
		    char *fname = takeQString (yyvsp[0].qstr);
		    currField = newFieldDef (databaseBeingDefined, fname);
		    if (currField == NULL)
		      {
			char *msg;
			asprintf (&msg, "Duplicate field definition for %s\n",
				  fname);
			fconferror (msg);
			free (msg);
		      }
		    currField->default_value = NULL;
		;
    break;}
case 34:
#line 158 "./fconfig.y"
{
		    currField->virtualFormat = qformat;
		    qformat = NULL;
		;
    break;}
case 37:
#line 166 "./fconfig.y"
{
		    currField->datatype = MultiText;
		    currField->defaultSearchType = NilSearch;
		;
    break;}
case 38:
#line 170 "./fconfig.y"
{
		  currField->datatype = Date;
		  currField->defaultSearchType = LessThan;
		;
    break;}
case 39:
#line 174 "./fconfig.y"
{
		    currField->datatype = Integer;
		    currField->defaultSearchType = NilSearch;
		;
    break;}
case 40:
#line 178 "./fconfig.y"
{
		    currField->datatype = PRListType;
		    currField->defaultSearchType = RegCmp;
		;
    break;}
case 41:
#line 184 "./fconfig.y"
{
		    currField->datatype = Text;
		;
    break;}
case 42:
#line 187 "./fconfig.y"
{
		    currField->datatype = TextWithRegex;
		;
    break;}
case 44:
#line 193 "./fconfig.y"
{
		    yyval.stringlist = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    currField->regex = yyval.stringlist;
		;
    break;}
case 45:
#line 197 "./fconfig.y"
{
		    yyvsp[-1].stringlist->next = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    yyval.stringlist = yyvsp[-1].stringlist->next;
		;
    break;}
case 46:
#line 203 "./fconfig.y"
{
		    currField->datatype = Enum;
		    currField->defaultSearchType = RegCmp;
		;
    break;}
case 47:
#line 207 "./fconfig.y"
{
		    currField->datatype = Enum;
		    currField->defaultSearchType = RegCmp;
		    initAdmField (currField);
		;
    break;}
case 48:
#line 212 "./fconfig.y"
{
		    currField->datatype = MultiEnum;
		    currField->defaultSearchType = RegCmp;
		    initAdmField (currField);
		;
    break;}
case 49:
#line 217 "./fconfig.y"
{
		   currField->datatype = MultiEnum;
		   currField->defaultSearchType = RegCmp;
		   if (currField->multiEnumSeparator == NULL)
		     {
		       currField->multiEnumSeparator
			 = xstrdup (DEFAULT_MULTIENUM_SEPARATOR);
		     }
		;
    break;}
case 54:
#line 234 "./fconfig.y"
{
		    addGlobalChangeActions (databaseBeingDefined, currChange);
		    currChange = NULL;
		;
    break;}
case 55:
#line 240 "./fconfig.y"
{
		    ChangeActions *p = &(currField->changeActions);
		    while (*p != NULL)
		      {
			p = &((*p)->next);
		      }
		    *p = currChange;
		    currChange = NULL;
		;
    break;}
case 56:
#line 251 "./fconfig.y"
{
		    currChange = newChangeAction (databaseBeingDefined, yyvsp[-1].sval);
		    if (yyvsp[-1].sval != NULL) 
		      {
			free (yyvsp[-1].sval);
		      }
		;
    break;}
case 57:
#line 260 "./fconfig.y"
{
		    yyval.sval = takeQString (yyvsp[0].qstr);
		;
    break;}
case 58:
#line 263 "./fconfig.y"
{
		    yyval.sval = NULL;
		;
    break;}
case 63:
#line 274 "./fconfig.y"
{
		    currChange->edits = currEdit;
		    currEdit = NULL;
		;
    break;}
case 64:
#line 278 "./fconfig.y"
{
		    currEdit->append = 1;
		    currChange->edits = currEdit;
		    currEdit = NULL;
		;
    break;}
case 65:
#line 283 "./fconfig.y"
{
		    currChange->addAuditTrail = 1;
		;
    break;}
case 66:
#line 286 "./fconfig.y"
{
		    currChange->auditTrailFormat = qformat;
		    qformat = NULL;
		;
    break;}
case 67:
#line 290 "./fconfig.y"
{
		    currChange->requireChangeReason = 1;
		;
    break;}
case 70:
#line 299 "./fconfig.y"
{
		    FieldList foo 
		      = newFieldListEnt (databaseBeingDefined, qStrVal (yyvsp[0].qstr),
					 currChange->requiredFields);
		    currChange->requiredFields = foo;
		;
    break;}
case 73:
#line 311 "./fconfig.y"
{
		    currEdit = (FieldEdit *) xmalloc (sizeof (FieldEdit));
		    currEdit->expr = NULL;
		    currEdit->fieldToEditName = takeQString (yyvsp[0].qstr);
		    currEdit->append = 0;
		    currEdit->textFormat = NULL;
		    currEdit->fieldsForFormat = NULL;
		    currEdit->next = NULL;
		;
    break;}
case 74:
#line 322 "./fconfig.y"
{
		    currEdit->textFormat = takeQString (yyvsp[0].qstr);
		;
    break;}
case 75:
#line 327 "./fconfig.y"
{
		    currEdit->fieldsForFormat = NULL;
		;
    break;}
case 76:
#line 330 "./fconfig.y"
{
		;
    break;}
case 77:
#line 334 "./fconfig.y"
{
		    yyval.flist = newFieldListEnt (databaseBeingDefined, qStrVal (yyvsp[0].qstr),
					  NULL);
		    currEdit->fieldsForFormat = yyval.flist;
		;
    break;}
case 78:
#line 339 "./fconfig.y"
{
		    yyval.flist = newFieldListEnt (databaseBeingDefined, qStrVal (yyvsp[0].qstr),
					  NULL);
		    yyvsp[-1].flist->next = yyval.flist;
		;
    break;}
case 84:
#line 355 "./fconfig.y"
{
		    currField->maxPrsPerLine = yyvsp[0].intval;
		;
    break;}
case 90:
#line 368 "./fconfig.y"
{
		   currField->multiEnumSeparator = takeQString (yyvsp[0].qstr);
		;
    break;}
case 94:
#line 378 "./fconfig.y"
{
		    yyval.stringlist = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    currField->enumValues = yyval.stringlist;
		;
    break;}
case 95:
#line 382 "./fconfig.y"
{
		    yyvsp[-1].stringlist->next = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    yyval.stringlist = yyvsp[-1].stringlist->next;
		;
    break;}
case 98:
#line 392 "./fconfig.y"
{
		    currField->adm_db_name = takeQString (yyvsp[0].qstr);
		;
    break;}
case 99:
#line 395 "./fconfig.y"
{
		    AdmFieldDesc *p;
		    int which = 0;

		    for (p = currField->adm_field_des; p != NULL; p = p->next)
		      {
			if (strcmp (p->name, qStrVal (yyvsp[0].qstr)) == 0)
			  {
			    break;
			  }
			which++;
		      }

		    if (p != NULL)
		      {
			currField->key_field = which;
		      }
		    else
		      {
			char *msg;

			asprintf (&msg, "Invalid adm subfield %s\n",
				  qStrVal (yyvsp[0].qstr));
			fconferror (msg);
			free (msg);
		      }
		;
    break;}
case 102:
#line 424 "./fconfig.y"
{
		    currField->allow_any_value = 1;
		;
    break;}
case 106:
#line 434 "./fconfig.y"
{
		   currField->multiEnumSeparator = takeQString (yyvsp[0].qstr);
		;
    break;}
case 107:
#line 439 "./fconfig.y"
{
		    currField->default_value = takeQString (yyvsp[0].qstr);
		;
    break;}
case 108:
#line 442 "./fconfig.y"
{
		    currField->input_default_value = takeQString (yyvsp[0].qstr);
		;
    break;}
case 109:
#line 447 "./fconfig.y"
{
		    currField->adm_db_fields = 1;
		    currField->adm_field_des = yyvsp[0].adm_field_des;
		    yyval.adm_field_des = yyvsp[0].adm_field_des;
		;
    break;}
case 110:
#line 452 "./fconfig.y"
{
		    yyvsp[-1].adm_field_des->next = yyvsp[0].adm_field_des;
		    yyval.adm_field_des = yyvsp[0].adm_field_des;
		    currField->adm_db_fields++;
		;
    break;}
case 111:
#line 459 "./fconfig.y"
{
		    yyval.adm_field_des = (AdmFieldDesc *) 
		      xmalloc (sizeof (AdmFieldDesc));
		    yyval.adm_field_des->name = takeQString (yyvsp[0].qstr);
		    yyval.adm_field_des->next = NULL;
		;
    break;}
case 112:
#line 467 "./fconfig.y"
{
		    currField->defaultSearchType = RegCmp;
		;
    break;}
case 113:
#line 470 "./fconfig.y"
{
		    currField->defaultSearchType = RegFind;
		;
    break;}
case 114:
#line 475 "./fconfig.y"
{
		    currField->textsearch = 1;
		;
    break;}
case 115:
#line 478 "./fconfig.y"
{
		    currField->restricted = 1;
		;
    break;}
case 116:
#line 481 "./fconfig.y"
{
		     currField->nospaces = 1;
		;
    break;}
case 117:
#line 484 "./fconfig.y"
{
		    if (setBuiltinField (currField, qStrVal (yyvsp[0].qstr)) != 0)
		      {
			char *msg;
			asprintf (&msg, "Invalid builtin fieldname %s",
				  qStrVal (yyvsp[0].qstr));
			fconferror (msg);
			free (msg);
		      }
		;
    break;}
case 119:
#line 495 "./fconfig.y"
{
		    currField->description = takeQString (yyvsp[0].qstr);
		;
    break;}
case 120:
#line 498 "./fconfig.y"
{
		    currField->readonly = 1;
		;
    break;}
case 121:
#line 501 "./fconfig.y"
{
		    currField->auxFlags = yyvsp[-1].stringlist;
		;
    break;}
case 122:
#line 504 "./fconfig.y"
{
		    currField->editonly = 1;
		;
    break;}
case 123:
#line 509 "./fconfig.y"
{
		    yyval.stringlist = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    currField->auxFlags = yyval.stringlist;
		;
    break;}
case 124:
#line 513 "./fconfig.y"
{
		    yyvsp[-1].stringlist->next = new_string_list_ent (takeQString (yyvsp[0].qstr), NULL);
		    yyval.stringlist = yyvsp[-1].stringlist->next;
		;
    break;}
case 129:
#line 527 "./fconfig.y"
{
		    addQueryFormat (databaseBeingDefined, qformat);
		    qformat = NULL;
		;
    break;}
case 130:
#line 531 "./fconfig.y"
{
		    freeQueryFormat (qformat);
		    qformat = NULL;
		;
    break;}
case 131:
#line 537 "./fconfig.y"
{
		    qformat = (QueryFormat *) xmalloc (sizeof (QueryFormat));
		    qformat->name = takeQString (yyvsp[0].qstr);
		    qformat->printf = NULL;
		    qformat->separator = NULL;
		    qformat->fields = NULL;
		    qformat->next = NULL;
		;
    break;}
case 140:
#line 561 "./fconfig.y"
{
		    qformat->rawQuery = 1;
		;
    break;}
case 141:
#line 566 "./fconfig.y"
{
		    qformat->printf = takeQString (yyvsp[0].qstr);
		;
    break;}
case 144:
#line 575 "./fconfig.y"
{
		    qformat->fields = yyvsp[0].flist;
		;
    break;}
case 145:
#line 578 "./fconfig.y"
{
		    yyvsp[-1].flist->next = yyvsp[0].flist;
		    yyval.flist = yyvsp[0].flist;
		;
    break;}
case 146:
#line 584 "./fconfig.y"
{
		    yyval.flist = newFieldListEnt (databaseBeingDefined, qStrVal (yyvsp[0].qstr),
					  NULL);
		    if (parseComplexFieldIndex (yyval.flist->ent) != 0)
		      {
			char *msg;

			asprintf (&msg, "Field %s is invalid\n", qStrVal (yyvsp[0].qstr));
			fconferror (msg);
			free (msg);
		      }
		;
    break;}
case 147:
#line 598 "./fconfig.y"
{
		    setIndexDesc (databaseBeingDefined, indexEntry);
		    indexEntry = NULL;
		;
    break;}
case 148:
#line 602 "./fconfig.y"
{
		    freeIndexDesc (indexEntry);
		    indexEntry = NULL;
		;
    break;}
case 150:
#line 609 "./fconfig.y"
{
		    indexEntry = newIndexDesc (databaseBeingDefined);
		;
    break;}
case 153:
#line 618 "./fconfig.y"
{
		    setIndexDescPath (indexEntry, qStrVal (yyvsp[0].qstr));
		;
    break;}
case 157:
#line 626 "./fconfig.y"
{
		    addFieldToIndex (indexEntry, yyvsp[0].flist);
		;
    break;}
case 158:
#line 629 "./fconfig.y"
{
		    addFieldToIndex (indexEntry, yyvsp[0].flist);
		;
    break;}
case 159:
#line 634 "./fconfig.y"
{
		    setIndexDescSeparator (indexEntry, takeQString (yyvsp[0].qstr));
		;
    break;}
case 160:
#line 637 "./fconfig.y"
{
		    setIndexDescBinary (indexEntry, yyvsp[0].intval);
		;
    break;}
case 163:
#line 645 "./fconfig.y"
{
		    setInputTemplate (databaseBeingDefined, yyvsp[-1].inputlist);
		;
    break;}
case 165:
#line 651 "./fconfig.y"
{
		    setRequiredInputFields (databaseBeingDefined, requiredFlds);
                ;
    break;}
case 166:
#line 654 "./fconfig.y"
{
                    freeFieldList (requiredFlds);
                    requiredFlds = NULL;
                ;
    break;}
case 167:
#line 660 "./fconfig.y"
{
		    requiredFlds = yyvsp[0].flist;
                ;
    break;}
case 168:
#line 663 "./fconfig.y"
{
                    yyvsp[-1].flist->next = yyvsp[0].flist;
                    yyval.flist = yyvsp[0].flist;
                ;
    break;}
case 169:
#line 669 "./fconfig.y"
{
		    yyval.inputlist = inputTemplate;
		    inputTemplate = NULL;
		;
    break;}
case 170:
#line 673 "./fconfig.y"
{
		    yyval.inputlist = NULL;
		;
    break;}
case 171:
#line 678 "./fconfig.y"
{
		     yyval.inputlist = (InputTemplate *) 
		       xmalloc (sizeof (InputTemplate));
		     yyval.inputlist->index = find_field_index (databaseBeingDefined,
						   qStrVal (yyvsp[0].qstr));
		     if (yyval.inputlist->index == InvalidFieldIndex)
		       {
			 char *msg;

			 asprintf (&msg, "Field %s is invalid\n",
				   qStrVal (yyvsp[0].qstr));
			 fconferror (msg);
			 free (yyval.inputlist);
			 free (msg);
			 inputTemplate = NULL;
		       }
		     else
		       {
			 inputTemplate = yyval.inputlist;
			 yyval.inputlist->next = NULL;
		       }
		;
    break;}
case 172:
#line 700 "./fconfig.y"
{
		     yyval.inputlist = (InputTemplate *)
		       xmalloc (sizeof (InputTemplate));
		     yyval.inputlist->index = find_field_index (databaseBeingDefined,
						   qStrVal (yyvsp[0].qstr));
		     if (yyval.inputlist->index == InvalidFieldIndex)
		       {
			 char *msg;

			 asprintf (&msg, "Field %s is invalid\n",
				   qStrVal (yyvsp[0].qstr));
			 fconferror (msg);
			 free (msg);
			 free (yyval.inputlist);
		       }
		     else
		       {
			 yyval.inputlist->next = NULL;
			 yyvsp[-1].inputlist->next = yyval.inputlist;
			 if (inputTemplate == NULL)
			   {
			     inputTemplate = yyval.inputlist;
			   }
		       }
		;
    break;}
case 175:
#line 731 "./fconfig.y"
{
		    addMessageFormat (databaseBeingDefined, mailFormat);
		    mailFormat = NULL;
		;
    break;}
case 176:
#line 735 "./fconfig.y"
{
		    freeMessageFormat (mailFormat);
		    mailFormat = NULL;
		;
    break;}
case 177:
#line 741 "./fconfig.y"
{
  		    mailFormat 
		      = (MailMessageFormat)
		      xmalloc (sizeof (struct mail_message_format));
		    mailFormat->name = takeQString (yyvsp[0].qstr);
		    mailFormat->toAddresses = NULL;
		    mailFormat->fromAddress = NULL;
		    mailFormat->replyTo = NULL;
		    mailFormat->body = NULL;
		    mailFormat->header = NULL;
		    mailFormat->next = NULL;
		;
    break;}
case 180:
#line 759 "./fconfig.y"
{
		    mailFormat->body = qformat;
		    qformat = NULL;
		;
    break;}
case 181:
#line 763 "./fconfig.y"
{
		    mailFormat->header = qformat;
		    qformat = NULL;
		;
    break;}
case 182:
#line 767 "./fconfig.y"
{
		    mailFormat->toAddresses = yyvsp[-1].mailaddrlist;
		;
    break;}
case 183:
#line 770 "./fconfig.y"
{
		    mailFormat->fromAddress = yyvsp[-1].mailaddr;
		;
    break;}
case 184:
#line 773 "./fconfig.y"
{
		  mailFormat->replyTo = yyvsp[-1].mailaddrlist;
		;
    break;}
case 188:
#line 785 "./fconfig.y"
{
		    freeQueryFormat (qformat);
		    qformat = NULL;
		;
    break;}
case 189:
#line 791 "./fconfig.y"
{
		    qformat = (QueryFormat *) xmalloc (sizeof (QueryFormat));
		    qformat->name = NULL;
		    qformat->printf = NULL;
		    qformat->separator = NULL;
		    qformat->fields = NULL;
		    qformat->next = NULL;
		;
    break;}
case 190:
#line 801 "./fconfig.y"
{
		   yyval.mailaddrlist = (MailAddressList *) xmalloc (sizeof (MailAddressList));
		   yyval.mailaddrlist->address = yyvsp[0].mailaddr;
		   yyval.mailaddrlist->next = NULL;
		;
    break;}
case 191:
#line 806 "./fconfig.y"
{
		   MailAddressList *lp = yyval.mailaddrlist;
		   while (lp->next != NULL) { lp = lp->next; }
		   lp->next =
		     (MailAddressList *) xmalloc (sizeof (MailAddressList));
		   lp->next->address = yyvsp[0].mailaddr;
		   lp->next->next = NULL;
		;
    break;}
case 192:
#line 816 "./fconfig.y"
{
		    yyval.mailaddr = (MailAddress *) xmalloc (sizeof (MailAddress));
		    yyval.mailaddr->fixedAddress = takeQString (yyvsp[0].qstr);
		    yyval.mailaddr->addresses = NULL;
		;
    break;}
case 193:
#line 821 "./fconfig.y"
{
		    yyval.mailaddr = (MailAddress *) xmalloc (sizeof (MailAddress));
		    yyval.mailaddr->fixedAddress = NULL;
		    yyval.mailaddr->addresses = yyvsp[0].flist;
		;
    break;}
case 194:
#line 828 "./fconfig.y"
{
		    yyval.flist = yyvsp[0].flist;
		;
    break;}
case 195:
#line 831 "./fconfig.y"
{
		    FieldList p = yyval.flist;
		    while (p->next != NULL) 
		      {
			p = p->next;
		      }
		    p->next = yyvsp[0].flist;
		;
    break;}
case 196:
#line 841 "./fconfig.y"
{
		    yyval.flist = newFieldListEnt (databaseBeingDefined, qStrVal (yyvsp[0].qstr),
					  NULL);
		;
    break;}
case 197:
#line 847 "./fconfig.y"
{
		    setAuditTrailFormat (databaseBeingDefined, qformat);
		;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 543 "/usr/lib/bison.simple"

  yyvsp -= yylen;
  yyssp -= yylen;
#ifdef YYLSP_NEEDED
  yylsp -= yylen;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++yyvsp = yyval;

#ifdef YYLSP_NEEDED
  yylsp++;
  if (yylen == 0)
    {
      yylsp->first_line = yylloc.first_line;
      yylsp->first_column = yylloc.first_column;
      yylsp->last_line = (yylsp-1)->last_line;
      yylsp->last_column = (yylsp-1)->last_column;
      yylsp->text = 0;
    }
  else
    {
      yylsp->last_line = (yylsp+yylen-1)->last_line;
      yylsp->last_column = (yylsp+yylen-1)->last_column;
    }
#endif

  /* Now "shift" the result of the reduction.
     Determine what state that goes to,
     based on the state we popped back to
     and the rule number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTBASE];

  goto yynewstate;

yyerrlab:   /* here on detecting error */

  if (! yyerrstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
	{
	  int size = 0;
	  char *msg;
	  int x, count;

	  count = 0;
	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
	  for (x = (yyn < 0 ? -yyn : 0);
	       x < (sizeof(yytname) / sizeof(char *)); x++)
	    if (yycheck[x + yyn] == x)
	      size += strlen(yytname[x]) + 15, count++;
	  msg = (char *) malloc(size + 15);
	  if (msg != 0)
	    {
	      strcpy(msg, "parse error");

	      if (count < 5)
		{
		  count = 0;
		  for (x = (yyn < 0 ? -yyn : 0);
		       x < (sizeof(yytname) / sizeof(char *)); x++)
		    if (yycheck[x + yyn] == x)
		      {
			strcat(msg, count == 0 ? ", expecting `" : " or `");
			strcat(msg, yytname[x]);
			strcat(msg, "'");
			count++;
		      }
		}
	      yyerror(msg);
	      free(msg);
	    }
	  else
	    yyerror ("parse error; also virtual memory exceeded");
	}
      else
#endif /* YYERROR_VERBOSE */
	yyerror("parse error");
    }

  goto yyerrlab1;
yyerrlab1:   /* here on error raised explicitly by an action */

  if (yyerrstatus == 3)
    {
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */

      /* return failure if at end of input */
      if (yychar == YYEOF)
	YYABORT;

#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

      yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token
     after shifting the error token.  */

  yyerrstatus = 3;		/* Each real token shifted decrements this */

  goto yyerrhandle;

yyerrdefault:  /* current state does not do anything special for the error token. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (yyn) goto yydefault;
#endif

yyerrpop:   /* pop the current state because it cannot handle the error token */

  if (yyssp == yyss) YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#ifdef YYLSP_NEEDED
  yylsp--;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

yyerrhandle:

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yyerrdefault;

  yyn += YYTERROR;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    goto yyerrdefault;

  yyn = yytable[yyn];
  if (yyn < 0)
    {
      if (yyn == YYFLAG)
	goto yyerrpop;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrpop;

  if (yyn == YYFINAL)
    YYACCEPT;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

  *++yyvsp = yylval;
#ifdef YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  yystate = yyn;
  goto yynewstate;

 yyacceptlab:
  /* YYACCEPT comes here.  */
  if (yyfree_stacks)
    {
      free (yyss);
      free (yyvs);
#ifdef YYLSP_NEEDED
      free (yyls);
#endif
    }
  return 0;

 yyabortlab:
  /* YYABORT comes here.  */
  if (yyfree_stacks)
    {
      free (yyss);
      free (yyvs);
#ifdef YYLSP_NEEDED
      free (yyls);
#endif
    }
  return 1;
}
#line 851 "./fconfig.y"
