grammar.c

用来监视网络通信数据的源代码和应用程序,方便网络程序底层开发.

case 92:
#line 310 "../libpcap/grammar.y"
{ yyval.i = Q_CLNP; }
    break;
case 93:
#line 311 "../libpcap/grammar.y"
{ yyval.i = Q_STP; }
    break;
case 94:
#line 312 "../libpcap/grammar.y"
{ yyval.i = Q_IPX; }
    break;
case 95:
#line 313 "../libpcap/grammar.y"
{ yyval.i = Q_NETBEUI; }
    break;
case 96:
#line 315 "../libpcap/grammar.y"
{ yyval.rblk = gen_broadcast(yyvsp[-1].i); }
    break;
case 97:
#line 316 "../libpcap/grammar.y"
{ yyval.rblk = gen_multicast(yyvsp[-1].i); }
    break;
case 98:
#line 317 "../libpcap/grammar.y"
{ yyval.rblk = gen_less(yyvsp[0].i); }
    break;
case 99:
#line 318 "../libpcap/grammar.y"
{ yyval.rblk = gen_greater(yyvsp[0].i); }
    break;
case 100:
#line 319 "../libpcap/grammar.y"
{ yyval.rblk = gen_byteop(yyvsp[-1].i, yyvsp[-2].i, yyvsp[0].i); }
    break;
case 101:
#line 320 "../libpcap/grammar.y"
{ yyval.rblk = gen_inbound(0); }
    break;
case 102:
#line 321 "../libpcap/grammar.y"
{ yyval.rblk = gen_inbound(1); }
    break;
case 103:
#line 322 "../libpcap/grammar.y"
{ yyval.rblk = gen_vlan(yyvsp[0].i); }
    break;
case 104:
#line 323 "../libpcap/grammar.y"
{ yyval.rblk = gen_vlan(-1); }
    break;
case 105:
#line 325 "../libpcap/grammar.y"
{ yyval.i = BPF_JGT; }
    break;
case 106:
#line 326 "../libpcap/grammar.y"
{ yyval.i = BPF_JGE; }
    break;
case 107:
#line 327 "../libpcap/grammar.y"
{ yyval.i = BPF_JEQ; }
    break;
case 108:
#line 329 "../libpcap/grammar.y"
{ yyval.i = BPF_JGT; }
    break;
case 109:
#line 330 "../libpcap/grammar.y"
{ yyval.i = BPF_JGE; }
    break;
case 110:
#line 331 "../libpcap/grammar.y"
{ yyval.i = BPF_JEQ; }
    break;
case 111:
#line 333 "../libpcap/grammar.y"
{ yyval.a = gen_loadi(yyvsp[0].i); }
    break;
case 113:
#line 336 "../libpcap/grammar.y"
{ yyval.a = gen_load(yyvsp[-3].i, yyvsp[-1].a, 1); }
    break;
case 114:
#line 337 "../libpcap/grammar.y"
{ yyval.a = gen_load(yyvsp[-5].i, yyvsp[-3].a, yyvsp[-1].i); }
    break;
case 115:
#line 338 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_ADD, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 116:
#line 339 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_SUB, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 117:
#line 340 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_MUL, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 118:
#line 341 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_DIV, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 119:
#line 342 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_AND, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 120:
#line 343 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_OR, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 121:
#line 344 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_LSH, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 122:
#line 345 "../libpcap/grammar.y"
{ yyval.a = gen_arth(BPF_RSH, yyvsp[-2].a, yyvsp[0].a); }
    break;
case 123:
#line 346 "../libpcap/grammar.y"
{ yyval.a = gen_neg(yyvsp[0].a); }
    break;
case 124:
#line 347 "../libpcap/grammar.y"
{ yyval.a = yyvsp[-1].a; }
    break;
case 125:
#line 348 "../libpcap/grammar.y"
{ yyval.a = gen_loadlen(); }
    break;
case 126:
#line 350 "../libpcap/grammar.y"
{ yyval.i = '&'; }
    break;
case 127:
#line 351 "../libpcap/grammar.y"
{ yyval.i = '|'; }
    break;
case 128:
#line 352 "../libpcap/grammar.y"
{ yyval.i = '<'; }
    break;
case 129:
#line 353 "../libpcap/grammar.y"
{ yyval.i = '>'; }
    break;
case 130:
#line 354 "../libpcap/grammar.y"
{ yyval.i = '='; }
    break;
case 132:
#line 357 "../libpcap/grammar.y"
{ yyval.i = yyvsp[-1].i; }
    break;
case 133:
#line 359 "../libpcap/grammar.y"
{ yyval.i = A_LANE; }
    break;
case 134:
#line 360 "../libpcap/grammar.y"
{ yyval.i = A_LLC; }
    break;
case 135:
#line 361 "../libpcap/grammar.y"
{ yyval.i = A_METAC;	}
    break;
case 136:
#line 362 "../libpcap/grammar.y"
{ yyval.i = A_BCC; }
    break;
case 137:
#line 363 "../libpcap/grammar.y"
{ yyval.i = A_OAMF4EC; }
    break;
case 138:
#line 364 "../libpcap/grammar.y"
{ yyval.i = A_OAMF4SC; }
    break;
case 139:
#line 365 "../libpcap/grammar.y"
{ yyval.i = A_SC; }
    break;
case 140:
#line 366 "../libpcap/grammar.y"
{ yyval.i = A_ILMIC; }
    break;
case 141:
#line 368 "../libpcap/grammar.y"
{ yyval.i = A_OAM; }
    break;
case 142:
#line 369 "../libpcap/grammar.y"
{ yyval.i = A_OAMF4; }
    break;
case 143:
#line 370 "../libpcap/grammar.y"
{ yyval.i = A_CONNECTMSG; }
    break;
case 144:
#line 371 "../libpcap/grammar.y"
{ yyval.i = A_METACONNECT; }
    break;
case 145:
#line 374 "../libpcap/grammar.y"
{ yyval.blk.atmfieldtype = A_VPI; }
    break;
case 146:
#line 375 "../libpcap/grammar.y"
{ yyval.blk.atmfieldtype = A_VCI; }
    break;
case 148:
#line 378 "../libpcap/grammar.y"
{ yyval.blk.b = gen_atmfield_code(yyvsp[-2].blk.atmfieldtype, (u_int)yyvsp[0].i, (u_int)yyvsp[-1].i, 0); }
    break;
case 149:
#line 379 "../libpcap/grammar.y"
{ yyval.blk.b = gen_atmfield_code(yyvsp[-2].blk.atmfieldtype, (u_int)yyvsp[0].i, (u_int)yyvsp[-1].i, 1); }
    break;
case 150:
#line 380 "../libpcap/grammar.y"
{ yyval.blk.b = yyvsp[-1].blk.b; yyval.blk.q = qerr; }
    break;
case 151:
#line 382 "../libpcap/grammar.y"
{
	yyval.blk.atmfieldtype = yyvsp[-1].blk.atmfieldtype;
	if (yyval.blk.atmfieldtype == A_VPI ||
	    yyval.blk.atmfieldtype == A_VCI)
		yyval.blk.b = gen_atmfield_code(yyval.blk.atmfieldtype, (u_int) yyvsp[0].i, BPF_JEQ, 0);
	}
    break;
case 153:
#line 390 "../libpcap/grammar.y"
{ gen_or(yyvsp[-2].blk.b, yyvsp[0].blk.b); yyval.blk = yyvsp[0].blk; }
    break;
}

#line 705 "/usr/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)