jamgram.c

C++的一个好库。。。现在很流行

    break;

  case 28:
#line 213 "jamgram.y"
    { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
    break;

  case 29:
#line 215 "jamgram.y"
    { yyval.parse = psetc( yyvsp[-2].string, yyvsp[0].parse, yyvsp[-1].parse, yyvsp[-4].number ); }
    break;

  case 30:
#line 217 "jamgram.y"
    { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
    break;

  case 31:
#line 219 "jamgram.y"
    { yymode( SCAN_STRING ); }
    break;

  case 32:
#line 221 "jamgram.y"
    { yymode( SCAN_NORMAL ); }
    break;

  case 33:
#line 223 "jamgram.y"
    { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
    break;

  case 34:
#line 231 "jamgram.y"
    { yyval.number = ASSIGN_SET; }
    break;

  case 35:
#line 233 "jamgram.y"
    { yyval.number = ASSIGN_APPEND; }
    break;

  case 36:
#line 235 "jamgram.y"
    { yyval.number = ASSIGN_DEFAULT; }
    break;

  case 37:
#line 237 "jamgram.y"
    { yyval.number = ASSIGN_DEFAULT; }
    break;

  case 38:
#line 244 "jamgram.y"
    { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); }
    break;

  case 39:
#line 246 "jamgram.y"
    { yyval.parse = peval( EXPR_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 40:
#line 248 "jamgram.y"
    { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 41:
#line 250 "jamgram.y"
    { yyval.parse = peval( EXPR_LESS, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 42:
#line 252 "jamgram.y"
    { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 43:
#line 254 "jamgram.y"
    { yyval.parse = peval( EXPR_MORE, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 44:
#line 256 "jamgram.y"
    { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 45:
#line 258 "jamgram.y"
    { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 46:
#line 260 "jamgram.y"
    { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 47:
#line 262 "jamgram.y"
    { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 48:
#line 264 "jamgram.y"
    { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 49:
#line 266 "jamgram.y"
    { yyval.parse = peval( EXPR_IN, yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 50:
#line 268 "jamgram.y"
    { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
    break;

  case 51:
#line 270 "jamgram.y"
    { yyval.parse = yyvsp[-1].parse; }
    break;

  case 52:
#line 281 "jamgram.y"
    { yyval.parse = P0; }
    break;

  case 53:
#line 283 "jamgram.y"
    { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
    break;

  case 54:
#line 287 "jamgram.y"
    { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
    break;

  case 55:
#line 296 "jamgram.y"
    { yyval.parse = pnode( P0, yyvsp[0].parse ); }
    break;

  case 56:
#line 298 "jamgram.y"
    { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
    break;

  case 57:
#line 308 "jamgram.y"
    { yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); }
    break;

  case 58:
#line 312 "jamgram.y"
    { yyval.parse = pnull(); yymode( SCAN_PUNCT ); }
    break;

  case 59:
#line 314 "jamgram.y"
    { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
    break;

  case 60:
#line 318 "jamgram.y"
    { yyval.parse = plist( yyvsp[0].string ); }
    break;

  case 61:
#line 319 "jamgram.y"
    { yymode( SCAN_NORMAL ); }
    break;

  case 62:
#line 320 "jamgram.y"
    { yyval.parse = yyvsp[-1].parse; }
    break;

  case 63:
#line 329 "jamgram.y"
    { yyval.parse = prule( yyvsp[-1].string, yyvsp[0].parse ); }
    break;

  case 64:
#line 331 "jamgram.y"
    { yyval.parse = pon( yyvsp[-2].parse, prule( yyvsp[-1].string, yyvsp[0].parse ) ); }
    break;

  case 65:
#line 333 "jamgram.y"
    { yyval.parse = pon( yyvsp[-2].parse, yyvsp[0].parse ); }
    break;

  case 66:
#line 343 "jamgram.y"
    { yyval.number = 0; }
    break;

  case 67:
#line 345 "jamgram.y"
    { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
    break;

  case 68:
#line 349 "jamgram.y"
    { yyval.number = EXEC_UPDATED; }
    break;

  case 69:
#line 351 "jamgram.y"
    { yyval.number = EXEC_TOGETHER; }
    break;

  case 70:
#line 353 "jamgram.y"
    { yyval.number = EXEC_IGNORE; }
    break;

  case 71:
#line 355 "jamgram.y"
    { yyval.number = EXEC_QUIETLY; }
    break;

  case 72:
#line 357 "jamgram.y"
    { yyval.number = EXEC_PIECEMEAL; }
    break;

  case 73:
#line 359 "jamgram.y"
    { yyval.number = EXEC_EXISTING; }
    break;

  case 74:
#line 368 "jamgram.y"
    { yyval.parse = pnull(); }
    break;

  case 75:
#line 370 "jamgram.y"
    { yyval.parse = yyvsp[0].parse; }
    break;


    }

/* Line 991 of yacc.c.  */
#line 1621 "y.tab.c"

  yyvsp -= yylen;
  yyssp -= yylen;


  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;


  /* 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 - YYNTOKENS] + *yyssp;
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTOKENS];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (YYPACT_NINF < yyn && yyn < YYLAST)
	{
	  YYSIZE_T yysize = 0;
	  int yytype = YYTRANSLATE (yychar);
	  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 && yyx != YYTERROR)
	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
	  yysize += yystrlen ("syntax error, unexpected ") + 1;
	  yysize += yystrlen (yytname[yytype]);
	  yymsg = (char *) YYSTACK_ALLOC (yysize);
	  if (yymsg != 0)
	    {
	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
	      yyp = yystpcpy (yyp, yytname[yytype]);

	      if (yycount < 5)
		{
		  yycount = 0;
		  for (yyx = yyn < 0 ? -yyn : 0;
		       yyx < (int) (sizeof (yytname) / sizeof (char *));
		       yyx++)
		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
		      {
			const char *yyq = ! yycount ? ", expecting " : " or ";
			yyp = yystpcpy (yyp, yyq);
			yyp = yystpcpy (yyp, yytname[yyx]);
			yycount++;
		      }
		}
	      yyerror (yymsg);
	      YYSTACK_FREE (yymsg);
	    }
	  else
	    yyerror ("syntax error; also virtual memory exhausted");
	}
      else
#endif /* YYERROR_VERBOSE */
	yyerror ("syntax error");
    }



  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)
        {
	  /* Pop the error token.  */
          YYPOPSTACK;
	  /* Pop the rest of the stack.  */
	  while (yyss < yyssp)
	    {
	      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
	      yydestruct (yystos[*yyssp], yyvsp);
	      YYPOPSTACK;
	    }
	  YYABORT;
        }

      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
      yydestruct (yytoken, &yylval);
      yychar = YYEMPTY;

    }

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


/*----------------------------------------------------.
| yyerrlab1 -- error raised explicitly by an action.  |
`----------------------------------------------------*/
yyerrlab1:

  /* Suppress GCC warning that yyerrlab1 is unused when no action
     invokes YYERROR.  */
#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)
  __attribute__ ((__unused__))
#endif


  goto yyerrlab2;


/*---------------------------------------------------------------.
| yyerrlab2 -- pop states until the error token can be shifted.  |
`---------------------------------------------------------------*/
yyerrlab2:
  yyerrstatus = 3;	/* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (yyn != YYPACT_NINF)
	{
	  yyn += YYTERROR;
	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
	    {
	      yyn = yytable[yyn];
	      if (0 < yyn)
		break;
	    }
	}

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
	YYABORT;

      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
      yydestruct (yystos[yystate], yyvsp);
      yyvsp--;
      yystate = *--yyssp;

      YY_STACK_PRINT (yyss, yyssp);
    }

  if (yyn == YYFINAL)
    YYACCEPT;

  YYDPRINTF ((stderr, "Shifting error token, "));

  *++yyvsp = yylval;


  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here.  |
`----------------------------------------------*/
yyoverflowlab:
  yyerror ("parser stack overflow");
  yyresult = 2;
  /* Fall through.  */
#endif

yyreturn:
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
  return yyresult;
}