crossroads

parser.c (69841B)

---

 /*************************************************************************
  * This file is part of Crosroads 1.23, a load balancer and fail over
  * utility for TCP. Copyright (c) Karel Kubat, distributed under GPL.
  * Visit http://crossroads.e-tunity.com for information.
  *************************************************************************/
 /* A Bison parser, made from parser.y
    by GNU bison 1.35.  */
 
 #define YYBISON 1  /* Identify Bison output.  */
 
 # define	SERVICE	257
 # define	IDENTIFIER	258
 # define	PORT	259
 # define	NUMBER	260
 # define	BACKEND	261
 # define	VERBOSITY	262
 # define	SERVER	263
 # define	ON	264
 # define	OFF	265
 # define	DISPATCHMODE	266
 # define	ROUNDROBIN	267
 # define	REVIVINGINTERVAL	268
 # define	SHMKEY	269
 # define	WEIGHT	270
 # define	ONSTART	271
 # define	ONFAIL	272
 # define	STRING	273
 # define	BACKLOG	274
 # define	RANDOM	275
 # define	BYDURATION	276
 # define	BYSIZE	277
 # define	BYCONNECTIONS	278
 # define	CONNECTIONTIMEOUT	279
 # define	MAXCONNECTIONS	280
 # define	BYORDER	281
 # define	TRAFFICLOG	282
 # define	OVER	283
 # define	DECAY	284
 # define	BINDTO	285
 # define	THROUGHPUTLOG	286
 # define	TYPE	287
 # define	ANY	288
 # define	HTTP	289
 # define	STICKYCOOKIE	290
 # define	ADDCLIENTHEADER	291
 # define	SETCLIENTHEADER	292
 # define	APPENDCLIENTHEADER	293
 # define	ADDSERVERHEADER	294
 # define	SETSERVERHEADER	295
 # define	APPENDSERVERHEADER	296
 # define	ALLOWFROM	297
 # define	DENYFROM	298
 # define	ALLOWFILE	299
 # define	DENYFILE	300
 # define	EXTERNALHANDLER	301
 # define	ONEND	302
 # define	USERACCOUNT	303
 
 #line 3 "parser.y"
 
 /* Prologue */
 #include "crossroads.h"
 
 #define YYSTYPE Confsets
 
 /* Static parser vars */
 static int i;				/* Loop counter */
 static Backend cur_backend;		/* Storage for a handled backend */
 static Service cur_service;		/* Storage for a handled service */
 
 /* Parser debugging related */
 // #define PARSER_DEBUG
 #ifdef PARSER_DEBUG
     static void pmsg (char const *x) {
 	printf ("P: %s\n", x);
     }
     static void psmsg (char const *x, char const *y) {
 	printf ("P: %s %s\n", x, y);
     }
     static void pimsg(char const *x, int y) {
 	printf ("P: %s %d\n", x, y);
     }
 #else
 #   define pmsg(x)
 #   define psmsg(x,y)
 #   define pimsg(x,y)
 #endif
 
 /* Error handler for yyparse() */
 static int yyerror (char *msg) {
     error ("Parse error at line %d, '%s': %s",
 	   yylineno + 1, yytext, yyerrmsg);
 }
 
 /* Store an encountered string */
 static char *laststr;
 static void setlaststr (char const *what) {
     free (laststr);
     laststr = xstrdup (what);
 }
 
 /* Store an encountered number */
 static int lastnr;
 static void setlastnr (char const *what) {
     lastnr = atoi (what);
 }
 
 /* Store an encountered 'over' number */
 static int lastovernr;
 static void setlastovernr (char const *what) {
     lastovernr = atoi(what);
 }
 
 /* Store an encountered 'externalhandler' */
 static char *lastext;
 static void setlastext (char const *what) {
     free (lastext);
     lastext = xstrdup (what);
 }
 
 /* Get the server part from HOSTNAME:PORT in allocated memory */
 static char *serverpart (char const *what) {
     char *ret = xstrdup (what);
     char *cp;
 
     if ( (cp = strchr (ret, ':')) )
 	*cp = 0;
     return (ret);
 }
 
 /* Get the port part from HOSTNAME:PORT */
 static int portpart (char const *what) {
     char *cp;
 
     if ( (cp = strchr (what, ':')) )
 	return (atoi (cp + 1));
     return (0);
 }
 
 /* Add a list of IP filters to the allowlist or the denylist */
 static void add_any (char *what, int chain) {
     char *item;
     int result;
     for (item = strtok (what, " "); item; item = strtok (0, " ")) {
 	if (chain)
 	    result = ipf_add_allow (&cur_service, item);
 	else
 	    result = ipf_add_deny  (&cur_service, item);
 	if (result)
 	    error ("Bad IP filter specifier '%s' at line %d",
 		   item, yylineno + 1);
     }
 }
 static void add_allowfrom (char *what) {
     add_any (what, 1);
 }
 static void add_denyfrom (char *what) {
     add_any (what, 0);
 }
 
 /* Set uid/gid for external commands. */
 static void setuseraccount (char *username) {
     struct passwd *pw;
 
     if (! (pw = getpwnam (username)) )
 	error ("Invalid username '%s' at line %d", username, yylineno + 1);
     cur_service.uid = pw->pw_uid;
     cur_service.gid = pw->pw_gid;
 }
 
 #ifndef YYSTYPE
 # define YYSTYPE int
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 #ifndef YYDEBUG
 # define YYDEBUG 0
 #endif
 
 
 
 #define	YYFINAL		197
 #define	YYFLAG		-32768
 #define	YYNTBASE	53
 
 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
 #define YYTRANSLATE(x) ((unsigned)(x) <= 303 ? yytranslate[x] : 132)
 
 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
 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,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,    52,
        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,    50,     2,    51,     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
 };
 
 #if YYDEBUG
 static const short yyprhs[] =
 {
        0,     0,     3,     5,    11,    14,    17,    20,    22,    25,
       27,    29,    31,    33,    35,    37,    39,    41,    43,    45,
       47,    49,    51,    53,    55,    57,    61,    65,    68,    71,
       74,    79,    81,    83,    88,    90,    92,    93,    96,    99,
      101,   104,   106,   108,   110,   112,   114,   116,   118,   122,
      125,   129,   133,   137,   141,   145,   149,   152,   154,   156,
      160,   164,   168,   172,   175,   181,   184,   187,   189,   192,
      194,   196,   198,   200,   202,   204,   206,   208,   210,   212,
      214,   216,   218,   220,   222,   224,   226,   228,   233,   237,
      241,   243,   247,   251,   255,   259,   263,   266,   269,   273,
      276,   280,   284,   288,   292,   296,   300,   303,   304,   305,
      306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
      316,   317,   318,   319,   320
 };
 static const short yyrhs[] =
 {
       54,    53,     0,    54,     0,    55,    56,    50,    57,    51,
        0,   118,     3,     0,   126,     4,     0,    57,    58,     0,
       58,     0,   120,    59,     0,    60,     0,    61,     0,    65,
        0,    67,     0,    76,     0,    77,     0,    78,     0,    79,
        0,    80,     0,    81,     0,    84,     0,    86,     0,    85,
        0,    87,     0,    74,     0,    89,     0,     5,    63,    64,
        0,    31,    62,    64,     0,   128,    19,     0,   116,     6,
        0,   121,    52,     0,     8,   122,    66,    64,     0,    10,
        0,    11,     0,    12,    72,    68,    64,     0,    69,     0,
       71,     0,     0,    29,    70,     0,   116,     6,     0,   103,
        0,   123,    73,     0,    13,     0,    21,     0,    22,     0,
       23,     0,    27,     0,    24,     0,    47,     0,    49,    75,
       64,     0,   131,    19,     0,    14,    63,    64,     0,    20,
       63,    64,     0,    15,    63,    64,     0,    25,    63,    64,
        0,    26,    63,    64,     0,    33,    82,    64,     0,   129,
       83,     0,    34,     0,    35,     0,    43,    88,    64,     0,
       44,    88,    64,     0,    45,   104,    64,     0,    46,   104,
       64,     0,   130,    19,     0,     7,    90,    50,    91,    51,
        0,   127,     4,     0,    91,    92,     0,    92,     0,   119,
       93,     0,    94,     0,    60,     0,    65,     0,    98,     0,
      100,     0,    99,     0,   101,     0,   102,     0,    95,     0,
       96,     0,    80,     0,   105,     0,   107,     0,   108,     0,
      109,     0,   110,     0,   111,     0,   112,     0,     9,   117,
       97,    64,     0,    16,    63,    64,     0,    30,    63,    64,
        0,    19,     0,    17,   103,    64,     0,    18,   103,    64,
        0,    48,   103,    64,     0,    28,   104,    64,     0,    32,
      104,    64,     0,   124,    19,     0,   125,    19,     0,    36,
      106,    64,     0,   115,    19,     0,    37,   113,    64,     0,
       38,   113,    64,     0,    39,   113,    64,     0,    40,   113,
       64,     0,    41,   113,    64,     0,    42,   113,    64,     0,
      114,    19,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0
 };
 
 #endif
 
 #if YYDEBUG
 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
 static const short yyrline[] =
 {
        0,   130,   133,   137,   166,   171,   179,   182,   186,   191,
      197,   203,   209,   219,   225,   231,   237,   243,   249,   255,
      261,   267,   273,   279,   286,   439,   451,   463,   472,   479,
      484,   497,   501,   507,   516,   518,   520,   524,   541,   548,
      558,   567,   571,   575,   579,   583,   587,   591,   597,   609,
      618,   630,   642,   654,   666,   678,   690,   695,   699,   705,
      717,   729,   741,   753,   762,   772,   780,   788,   794,   801,
      806,   811,   816,   821,   826,   831,   836,   841,   846,   851,
      856,   861,   866,   871,   876,   881,   886,   893,   906,   918,
      930,   936,   948,   960,   972,   984,   996,  1005,  1014,  1026,
     1035,  1047,  1059,  1071,  1083,  1095,  1107,  1116,  1121,  1126,
     1131,  1136,  1141,  1146,  1151,  1156,  1161,  1166,  1171,  1176,
     1181,  1186,  1191,  1196,  1201
 };
 #endif
 
 
 #if (YYDEBUG) || defined YYERROR_VERBOSE
 
 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
 static const char *const yytname[] =
 {
   "$", "error", "$undefined.", "SERVICE", "IDENTIFIER", "PORT", "NUMBER", 
   "BACKEND", "VERBOSITY", "SERVER", "ON", "OFF", "DISPATCHMODE", 
   "ROUNDROBIN", "REVIVINGINTERVAL", "SHMKEY", "WEIGHT", "ONSTART", 
   "ONFAIL", "STRING", "BACKLOG", "RANDOM", "BYDURATION", "BYSIZE", 
   "BYCONNECTIONS", "CONNECTIONTIMEOUT", "MAXCONNECTIONS", "BYORDER", 
   "TRAFFICLOG", "OVER", "DECAY", "BINDTO", "THROUGHPUTLOG", "TYPE", "ANY", 
   "HTTP", "STICKYCOOKIE", "ADDCLIENTHEADER", "SETCLIENTHEADER", 
   "APPENDCLIENTHEADER", "ADDSERVERHEADER", "SETSERVERHEADER", 
   "APPENDSERVERHEADER", "ALLOWFROM", "DENYFROM", "ALLOWFILE", "DENYFILE", 
   "EXTERNALHANDLER", "ONEND", "USERACCOUNT", "'{'", "'}'", "';'", "input", 
   "element", "service", "servicename", "servicestatements", 
   "servicestatement", "servicebody", "portstatement", "bindstatement", 
   "ipaddress", "number", "semicol", "verbositystatement", "onoff", 
   "dispatchmodestatement", "dispatchtail", "dispatchover", "overnumber", 
   "dispatchext", "dispatchmethod", "dispatchmethodspec", 
   "useraccountstatement", "useraccount", "revivingintervalstatement", 
   "backlogstatement", "shmkeystatement", "connectiontimeoutstatement", 
   "maxconnectionsstatement", "typestatement", "typespec", "typespecifier", 
   "allowfromstatement", "denyfromstatement", "allowfilestatement", 
   "denyfilestatement", "ipfilters", "backendblock", "backendname", 
   "backenddefinitions", "backenddefinition", "backendstatement", 
   "serverstatement", "weightstatement", "decaystatement", "serveraddress", 
   "onstartstatement", "onfailstatement", "onendstatement", 
   "dumptrafficstatement", "throughputstatement", "commandline", 
   "filename", "stickycookiestatement", "cookiespecifier", 
   "addclientheaderstatement", "setclientheaderstatement", 
   "appendclientheaderstatement", "addserverheaderstatement", 
   "setserverheaderstatement", "appendserverheaderstatement", 
   "headerstring", "headerstring_expected", "cookie_expected", 
   "number_expected", "serveraddress_expected", "service_expected", 
   "backendstatement_expected", "servicebody_expected", "semicol_expected", 
   "onoff_expected", "dispatchmethod_expected", "commandline_expected", 
   "filename_expected", "servicename_expected", "backendname_expected", 
   "ipaddress_expected", "type_expected", "ipfilters_expected", 
   "useraccount_expected", 0
 };
 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
 static const short yyr1[] =
 {
        0,    53,    53,    54,    55,    56,    57,    57,    58,    59,
       59,    59,    59,    59,    59,    59,    59,    59,    59,    59,
       59,    59,    59,    59,    59,    60,    61,    62,    63,    64,
       65,    66,    66,    67,    68,    68,    68,    69,    70,    71,
       72,    73,    73,    73,    73,    73,    73,    73,    74,    75,
       76,    77,    78,    79,    80,    81,    82,    83,    83,    84,
       85,    86,    87,    88,    89,    90,    91,    91,    92,    93,
       93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
       93,    93,    93,    93,    93,    93,    93,    94,    95,    96,
       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
      127,   128,   129,   130,   131
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
 static const short yyr2[] =
 {
        0,     2,     1,     5,     2,     2,     2,     1,     2,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     3,     3,     2,     2,     2,
        4,     1,     1,     4,     1,     1,     0,     2,     2,     1,
        2,     1,     1,     1,     1,     1,     1,     1,     3,     2,
        3,     3,     3,     3,     3,     3,     2,     1,     1,     3,
        3,     3,     3,     2,     5,     2,     2,     1,     2,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     4,     3,     3,
        1,     3,     3,     3,     3,     3,     2,     2,     3,     2,
        3,     3,     3,     3,     3,     3,     2,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0
 };
 
 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    doesn't specify something else to do.  Zero means the default is an
    error. */
 static const short yydefact[] =
 {
      111,     2,   119,     0,     1,     0,     0,     4,   113,     5,
      113,     7,     0,     3,     6,   109,   120,   115,   116,   109,
      109,   109,   109,   109,   121,   122,   123,   123,   118,   118,
      124,     8,     9,    10,    11,    12,    23,    13,    14,    15,
       16,    17,    18,    19,    21,    20,    22,    24,   114,     0,
        0,     0,     0,    36,     0,   114,   114,   114,   114,   114,
      114,     0,   114,     0,   114,     0,   114,   114,     0,   114,
      114,     0,    25,     0,    28,   112,    65,    31,    32,   114,
      109,   114,    34,    35,    39,     0,    41,    42,    43,    44,
       46,    45,    47,    40,    50,    52,    51,    53,    54,    26,
       27,    55,    57,    58,    56,    59,    63,    60,    61,    97,
       62,    48,    49,    29,   112,    67,     0,    30,    37,     0,
       33,    96,    64,    66,   110,   109,   117,   117,   118,   109,
      118,   108,   107,   107,   107,   107,   107,   107,   117,    70,
       71,    79,    68,    69,    77,    78,    72,    74,    73,    75,
       76,    80,    81,    82,    83,    84,    85,    86,    38,     0,
      114,   114,   114,   114,   114,   114,   114,     0,   114,     0,
      114,   114,   114,   114,   114,   114,    90,   114,    88,    91,
       92,    94,    89,    95,    98,    99,   100,   106,   101,   102,
      103,   104,   105,    93,    87,     0,     0,     0
 };
 
 static const short yydefgoto[] =
 {
        4,     1,     2,     5,    10,    11,    31,    32,    33,    60,
       48,    72,    34,    79,    35,    81,    82,   118,    83,    53,
       93,    36,    70,    37,    38,    39,    40,    41,    42,    62,
      104,    43,    44,    45,    46,    64,    47,    50,   114,   115,
      142,   143,   144,   145,   177,   146,   147,   148,   149,   150,
       84,    67,   151,   166,   152,   153,   154,   155,   156,   157,
      168,   169,   167,    49,   159,     3,   116,    12,    73,    52,
       54,    85,    68,     6,    51,    61,    63,    65,    71
 };
 
 static const short yypact[] =
 {
   -32768,     5,-32768,     7,-32768,   -19,    29,-32768,-32768,-32768,
      -12,-32768,    20,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    32,
       -8,    39,    12,   -13,    34,-32768,-32768,-32768,-32768,-32768,
   -32768,    25,-32768,     2,-32768,    30,-32768,-32768,    31,-32768,
   -32768,    33,-32768,    -4,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,    35,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,     8,-32768,   116,-32768,-32768,    54,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    43,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,    48,-32768,    49,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,    75,    76,-32768
 };
 
 static const short yypgoto[] =
 {
       77,-32768,-32768,-32768,-32768,    68,-32768,   -37,-32768,-32768,
       -2,   -55,   -36,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,   -34,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,    56,-32768,-32768,-32768,   -30,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
      -97,   -16,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
      -63,-32768,-32768,     6,-32768,-32768,-32768,-32768,-32768,-32768,
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768
 };
 
 
 #define	YYLAST		164
 
 
 static const short yytable[] =
 {
       94,    95,    96,    97,    98,    99,  -117,   101,  -111,   105,
        7,   107,   108,    69,   110,   111,    80,    55,    56,    57,
       58,    59,    77,    78,   117,    15,   120,    16,    17,   161,
      162,     8,    18,     9,    19,    20,   102,   103,    74,    13,
       21,   175,    75,    76,   100,    22,    23,    86,   113,   106,
      109,    24,   112,    25,   121,    87,    88,    89,    90,   122,
      158,    91,   176,    26,    27,    28,    29,   185,   187,    30,
      170,   171,   172,   173,   174,   196,   197,   195,    14,   139,
      140,    92,   141,    66,   123,     0,   119,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,   178,   179,   180,   181,   182,
      183,   184,   163,   186,   165,   188,   189,   190,   191,   192,
      193,    15,   194,   160,    17,   124,     0,   164,     0,     0,
        0,     0,   125,   126,   127,     0,     0,     0,     0,     0,
        0,     0,    23,     0,   128,     0,   129,     0,   130,     0,
        0,     0,   131,   132,   133,   134,   135,   136,   137,     0,
        0,     0,     0,     0,   138
 };
 
 static const short yycheck[] =
 {
       55,    56,    57,    58,    59,    60,    19,    62,     3,    64,
        3,    66,    67,    29,    69,    70,    29,    19,    20,    21,
       22,    23,    10,    11,    79,     5,    81,     7,     8,   126,
      127,    50,    12,     4,    14,    15,    34,    35,     6,    51,
       20,   138,    50,     4,    19,    25,    26,    13,    52,    19,
       19,    31,    19,    33,    19,    21,    22,    23,    24,    51,
        6,    27,    19,    43,    44,    45,    46,    19,    19,    49,
      133,   134,   135,   136,   137,     0,     0,     0,    10,   116,
      116,    47,   116,    27,   114,    -1,    80,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,   160,   161,   162,   163,   164,
      165,   166,   128,   168,   130,   170,   171,   172,   173,   174,
      175,     5,   177,   125,     8,     9,    -1,   129,    -1,    -1,
       -1,    -1,    16,    17,    18,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    26,    -1,    28,    -1,    30,    -1,    32,    -1,
       -1,    -1,    36,    37,    38,    39,    40,    41,    42,    -1,
       -1,    -1,    -1,    -1,    48
 };
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 #line 3 "/sw/share/bison/bison.simple"
 
 /* Skeleton output parser for bison,
 
    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 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.  */
 
 /* All symbols defined below should begin with yy or YY, to avoid
    infringing on user name space.  This should be done even for local
    variables, as they might otherwise be expanded by user macros.
    There are some unavoidable exceptions within include files to
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
 # if YYSTACK_USE_ALLOCA
 #  define YYSTACK_ALLOC alloca
 # else
 #  ifndef YYSTACK_USE_ALLOCA
 #   if defined (alloca) || defined (_ALLOCA_H)
 #    define YYSTACK_ALLOC alloca
 #   else
 #    ifdef __GNUC__
 #     define YYSTACK_ALLOC __builtin_alloca
 #    endif
 #   endif
 #  endif
 # endif
 
 # ifdef YYSTACK_ALLOC
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 # else
 #  if defined (__STDC__) || defined (__cplusplus)
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 #   define YYSIZE_T size_t
 #  endif
 #  define YYSTACK_ALLOC malloc
 #  define YYSTACK_FREE free
 # endif
 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
 	 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
   short yyss;
   YYSTYPE yyvs;
 # if YYLSP_NEEDED
   YYLTYPE yyls;
 # endif
 };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # if YYLSP_NEEDED
 #  define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))	\
       + 2 * YYSTACK_GAP_MAX)
 # else
 #  define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
       + YYSTACK_GAP_MAX)
 # endif
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 #  if 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)		\
       do					\
 	{					\
 	  register YYSIZE_T yyi;		\
 	  for (yyi = 0; yyi < (Count); yyi++)	\
 	    (To)[yyi] = (From)[yyi];		\
 	}					\
       while (0)
 #  endif
 # endif
 
 /* Relocate STACK from its old location to the new one.  The
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
 # define YYSTACK_RELOCATE(Stack)					\
     do									\
       {									\
 	YYSIZE_T yynewbytes;						\
 	YYCOPY (&yyptr->Stack, Stack, yysize);				\
 	Stack = &yyptr->Stack;						\
 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;	\
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
     while (0)
 
 #endif
 
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
 #endif
 #if ! defined (YYSIZE_T) && defined (size_t)
 # define YYSIZE_T size_t
 #endif
 #if ! defined (YYSIZE_T)
 # if defined (__STDC__) || defined (__cplusplus)
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # endif
 #endif
 #if ! defined (YYSIZE_T)
 # define YYSIZE_T unsigned int
 #endif
 
 #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
 
 
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    are run).
 
    When YYLLOC_DEFAULT is run, CURRENT is set the location of the
    first token.  By default, to implement support for ranges, extend
    its range to the last symbol.  */
 
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(Current, Rhs, N)       	\
    Current.last_line   = Rhs[N].last_line;	\
    Current.last_column = Rhs[N].last_column;
 #endif
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #if YYPURE
 # if YYLSP_NEEDED
 #  ifdef YYLEX_PARAM
 #   define YYLEX		yylex (&yylval, &yylloc, YYLEX_PARAM)
 #  else
 #   define YYLEX		yylex (&yylval, &yylloc)
 #  endif
 # else /* !YYLSP_NEEDED */
 #  ifdef YYLEX_PARAM
 #   define YYLEX		yylex (&yylval, YYLEX_PARAM)
 #  else
 #   define YYLEX		yylex (&yylval)
 #  endif
 # endif /* !YYLSP_NEEDED */
 #else /* !YYPURE */
 # define YYLEX			yylex ()
 #endif /* !YYPURE */
 
 
 /* Enable debugging if requested.  */
 #if YYDEBUG
 
 # ifndef YYFPRINTF
 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYFPRINTF fprintf
 # endif
 
 # define YYDPRINTF(Args)			\
 do {						\
   if (yydebug)					\
     YYFPRINTF Args;				\
 } while (0)
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 #endif /* !YYDEBUG */
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef	YYINITDEPTH
 # define YYINITDEPTH 200
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
 #if YYMAXDEPTH == 0
 # undef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
 # define YYMAXDEPTH 10000
 #endif
 
 #ifdef YYERROR_VERBOSE
 
 # ifndef yystrlen
 #  if defined (__GLIBC__) && defined (_STRING_H)
 #   define yystrlen strlen
 #  else
 /* Return the length of YYSTR.  */
 static YYSIZE_T
 #   if defined (__STDC__) || defined (__cplusplus)
 yystrlen (const char *yystr)
 #   else
 yystrlen (yystr)
      const char *yystr;
 #   endif
 {
   register const char *yys = yystr;
 
   while (*yys++ != '\0')
     continue;
 
   return yys - yystr - 1;
 }
 #  endif
 # endif
 
 # ifndef yystpcpy
 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
    YYDEST.  */
 static char *
 #   if defined (__STDC__) || defined (__cplusplus)
 yystpcpy (char *yydest, const char *yysrc)
 #   else
 yystpcpy (yydest, yysrc)
      char *yydest;
      const char *yysrc;
 #   endif
 {
   register char *yyd = yydest;
   register const char *yys = yysrc;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;
 
   return yyd - 1;
 }
 #  endif
 # endif
 #endif
 
 #line 315 "/sw/share/bison/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
 # if defined (__STDC__) || defined (__cplusplus)
 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL
 # else
 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 # endif
 #else /* !YYPARSE_PARAM */
 # define YYPARSE_PARAM_ARG
 # define YYPARSE_PARAM_DECL
 #endif /* !YYPARSE_PARAM */
 
 /* Prevent warning if -Wstrict-prototypes.  */
 #ifdef __GNUC__
 # ifdef YYPARSE_PARAM
 int yyparse (void *);
 # else
 int yyparse (void);
 # endif
 #endif
 
 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
    variables are global, or local to YYPARSE.  */
 
 #define YY_DECL_NON_LSP_VARIABLES			\
 /* The lookahead symbol.  */				\
 int yychar;						\
 							\
 /* The semantic value of the lookahead symbol. */	\
 YYSTYPE yylval;						\
 							\
 /* Number of parse errors so far.  */			\
 int yynerrs;
 
 #if YYLSP_NEEDED
 # define YY_DECL_VARIABLES			\
 YY_DECL_NON_LSP_VARIABLES			\
 						\
 /* Location data for the lookahead symbol.  */	\
 YYLTYPE yylloc;
 #else
 # define YY_DECL_VARIABLES			\
 YY_DECL_NON_LSP_VARIABLES
 #endif
 
 
 /* If nonreentrant, generate the variables here. */
 
 #if !YYPURE
 YY_DECL_VARIABLES
 #endif  /* !YYPURE */
 
 int
 yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
 {
   /* If reentrant, generate the variables here. */
 #if YYPURE
   YY_DECL_VARIABLES
 #endif  /* !YYPURE */
 
   register int yystate;
   register int yyn;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */
   int yychar1 = 0;
 
   /* Three stacks and their tools:
      `yyss': related to states,
      `yyvs': related to semantic values,
      `yyls': related to locations.
 
      Refer to the stacks thru separate pointers, to allow yyoverflow
      to reallocate them elsewhere.  */
 
   /* The state stack. */
   short	yyssa[YYINITDEPTH];
   short *yyss = yyssa;
   register short *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
   YYSTYPE *yyvs = yyvsa;
   register YYSTYPE *yyvsp;
 
 #if YYLSP_NEEDED
   /* The location stack.  */
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;
 #endif
 
 #if YYLSP_NEEDED
 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 #else
 # define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 
   YYSIZE_T yystacksize = YYINITDEPTH;
 
 
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;
 #if YYLSP_NEEDED
   YYLTYPE yyloc;
 #endif
 
   /* When reducing, the number of symbols on the RHS of the reduced
      rule. */
   int yylen;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   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;
   yyvsp = yyvs;
 #if YYLSP_NEEDED
   yylsp = yyls;
 #endif
   goto yysetstate;
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
  yynewstate:
   /* In all cases, when you get here, the value and location stacks
      have just been pushed. so pushing a state here evens the stacks.
      */
   yyssp++;
 
  yysetstate:
   *yyssp = yystate;
 
   if (yyssp >= yyss + yystacksize - 1)
     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
 
 #ifdef yyoverflow
       {
 	/* 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;
 
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  */
 # if YYLSP_NEEDED
 	YYLTYPE *yyls1 = yyls;
 	/* 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, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
 		    &yyls1, yysize * sizeof (*yylsp),
 		    &yystacksize);
 	yyls = yyls1;
 # else
 	yyoverflow ("parser stack overflow",
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
 		    &yystacksize);
 # endif
 	yyss = yyss1;
 	yyvs = yyvs1;
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
       goto yyoverflowlab;
 # else
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
 	goto yyoverflowlab;
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
 	yystacksize = YYMAXDEPTH;
 
       {
 	short *yyss1 = yyss;
 	union yyalloc *yyptr =
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
 	  goto yyoverflowlab;
 	YYSTACK_RELOCATE (yyss);
 	YYSTACK_RELOCATE (yyvs);
 # if YYLSP_NEEDED
 	YYSTACK_RELOCATE (yyls);
 # endif
 # undef YYSTACK_RELOCATE
 	if (yyss1 != yyssa)
 	  YYSTACK_FREE (yyss1);
       }
 # endif
 #endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 #if YYLSP_NEEDED
       yylsp = yyls + yysize - 1;
 #endif
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
       if (yyssp >= yyss + yystacksize - 1)
 	YYABORT;
     }
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
   goto yybackup;
 
 
 /*-----------.
 | 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)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       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 */
 
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
       yychar1 = YYTRANSLATE (yychar);
 
 #if YYDEBUG
      /* We have to keep this `#if YYDEBUG', since we use variables
 	which are defined only if `YYDEBUG' is set.  */
       if (yydebug)
 	{
 	  YYFPRINTF (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
 	  YYFPRINTF (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.  */
   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 	      yychar, yytname[yychar1]));
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
     yychar = YYEMPTY;
 
   *++yyvsp = yylval;
 #if YYLSP_NEEDED
   *++yylsp = yylloc;
 #endif
 
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
   yystate = yyn;
   goto yynewstate;
 
 
 /*-----------------------------------------------------------.
 | yydefault -- do the default action for the current state.  |
 `-----------------------------------------------------------*/
 yydefault:
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
   goto yyreduce;
 
 
 /*-----------------------------.
 | yyreduce -- Do a reduction.  |
 `-----------------------------*/
 yyreduce:
   /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];
 
   /* If YYLEN is nonzero, implement the default value of the action:
      `$$ = $1'.
 
      Otherwise, the following line sets YYVAL to the semantic value of
      the lookahead token.  This behavior is undocumented and Bison
      users should not rely upon it.  Assigning to YYVAL
      unconditionally makes the parser a bit smaller, and it avoids a
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
 
 #if YYLSP_NEEDED
   /* Similarly for the default location.  Let the user run additional
      commands if for instance locations are ranges.  */
   yyloc = yylsp[1-yylen];
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
 #endif
 
 #if YYDEBUG
   /* We have to keep this `#if YYDEBUG', since we use variables which
      are defined only if `YYDEBUG' is set.  */
   if (yydebug)
     {
       int yyi;
 
       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
 		 yyn, yyrline[yyn]);
 
       /* Print the symbols being reduced, and their result.  */
       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
 	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     }
 #endif
 
   switch (yyn) {
 
 case 3:
 #line 142 "parser.y"
 {
 	    /* Verify the service description, supply defaults
 	     * and so on.
 	     */
 	    if (!cur_service.port)
 		error ("Service %s lacks a port",
 		       cur_service.name);
 	    if (!cur_service.nbackend)
 		error ("Service %s lacks back ends",
 		       cur_service.name);
 
 	    if (!cur_service.shmkey)
 		cur_service.shmkey = cur_service.port | SHM_MASK;
 
 	    if (!cur_service.bind)
 		cur_service.bind = "any";
 
 	    /* Add to the list. */
 	    service = xrealloc (service, ++nservice * sizeof(Service));
 	    service[nservice - 1] = cur_service;
 	    memset (&cur_service, 0, sizeof(Service));
 	;
     break;}
 case 5:
 #line 173 "parser.y"
 {
 	    psmsg ("service:", yytext);
 	    cur_service.name = xstrdup(yytext);
 	;
     break;}
 case 9:
 #line 192 "parser.y"
 {
 	    pimsg ("sevice port:", yyvsp[0].set[0].v.ival);
 	    cur_service.port = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 10:
 #line 198 "parser.y"
 {
 	    psmsg ("service binding:", yyvsp[0].set[0].v.sval);
 	    cur_service.bind = yyvsp[0].set[0].v.sval;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 11:
 #line 204 "parser.y"
 {
 	    pimsg ("service verbosity:", yyvsp[0].set[0].v.ival);
 	    cur_service.verbosity = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 12:
 #line 210 "parser.y"
 {
 	    pimsg ("service dispatch mode:", yyvsp[0].set[0].v.ival);
 	    pimsg ("service dispatch over:", lastovernr);
 	    psmsg ("service dispatch exth:", lastext);
 	    cur_service.dispatchtype = yyvsp[0].set[0].v.ival;
 	    cur_service.dispatchover = lastovernr;
 	    cur_service.dispatchext  = lastext;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 13:
 #line 220 "parser.y"
 {
 	    pimsg ("service revival interval:", yyvsp[0].set[0].v.ival);
 	    cur_service.rev_interval = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 14:
 #line 226 "parser.y"
 {
 	    pimsg ("service backlog:", yyvsp[0].set[0].v.ival);
 	    cur_service.backlog = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 15:
 #line 232 "parser.y"
 {
 	    pimsg ("service shmkey:", yyvsp[0].set[0].v.ival);
 	    cur_service.shmkey = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 16:
 #line 238 "parser.y"
 {
 	    pimsg ("connection timout:", yyvsp[0].set[0].v.ival);
 	    cur_service.connectiontimeout = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 17:
 #line 244 "parser.y"
 {
 	    pimsg ("max clients in service:", yyvsp[0].set[0].v.ival);
 	    cur_service.maxconnections = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 18:
 #line 250 "parser.y"
 {
 	    pimsg ("service type: ", yyvsp[0].set[0].v.ival);
 	    cur_service.type = yyvsp[0].set[0].v.ival;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 19:
 #line 256 "parser.y"
 {
 	    psmsg ("allow from: ", yyvsp[0].set[0].v.sval);
 	    add_allowfrom (yyvsp[0].set[0].v.sval);
 	    free (yyvsp[0].set);
 	;
     break;}
 case 20:
 #line 262 "parser.y"
 {
 	    psmsg ("allow file: ", yyvsp[0].set[0].v.sval);
 	    cur_service.allowfile = yyvsp[0].set[0].v.sval;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 21:
 #line 268 "parser.y"
 {
 	    psmsg ("deny from: ", yyvsp[0].set[0].v.sval);
 	    add_denyfrom (yyvsp[0].set[0].v.sval);
 	    free (yyvsp[0].set);
 	;
     break;}
 case 22:
 #line 274 "parser.y"
 {
 	    psmsg ("deny file: ", yyvsp[0].set[0].v.sval);
 	    cur_service.denyfile = yyvsp[0].set[0].v.sval;
 	    free (yyvsp[0].set);
 	;
     break;}
 case 23:
 #line 280 "parser.y"
 {
 	    psmsg ("user account: ", yyvsp[0].set[0].v.sval);
 	    setuseraccount (yyvsp[0].set[0].v.sval);
 	    free (yyvsp[0].set[0].v.sval);
 	    free (yyvsp[0].set);
 	;
     break;}
 case 24:
 #line 287 "parser.y"
 {
 	    pimsg ("converting backend statements, count is", yyvsp[0].n);
 	    for (i = 0; i < yyvsp[0].n; i++)
 		switch (yyvsp[0].set[i].cf) {
 		case cf_portspec:
 		    pimsg ("backend block port:", yyvsp[0].set[i].v.ival);
 		    cur_backend.port = yyvsp[0].set[i].v.ival;
 		    break;
 		case cf_serverspec:
 		    psmsg ("backend block server:", yyvsp[0].set[i].v.sval);
 		    cur_backend.server = serverpart (yyvsp[0].set[i].v.sval);
 		    cur_backend.port   = portpart (yyvsp[0].set[i].v.sval);
 		    free (yyvsp[0].set[i].v.sval);
 		    break;
 		case cf_verbosityspec:
 		    pimsg ("backend block verbosity:", yyvsp[0].set[i].v.ival);
 		    cur_backend.verbosity = yyvsp[0].set[i].v.ival;
 		    break;
 		case cf_onstartspec:
 		    psmsg ("backend block onstart:", yyvsp[0].set[i].v.sval);
 		    cur_backend.onstart = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_onfailspec:
 		    psmsg ("backend block onfail:", yyvsp[0].set[i].v.sval);
 		    cur_backend.onfail = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_onendspec:
 		    psmsg ("backend block onend:", yyvsp[0].set[i].v.sval);
 		    cur_backend.onend = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_dumpspec:
 		    psmsg ("backend trafficlog:", yyvsp[0].set[i].v.sval);
 		    cur_backend.dumpfile = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_thruspec:
 		    psmsg ("backend throughputlog:", yyvsp[0].set[i].v.sval);
 		    cur_backend.thruputfile = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_weightspec:
 		    pimsg ("backend weight:", yyvsp[0].set[i].v.ival);
 		    cur_backend.weight = yyvsp[0].set[i].v.ival;
 		    break;
 		case cf_decayspec:
 		    pimsg ("backend decay:", yyvsp[0].set[i].v.ival);
 		    if (yyvsp[0].set[i].v.ival >= 100)
 			error ("Decay specifier %d must be a percentage, "
 			       "never more than 99",
 			       yyvsp[0].set[i].v.ival);
 		    cur_backend.decay = yyvsp[0].set[i].v.ival;
 		    break;
 		case cf_maxconnectionsspec:
 		    pimsg ("backend max clients: ", yyvsp[0].set[i].v.ival);
 		    cur_backend.maxconnections = yyvsp[0].set[i].v.ival;
 		    break;
 		case cf_stickycookiespec:
 		    psmsg ("backend sticky cookie:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.stickycookie = yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_addclientheaderspec:
 		    psmsg ("client header to add:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.addclientheader =
 			xrealloc (cur_backend.addclientheader,
 				  (cur_backend.naddclientheader + 1) *
 				  sizeof(char*));
 		    cur_backend.addclientheader
 			[cur_backend.naddclientheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_setclientheaderspec:
 		    psmsg ("client header to set:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.setclientheader =
 			xrealloc (cur_backend.setclientheader,
 				  (cur_backend.nsetclientheader + 1) *
 				  sizeof(char*));
 		    cur_backend.setclientheader
 			[cur_backend.nsetclientheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_appendclientheaderspec:
 		    psmsg ("client header to append:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.appendclientheader =
 			xrealloc (cur_backend.appendclientheader,
 				  (cur_backend.nappendclientheader + 1) *
 				  sizeof(char*));
 		    cur_backend.appendclientheader
 			[cur_backend.nappendclientheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_addserverheaderspec:
 		    psmsg ("server header to add:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.addserverheader =
 			xrealloc (cur_backend.addserverheader,
 				  (cur_backend.naddserverheader + 1) *
 				  sizeof(char*));
 		    cur_backend.addserverheader
 			[cur_backend.naddserverheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_setserverheaderspec:
 		    psmsg ("server header to set:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.setserverheader =
 			xrealloc (cur_backend.setserverheader,
 				  (cur_backend.nsetserverheader + 1) *
 				  sizeof(char*));
 		    cur_backend.setserverheader
 			[cur_backend.nsetserverheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		case cf_appendserverheaderspec:
 		    psmsg ("server header to append:",
 			   yyvsp[0].set[i].v.sval);
 		    cur_backend.appendserverheader =
 			xrealloc (cur_backend.appendserverheader,
 				  (cur_backend.nappendserverheader + 1) *
 				  sizeof(char*));
 		    cur_backend.appendserverheader
 			[cur_backend.nappendserverheader++] =
 			    yyvsp[0].set[i].v.sval;
 		    break;
 		default:
 		    error ("Internal jam, unhandled type %d "
 			   "in backend specification",
 			   yyvsp[0].set[i].cf);
 		}
 	    free (yyvsp[0].set);
 
 	    /* Verify the backend block, supply defaults,
 	     * And so on.
 	     */
 	    if (!cur_service.port)
 		error ("Back end %s lacks port",
 		       cur_service.port);
 	    if (!cur_backend.weight)
 		cur_backend.weight = 1;
 
 	    /* Add to the list. */
 	    cur_service.backend = xrealloc (cur_service.backend,
 					    ++cur_service.nbackend *
 					    sizeof(Backend));
 	    cur_service.backend[cur_service.nbackend - 1] =
 		cur_backend;
 	    pimsg ("this was backend defintion", cur_service.nbackend);
 	    memset (&cur_backend, 0, sizeof(cur_backend));
 	;
     break;}
 case 25:
 #line 442 "parser.y"
 {
 	    pimsg ("port statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_portspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 26:
 #line 454 "parser.y"
 {
 	    psmsg ("bindto statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_bindspec;
 	    yyval.set[0].v.sval = xstrdup(laststr);
 	;
     break;}
 case 27:
 #line 465 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 28:
 #line 474 "parser.y"
 {
 	    setlastnr (yytext);
 	;
     break;}
 case 30:
 #line 488 "parser.y"
 {
 	    pimsg ("verbosity statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_verbosityspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 31:
 #line 498 "parser.y"
 {
 	    lastnr = 1;
 	;
     break;}
 case 32:
 #line 502 "parser.y"
 {
 	    lastnr = 0;
 	;
     break;}
 case 33:
 #line 511 "parser.y"
 {
 	    yyval = yyvsp[-2];
 	;
     break;}
 case 37:
 #line 526 "parser.y"
 {
 	    pimsg ("dispatch mode statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_dispatchspec;
 	    yyval.set[0].v.ival = lastnr;
 
 	    if (lastovernr &&
 		(lastnr != ds_bysize && lastnr != ds_byduration))
 		error ("Service '%s': this dispatch mode "
 		       "doesn't support 'over <connections>'",
 		       cur_service.name);
 	;
     break;}
 case 38:
 #line 543 "parser.y"
 {
 	    setlastovernr (yytext);
 	;
     break;}
 case 39:
 #line 549 "parser.y"
 {
 	    psmsg ("external handler:", laststr);
 	    if (lastnr != ds_externalhandler)
 		error ("Service %s: this dispatch mode doesn't support "
 		       "an external handler", cur_service.name);
 	    setlastext (laststr);
 	;
     break;}
 case 40:
 #line 560 "parser.y"
 {
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 41:
 #line 568 "parser.y"
 {
 	    lastnr = ds_roundrobin;
 	;
     break;}
 case 42:
 #line 572 "parser.y"
 {
 	    lastnr = ds_random;
 	;
     break;}
 case 43:
 #line 576 "parser.y"
 {
 	    lastnr = ds_byduration;
 	;
     break;}
 case 44:
 #line 580 "parser.y"
 {
 	    lastnr = ds_bysize;
 	;
     break;}
 case 45:
 #line 584 "parser.y"
 {
 	    lastnr = ds_byorder;
 	;
     break;}
 case 46:
 #line 588 "parser.y"
 {
 	    lastnr = ds_byconnections;
 	;
     break;}
 case 47:
 #line 592 "parser.y"
 {
 	    lastnr = ds_externalhandler;
 	;
     break;}
 case 48:
 #line 600 "parser.y"
 {
 	    pimsg ("user account statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_useraccountspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 49:
 #line 611 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 50:
 #line 621 "parser.y"
 {
 	    pimsg ("reviving interval statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_revivespec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 51:
 #line 633 "parser.y"
 {
 	    pimsg ("backlog statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_revivespec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 52:
 #line 645 "parser.y"
 {
 	    pimsg ("shmkey statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_shmkeyspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 53:
 #line 657 "parser.y"
 {
 	    pimsg ("connection timeout statement:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_connectiontimeoutspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 54:
 #line 669 "parser.y"
 {
 	    pimsg ("max clients statement (service):", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_maxconnectionsspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 55:
 #line 681 "parser.y"
 {
 	    pimsg ("service type:", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_typespec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 57:
 #line 696 "parser.y"
 {
 	    lastnr = type_any;
 	;
     break;}
 case 58:
 #line 700 "parser.y"
 {
 	    lastnr = type_http;
 	;
     break;}
 case 59:
 #line 708 "parser.y"
 {
 	    psmsg ("allow from: ", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_allowfromspec;
 	    yyval.set[0].v.sval = xstrdup(laststr);
 	;
     break;}
 case 60:
 #line 720 "parser.y"
 {
 	    psmsg ("allow from: ", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_denyfromspec;
 	    yyval.set[0].v.sval = xstrdup(laststr);
 	;
     break;}
 case 61:
 #line 732 "parser.y"
 {
 	    psmsg ("allow file: ", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_allowfilespec;
 	    yyval.set[0].v.sval = xstrdup(laststr);
 	;
     break;}
 case 62:
 #line 744 "parser.y"
 {
 	    psmsg ("allow file: ", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_allowfilespec;
 	    yyval.set[0].v.sval = xstrdup(laststr);
 	;
     break;}
 case 63:
 #line 755 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 64:
 #line 767 "parser.y"
 {
 	    yyval = yyvsp[-1];
 	;
     break;}
 case 65:
 #line 774 "parser.y"
 {
 	    psmsg ("backend name:", yytext);
 	    cur_backend.name = xstrdup (yytext);
 	;
     break;}
 case 66:
 #line 782 "parser.y"
 {
 	    yyvsp[-1].n++;
 	    yyvsp[-1].set = xrealloc (yyvsp[-1].set, yyvsp[-1].n * sizeof(Confset));
 	    yyvsp[-1].set[yyvsp[-1].n - 1] = yyvsp[0].set[0];
 	    yyval = yyvsp[-1];
 	;
     break;}
 case 67:
 #line 789 "parser.y"
 {
 	    yyval = yyvsp[0];
 	;
     break;}
 case 68:
 #line 796 "parser.y"
 {
 	    yyval = yyvsp[0];
 	;
     break;}
 case 69:
 #line 802 "parser.y"
 {
 	    psmsg ("backend server:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 70:
 #line 807 "parser.y"
 {
 	    pimsg ("backend port:", yyvsp[0].set[0].v.ival);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 71:
 #line 812 "parser.y"
 {
 	    pimsg ("backend verbosity:", yyvsp[0].set[0].v.ival);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 72:
 #line 817 "parser.y"
 {
 	    psmsg ("backend onstart:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 73:
 #line 822 "parser.y"
 {
 	    psmsg ("backend onend:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 74:
 #line 827 "parser.y"
 {
 	    psmsg ("backend onfail:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 75:
 #line 832 "parser.y"
 {
 	    psmsg ("backend trafficlog:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 76:
 #line 837 "parser.y"
 {
 	    psmsg ("backend trafficlog:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 77:
 #line 842 "parser.y"
 {
 	    pimsg ("backend weight:", yyvsp[0].set[0].v.ival);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 78:
 #line 847 "parser.y"
 {
 	    pimsg ("backend decay:", yyvsp[0].set[0].v.ival);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 79:
 #line 852 "parser.y"
 {
 	    pimsg ("backend maxconnections:", yyvsp[0].set[0].v.ival);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 80:
 #line 857 "parser.y"
 {
 	    psmsg ("backend sticky cookie:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 81:
 #line 862 "parser.y"
 {
 	    psmsg ("addclientheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 82:
 #line 867 "parser.y"
 {
 	    psmsg ("setclientheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 83:
 #line 872 "parser.y"
 {
 	    psmsg ("appendclientheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 84:
 #line 877 "parser.y"
 {
 	    psmsg ("addserverheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 85:
 #line 882 "parser.y"
 {
 	    psmsg ("setserverheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 86:
 #line 887 "parser.y"
 {
 	    psmsg ("appendserverheader:", yyvsp[0].set[0].v.sval);
 	    yyval = yyvsp[0];
 	;
     break;}
 case 87:
 #line 897 "parser.y"
 {
 	    psmsg ("server statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_serverspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 88:
 #line 909 "parser.y"
 {
 	    pimsg ("weight statement", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_weightspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 89:
 #line 921 "parser.y"
 {
 	    pimsg ("decay statement", lastnr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_decayspec;
 	    yyval.set[0].v.ival = lastnr;
 	;
     break;}
 case 90:
 #line 931 "parser.y"
 {
 	    setlaststr (laststring);
 	;
     break;}
 case 91:
 #line 939 "parser.y"
 {
 	    psmsg ("onstart statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_onstartspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 92:
 #line 951 "parser.y"
 {
 	    psmsg ("onfail statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_onfailspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 93:
 #line 963 "parser.y"
 {
 	    psmsg ("onend statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_onendspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 94:
 #line 975 "parser.y"
 {
 	    psmsg ("trafficlog statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_dumpspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 95:
 #line 987 "parser.y"
 {
 	    psmsg ("throughputlog statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_thruspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 96:
 #line 998 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 97:
 #line 1007 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 98:
 #line 1017 "parser.y"
 {
 	    psmsg ("insertcookie statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof (Confset));
 	    yyval.set[0].cf = cf_stickycookiespec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 99:
 #line 1028 "parser.y"
 {
 		setlaststr (laststring);
 		free (laststring);
 		laststring = 0;
 	;
     break;}
 case 100:
 #line 1038 "parser.y"
 {
 	    psmsg ("addclientheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_addclientheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 101:
 #line 1050 "parser.y"
 {
 	    psmsg ("setclientheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_setclientheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 102:
 #line 1062 "parser.y"
 {
 	    psmsg ("appendclientheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_appendclientheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 103:
 #line 1074 "parser.y"
 {
 	    psmsg ("addserverheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_addserverheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 104:
 #line 1086 "parser.y"
 {
 	    psmsg ("setserverheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_setserverheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 105:
 #line 1098 "parser.y"
 {
 	    psmsg ("appendserverheader statement:", laststr);
 	    yyval.n = 1;
 	    yyval.set = xmalloc (sizeof(Confset));
 	    yyval.set[0].cf = cf_appendserverheaderspec;
 	    yyval.set[0].v.sval = xstrdup (laststr);
 	;
     break;}
 case 106:
 #line 1109 "parser.y"
 {
 	    setlaststr (laststring);
 	    free (laststring);
 	    laststring = 0;
 	;
     break;}
 case 107:
 #line 1116 "parser.y"
 {
     yyerrmsg = "HTTP header specifier expected";
 ;
     break;}
 case 108:
 #line 1121 "parser.y"
 {
     yyerrmsg = "cookie specifier expected";
 ;
     break;}
 case 109:
 #line 1126 "parser.y"
 {
     yyerrmsg = "number expected";
 ;
     break;}
 case 110:
 #line 1131 "parser.y"
 {
     yyerrmsg = "hostname or IP address expected";
 ;
     break;}
 case 111:
 #line 1136 "parser.y"
 {
     yyerrmsg = "'service' expected";
 ;
     break;}
 case 112:
 #line 1141 "parser.y"
 {
     yyerrmsg = "backend definition statement expected";
 ;
     break;}
 case 113:
 #line 1146 "parser.y"
 {
     yyerrmsg = "service body statement expected";
 ;
     break;}
 case 114:
 #line 1151 "parser.y"
 {
     yyerrmsg = "semicolon (;) expected";
 ;
     break;}
 case 115:
 #line 1156 "parser.y"
 {
     yyerrmsg = "'on' or 'off' expetcted";
 ;
     break;}
 case 116:
 #line 1161 "parser.y"
 {
     yyerrmsg = "dispatch method expected";
 ;
     break;}
 case 117:
 #line 1166 "parser.y"
 {
     yyerrmsg = "command line expected";
 ;
     break;}
 case 118:
 #line 1171 "parser.y"
 {
     yyerrmsg = "file name expected";
 ;
     break;}
 case 119:
 #line 1176 "parser.y"
 {
     yyerrmsg = "service name (identifier) expected";
 ;
     break;}
 case 120:
 #line 1181 "parser.y"
 {
     yyerrmsg = "backend name (identifier) expected";
 ;
     break;}
 case 121:
 #line 1186 "parser.y"
 {
     yyerrmsg = "IP address or 'any' expected";
 ;
     break;}
 case 122:
 #line 1191 "parser.y"
 {
     yyerrmsg = "Service type expected ('any', 'stickyhttp', ...)";
 ;
     break;}
 case 123:
 #line 1196 "parser.y"
 {
     yyerrmsg = "IP filter(s) expected";
 ;
     break;}
 case 124:
 #line 1201 "parser.y"
 {
     yyerrmsg = "username expected";
 ;
     break;}
 }
 
 #line 705 "/sw/share/bison/bison.simple"
 
 
   yyvsp -= yylen;
   yyssp -= yylen;
 #if YYLSP_NEEDED
   yylsp -= yylen;
 #endif
 
 #if YYDEBUG
   if (yydebug)
     {
       short *yyssp1 = yyss - 1;
       YYFPRINTF (stderr, "state stack now");
       while (yyssp1 != yyssp)
 	YYFPRINTF (stderr, " %d", *++yyssp1);
       YYFPRINTF (stderr, "\n");
     }
 #endif
 
   *++yyvsp = yyval;
 #if YYLSP_NEEDED
   *++yylsp = yyloc;
 #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 |
 `------------------------------------*/
 yyerrlab:
   /* If not already recovering from an error, report this error.  */
   if (!yyerrstatus)
     {
       ++yynerrs;
 
 #ifdef YYERROR_VERBOSE
       yyn = yypact[yystate];
 
       if (yyn > YYFLAG && yyn < YYLAST)
 	{
 	  YYSIZE_T yysize = 0;
 	  char *yymsg;
 	  int yyx, yycount;
 
 	  yycount = 0;
 	  /* Start YYX at -YYN if negative to avoid negative indexes in
 	     YYCHECK.  */
 	  for (yyx = yyn < 0 ? -yyn : 0;
 	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
 	    if (yycheck[yyx + yyn] == yyx)
 	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
 	  yysize += yystrlen ("parse error, unexpected ") + 1;
 	  yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
 	  yymsg = (char *) YYSTACK_ALLOC (yysize);
 	  if (yymsg != 0)
 	    {
 	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
 	      yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
 
 	      if (yycount < 5)
 		{
 		  yycount = 0;
 		  for (yyx = yyn < 0 ? -yyn : 0;
 		       yyx < (int) (sizeof (yytname) / sizeof (char *));
 		       yyx++)
 		    if (yycheck[yyx + yyn] == yyx)
 		      {
 			const char *yyq = ! yycount ? ", expecting " : " or ";
 			yyp = yystpcpy (yyp, yyq);
 			yyp = yystpcpy (yyp, yytname[yyx]);
 			yycount++;
 		      }
 		}
 	      yyerror (yymsg);
 	      YYSTACK_FREE (yymsg);
 	    }
 	  else
 	    yyerror ("parse error; also virtual memory exhausted");
 	}
       else
 #endif /* defined (YYERROR_VERBOSE) */
 	yyerror ("parse error");
     }
   goto yyerrlab1;
 
 
 /*--------------------------------------------------.
 | yyerrlab1 -- error raised explicitly by an action |
 `--------------------------------------------------*/
 yyerrlab1:
   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;
       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
 		  yychar, yytname[yychar1]));
       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.                                                       |
 `-------------------------------------------------------------------*/
 yyerrdefault:
 #if 0
   /* This is wrong; only states that explicitly want error tokens
      should shift them.  */
 
   /* If its default is to accept any token, ok.  Otherwise pop it.  */
   yyn = yydefact[yystate];
   if (yyn)
     goto yydefault;
 #endif
 
 
 /*---------------------------------------------------------------.
 | yyerrpop -- pop the current state because it cannot handle the |
 | error token                                                    |
 `---------------------------------------------------------------*/
 yyerrpop:
   if (yyssp == yyss)
     YYABORT;
   yyvsp--;
   yystate = *--yyssp;
 #if YYLSP_NEEDED
   yylsp--;
 #endif
 
 #if YYDEBUG
   if (yydebug)
     {
       short *yyssp1 = yyss - 1;
       YYFPRINTF (stderr, "Error: state stack now");
       while (yyssp1 != yyssp)
 	YYFPRINTF (stderr, " %d", *++yyssp1);
       YYFPRINTF (stderr, "\n");
     }
 #endif
 
 /*--------------.
 | yyerrhandle.  |
 `--------------*/
 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;
 
   YYDPRINTF ((stderr, "Shifting error token, "));
 
   *++yyvsp = yylval;
 #if YYLSP_NEEDED
   *++yylsp = yylloc;
 #endif
 
   yystate = yyn;
   goto yynewstate;
 
 
 /*-------------------------------------.
 | yyacceptlab -- YYACCEPT comes here.  |
 `-------------------------------------*/
 yyacceptlab:
   yyresult = 0;
   goto yyreturn;
 
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
 /*---------------------------------------------.
 | yyoverflowab -- parser overflow comes here.  |
 `---------------------------------------------*/
 yyoverflowlab:
   yyerror ("parser stack overflow");
   yyresult = 2;
   /* Fall through.  */
 
 yyreturn:
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);
 #endif
   return yyresult;
 }
 #line 1205 "parser.y"