ssl_expr_parse.c

最新apache的源代码

  switch (ssl_expr_yyn) {

case 1:
#line 115 "ssl_expr_parse.y"
{ ssl_expr_info.expr = ssl_expr_yyvsp[0].exVal; ;
    break;}
case 2:
#line 118 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_True,  NULL, NULL); ;
    break;}
case 3:
#line 119 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_False, NULL, NULL); ;
    break;}
case 4:
#line 120 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Not,   ssl_expr_yyvsp[0].exVal,   NULL); ;
    break;}
case 5:
#line 121 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Or,    ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   ;
    break;}
case 6:
#line 122 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_And,   ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   ;
    break;}
case 7:
#line 123 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Comp,  ssl_expr_yyvsp[0].exVal,   NULL); ;
    break;}
case 8:
#line 124 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal; ;
    break;}
case 9:
#line 127 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_EQ,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 10:
#line 128 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_NE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 11:
#line 129 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_LT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 12:
#line 130 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_LE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 13:
#line 131 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_GT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 14:
#line 132 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_GE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 15:
#line 133 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_IN,  ssl_expr_yyvsp[-4].exVal, ssl_expr_yyvsp[-1].exVal); ;
    break;}
case 16:
#line 134 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_REG, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 17:
#line 135 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_NRE, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
    break;}
case 18:
#line 138 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, NULL); ;
    break;}
case 19:
#line 139 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, ssl_expr_yyvsp[-2].exVal);   ;
    break;}
case 20:
#line 142 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Digit,  ssl_expr_yyvsp[0].cpVal, NULL); ;
    break;}
case 21:
#line 143 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_String, ssl_expr_yyvsp[0].cpVal, NULL); ;
    break;}
case 22:
#line 144 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Var,    ssl_expr_yyvsp[-1].cpVal, NULL); ;
    break;}
case 23:
#line 145 "ssl_expr_parse.y"
{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[0].exVal; ;
    break;}
case 24:
#line 148 "ssl_expr_parse.y"
{ 
                regex_t *regex;
                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal, 
                                         REG_EXTENDED|REG_NOSUB)) == NULL) {
                    ssl_expr_error = "Failed to compile regular expression";
                    YYERROR;
                    regex = NULL;
                }
                ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
            ;
    break;}
case 25:
#line 158 "ssl_expr_parse.y"
{
                regex_t *regex;
                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal, 
                                         REG_EXTENDED|REG_NOSUB|REG_ICASE)) == NULL) {
                    ssl_expr_error = "Failed to compile regular expression";
                    YYERROR;
                    regex = NULL;
                }
                ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
            ;
    break;}
case 26:
#line 170 "ssl_expr_parse.y"
{ 
               ssl_expr *args = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[-1].cpVal, NULL);
               ssl_expr_yyval.exVal = ssl_expr_make(op_Func, "file", args);
            ;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 543 "/usr/local/share/bison.simple"

  ssl_expr_yyvsp -= ssl_expr_yylen;
  ssl_expr_yyssp -= ssl_expr_yylen;
#ifdef YYLSP_NEEDED
  ssl_expr_yylsp -= ssl_expr_yylen;
#endif

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

  *++ssl_expr_yyvsp = ssl_expr_yyval;

#ifdef YYLSP_NEEDED
  ssl_expr_yylsp++;
  if (ssl_expr_yylen == 0)
    {
      ssl_expr_yylsp->first_line = ssl_expr_yylloc.first_line;
      ssl_expr_yylsp->first_column = ssl_expr_yylloc.first_column;
      ssl_expr_yylsp->last_line = (ssl_expr_yylsp-1)->last_line;
      ssl_expr_yylsp->last_column = (ssl_expr_yylsp-1)->last_column;
      ssl_expr_yylsp->text = 0;
    }
  else
    {
      ssl_expr_yylsp->last_line = (ssl_expr_yylsp+ssl_expr_yylen-1)->last_line;
      ssl_expr_yylsp->last_column = (ssl_expr_yylsp+ssl_expr_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.  */

  ssl_expr_yyn = ssl_expr_yyr1[ssl_expr_yyn];

  ssl_expr_yystate = ssl_expr_yypgoto[ssl_expr_yyn - YYNTBASE] + *ssl_expr_yyssp;
  if (ssl_expr_yystate >= 0 && ssl_expr_yystate <= YYLAST && ssl_expr_yycheck[ssl_expr_yystate] == *ssl_expr_yyssp)
    ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yystate];
  else
    ssl_expr_yystate = ssl_expr_yydefgoto[ssl_expr_yyn - YYNTBASE];

  goto ssl_expr_yynewstate;

ssl_expr_yyerrlab:   /* here on detecting error */

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

#ifdef YYERROR_VERBOSE
      ssl_expr_yyn = ssl_expr_yypact[ssl_expr_yystate];

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

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

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

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

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

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

#if YYDEBUG != 0
      if (ssl_expr_yydebug)
	fprintf(stderr, "Discarding token %d (%s).\n", ssl_expr_yychar, ssl_expr_yytname[ssl_expr_yychar1]);
#endif

      ssl_expr_yychar = YYEMPTY;
    }

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

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

  goto ssl_expr_yyerrhandle;

ssl_expr_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.  */
  ssl_expr_yyn = ssl_expr_yydefact[ssl_expr_yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (ssl_expr_yyn) goto ssl_expr_yydefault;
#endif

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

  if (ssl_expr_yyssp == ssl_expr_yyss) YYABORT;
  ssl_expr_yyvsp--;
  ssl_expr_yystate = *--ssl_expr_yyssp;
#ifdef YYLSP_NEEDED
  ssl_expr_yylsp--;
#endif

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

ssl_expr_yyerrhandle:

  ssl_expr_yyn = ssl_expr_yypact[ssl_expr_yystate];
  if (ssl_expr_yyn == YYFLAG)
    goto ssl_expr_yyerrdefault;

  ssl_expr_yyn += YYTERROR;
  if (ssl_expr_yyn < 0 || ssl_expr_yyn > YYLAST || ssl_expr_yycheck[ssl_expr_yyn] != YYTERROR)
    goto ssl_expr_yyerrdefault;

  ssl_expr_yyn = ssl_expr_yytable[ssl_expr_yyn];
  if (ssl_expr_yyn < 0)
    {
      if (ssl_expr_yyn == YYFLAG)
	goto ssl_expr_yyerrpop;
      ssl_expr_yyn = -ssl_expr_yyn;
      goto ssl_expr_yyreduce;
    }
  else if (ssl_expr_yyn == 0)
    goto ssl_expr_yyerrpop;

  if (ssl_expr_yyn == YYFINAL)
    YYACCEPT;

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

  *++ssl_expr_yyvsp = ssl_expr_yylval;
#ifdef YYLSP_NEEDED
  *++ssl_expr_yylsp = ssl_expr_yylloc;
#endif

  ssl_expr_yystate = ssl_expr_yyn;
  goto ssl_expr_yynewstate;

 ssl_expr_yyacceptlab:
  /* YYACCEPT comes here.  */
  if (ssl_expr_yyfree_stacks)
    {
      free (ssl_expr_yyss);
      free (ssl_expr_yyvs);
#ifdef YYLSP_NEEDED
      free (ssl_expr_yyls);
#endif
    }
  return 0;

 ssl_expr_yyabortlab:
  /* YYABORT comes here.  */
  if (ssl_expr_yyfree_stacks)
    {
      free (ssl_expr_yyss);
      free (ssl_expr_yyvs);
#ifdef YYLSP_NEEDED
      free (ssl_expr_yyls);
#endif
    }
  return 1;
}
#line 176 "ssl_expr_parse.y"


int ssl_expr_yyerror(char *s)
{
    ssl_expr_error = s;
    return 2;
}