rem: ; break;} case 35: #line 282 "conf.y" {
add: } break;  case 38: #line 288 "conf.y" {
context: 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 5:#line 181 "conf.y"{ entry_vector-> push(yyvsp[0].entry_type); ;    break;}case 7:#line 184 "conf.y"{ conf_user = solve_user(conf_ident); ;    break;}case 8:#line 185 "conf.y"{ conf_group = solve_group(conf_ident); ;    break;}case 9:#line 186 "conf.y"{ conf_listen = solve_hostname(conf_ident); ;    break;}case 10:#line 187 "conf.y"{ 					conf_source = solve_hostname(conf_ident); 					conf_src = &conf_source;		;    break;}case 11:#line 191 "conf.y"{ conf_listen = solve_hostname(conf_ident); ;    break;}case 12:#line 193 "conf.y"{ yyval.entry_type = new entry(P_TCP, yyvsp[0].map_list_type); ;    break;}case 13:#line 194 "conf.y"{ yyval.entry_type = new entry(P_UDP, yyvsp[0].map_list_type); ;    break;}case 14:#line 196 "conf.y"{ set_protoname(P_TCP); ;    break;}case 15:#line 197 "conf.y"{ set_protoname(P_UDP); ;    break;}case 16:#line 199 "conf.y"{ yyval.map_list_type = yyvsp[-1].map_list_type; ;    break;}case 17:#line 201 "conf.y"{			map_vector = new vector<proto_map*>();			map_vector->push(yyvsp[0].map_type);			yyval.map_list_type = map_vector;		;    break;}case 18:#line 206 "conf.y"{			map_vector->push(yyvsp[0].map_type);			yyval.map_list_type = map_vector;		;    break;}case 19:#line 211 "conf.y"{			yyval.map_type = new proto_map(yyvsp[-3].port_list_type, yyvsp[-1].host_list_type, 0, 0, conf_user, conf_group, conf_listen, conf_src);		;    break;}case 20:#line 214 "conf.y"{		        struct ip_addr ip = use_hostname(yyvsp[-3].str_type);			yyval.map_type = new proto_map(yyvsp[-5].port_list_type, yyvsp[-1].host_list_type, &ip, 0, conf_user, conf_group, conf_listen, conf_src);		;    break;}case 21:#line 218 "conf.y"{		        struct ip_addr ip = use_hostname(yyvsp[-3].str_type);			yyval.map_type = new proto_map(yyvsp[-5].port_list_type, yyvsp[-1].host_list_type, 0, &ip, conf_user, conf_group, conf_listen, conf_src);		;    break;}case 22:#line 222 "conf.y"{		        struct ip_addr ip1 = use_hostname(yyvsp[-5].str_type);		        struct ip_addr ip2 = use_hostname(yyvsp[-3].str_type);			yyval.map_type = new proto_map(yyvsp[-7].port_list_type, yyvsp[-1].host_list_type, &ip1, &ip2, conf_user, conf_group, conf_listen, conf_src);		;    break;}case 23:#line 227 "conf.y"{		        struct ip_addr ip1 = use_hostname(yyvsp[-5].str_type);		        struct ip_addr ip2 = use_hostname(yyvsp[-3].str_type);			yyval.map_type = new proto_map(yyvsp[-7].port_list_type, yyvsp[-1].host_list_type, &ip2, &ip1, conf_user, conf_group, conf_listen, conf_src);		;    break;}case 24:#line 233 "conf.y"{ yyval.str_type = safe_strdup(conf_ident); ;    break;}case 25:#line 235 "conf.y"{			port_vector = new vector<int>();			port_vector->push(use_port(yyvsp[0].str_type));			yyval.port_list_type = port_vector; 		;    break;}case 26:#line 240 "conf.y"{			port_vector->push(use_port(yyvsp[0].str_type));			yyval.port_list_type = port_vector; 		;    break;}case 27:#line 245 "conf.y"{              		host_vector = new vector<host_map*>();			host_vector->push(yyvsp[0].host_map_type);			yyval.host_list_type = host_vector;		;    break;}case 28:#line 250 "conf.y"{			host_vector->push(yyvsp[0].host_map_type);			yyval.host_list_type = host_vector;		;    break;}case 29:#line 255 "conf.y"{			yyval.host_map_type = new host_map(yyvsp[-2].from_list_type, yyvsp[0].dst_list_type);		;    break;}case 30:#line 259 "conf.y"{			dst_vector = new vector<to_addr*>();			dst_vector->push(yyvsp[0].dst_type);			yyval.dst_list_type = dst_vector;                ;    break;}case 31:#line 264 "conf.y"{			dst_vector->push(yyvsp[0].dst_type);			yyval.dst_list_type = dst_vector;                ;    break;}case 32:#line 269 "conf.y"{			int port = use_port(yyvsp[0].str_type);   /* solve portname */			yyval.dst_type = use_dstaddr(yyvsp[-2].str_type, port); /* new dst_addr() */                ;    break;}case 33:#line 273 "conf.y"{                        yyval.dst_type = new director(conf_lex_str_buf);		;    break;}case 34:#line 277 "conf.y"{			from_vector = new vector<from_addr*>();			from_vector->push(yyvsp[0].from_type);			yyval.from_list_type = from_vector;		;    break;}case 35:#line 282 "conf.y"{			from_vector->push(yyvsp[0].from_type);			yyval.from_list_type = from_vector;		;    break;}case 36:#line 287 "conf.y"{ 			yyval.from_type = new from_addr(new net_portion(solve_hostname(ANY_ADDR), MIN_MASK_LEN), new port_pair(FIRST_PORT, LAST_PORT)); 		;    break;}case 37:#line 290 "conf.y"{ 			yyval.from_type = new from_addr(yyvsp[0].net_type, new port_pair(FIRST_PORT, LAST_PORT)); 		;    break;}case 38:#line 293 "conf.y"{ 			yyval.from_type = new from_addr(new net_portion(solve_hostname(ANY_ADDR), MIN_MASK_LEN), yyvsp[0].port_type); 		;    break;}case 39:#line 296 "conf.y"{ 			yyval.from_type = new from_addr(yyvsp[-2].net_type, yyvsp[0].port_type); 		;    break;}case 40:#line 300 "conf.y"{ 			/* use_hostprefix(): new net_portion() */  			yyval.net_type = use_hostprefix(yyvsp[-1].str_type, yyvsp[0].int_type); 		;    break;}case 41:#line 305 "conf.y"{ yyval.int_type = MAX_MASK_LEN; ;    break;}case 42:#line 306 "conf.y"{ yyval.int_type = mask_len_value(conf_ident); ;    break;}case 43:#line 308 "conf.y"{			int port = use_port(yyvsp[0].str_type);			yyval.port_type = new port_pair(port, port);		;    break;}case 44:#line 312 "conf.y"{ 			yyval.port_type = new port_pair(use_port(yyvsp[-1].str_type), 					   LAST_PORT); 		;    break;}case 45:#line 316 "conf.y"{ 			yyval.port_type = new port_pair(FIRST_PORT, 				           use_port(yyvsp[0].str_type)); 		;    break;}case 46:#line 320 "conf.y"{ 			yyval.port_type = new port_pair(use_port(yyvsp[-2].str_type),				           use_port(yyvsp[0].str_type));		;    break;}}   /* the action file gets copied in in place of this dollarsign */#line 543 "/usr/share/misc/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;#endifyyerrpop:   /* 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");    }#endifyyerrhandle:  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;}