自学教程：C++ yy_pop_parser_stack函数代码示例

/*** Deallocate and destroy a parser.  Destructors are all called for** all stack elements before shutting the parser down.**** Inputs:** <ul>** <li>  A pointer to the parser.  This should be a pointer**       obtained from configparserAlloc.** <li>  A pointer to a function used to reclaim memory obtained**       from malloc.** </ul>*/void configparserFree(  void *p,                    /* The parser to be deleted */  void (*freeProc)(void*)     /* Function used to reclaim memory */){  yyParser *pParser = (yyParser*)p;  if( pParser==0 ) return;  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);  (*freeProc)((void*)pParser);}

/* ** Deallocate and destroy a parser.  Destructors are all called for** all stack elements before shutting the parser down.**** Inputs:** <ul>** <li>  A pointer to the parser.  This should be a pointer**       obtained from ParseAlloc.** <li>  A pointer to a function used to reclaim memory obtained**       from malloc.** </ul>*/void ParseFree(  void *p,                    /* The parser to be deleted */  void (*freeProc)(void*)     /* Function used to reclaim memory */){  yyParser *pParser = (yyParser*)p;  if( pParser==0 ) return;  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);#if YYSTACKDEPTH<=0  free(pParser->yystack);#endif  (*freeProc)((void*)pParser);}

/* ** Deallocate and destroy a parser.  Destructors are called for** all stack elements before shutting the parser down.**** If the YYPARSEFREENEVERNULL macro exists (for example because it** is defined in a %include section of the input grammar) then it is** assumed that the input pointer is never NULL.*/void sqlite3Fts5ParserFree(  void *p,                    /* The parser to be deleted */  void (*freeProc)(void*)     /* Function used to reclaim memory */){  yyParser *pParser = (yyParser*)p;#ifndef YYPARSEFREENEVERNULL  if( pParser==0 ) return;#endif  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);#if YYSTACKDEPTH<=0  free(pParser->yystack);#endif  (*freeProc)((void*)pParser);}

/*** The following is executed when the parser accepts*/static void yy_accept(  yyParser *yypParser           /* The parser */){  configparserARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sAccept!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser accepts */  configparserARG_STORE; /* Suppress warning about unused %extra_argument variable */}

static void yy_parse_failed(  yyParser *yypParser           /* The parser */){  sqlite3Fts5ParserARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser fails *//************ Begin %parse_failure code ***************************************//************ End %parse_failure code *****************************************/  sqlite3Fts5ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following routine is called if the stack overflows.*/static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){   ParseARG_FETCH;   yypParser->yyidx--;#ifndef NDEBUG   if( yyTraceFILE ){     fprintf(yyTraceFILE,"%sStack Overflow!/n",yyTracePrompt);   }#endif   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);   /* Here code is inserted which will execute if the parser   ** stack every overflows */#line 33 "/home/veei/git/calculator/expressions.grammar.y"UNUSED_ARG(yypMinor); #line 655 "/home/veei/git/calculator/expressions.grammar.cpp"   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */}

static void yy_parse_failed(    yyParser *yypParser           /* The parser */) {    DSVariablePoolParserARG_FETCH;#ifndef NDEBUG    if( yyTraceFILE ) {        fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);    }#endif    while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);    /* Here code is inserted which will be executed whenever the    ** parser fails */    DSError(M_DS_PARSE ": Parsing failed", A_DS_ERROR);    DSVariablePoolParserARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following routine is called if the stack overflows.*/static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){   ParseARG_FETCH;   yypParser->yyidx--;#ifndef NDEBUG   if( yyTraceFILE ){     fprintf(yyTraceFILE,"%sStack Overflow!/n",yyTracePrompt);   }#endif   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);   /* Here code is inserted which will execute if the parser   ** stack every overflows */#line 24 "src/parser.y"    log_err("There was a stack overflow at line: %d", state->line_number);#line 616 "src/parser.c"   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */}

/*** The following routine is called if the stack overflows.*/static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){   ParseARG_FETCH;   yypParser->yyidx--;#ifndef NDEBUG   if( yyTraceFILE ){     fprintf(yyTraceFILE,"%sStack Overflow!/n",yyTracePrompt);   }#endif   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);   /* Here code is inserted which will execute if the parser   ** stack every overflows */#line 34 "grammar.y"    printf("Stack overflowed, you suck after line: %u./n", state->curline);#line 591 "grammar.c"   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */}

static void yy_parse_failed(  yyParser *yypParser           /* The parser */){  ParseARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser fails */#line 17 "/home/veei/git/calculator/expressions.grammar.y"    state->syntax_error = 1;#line 1098 "/home/veei/git/calculator/expressions.grammar.cpp"  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */}

static void yy_parse_failed(  yyParser *yypParser           /* The parser */){  ParseARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser fails */#line 56 "parser.y"  result->error_type = Result::PARSE_ERROR;#line 850 "parser.c"  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following code executes when the parse fails*/static void yy_parse_failed(  yyParser *yypParser           /* The parser */){  lcn_query_parser_ARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser fails */#line 78 "query_parser.y"    info->status = LCN_ERR_QUERY_PARSER_SYNTAX_ERROR;#line 808 "query_parser.c"  lcn_query_parser_ARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following routine is called if the stack overflows.*/static void yyStackOverflow(yyParser *yypParser){   sqlite3Fts5ParserARG_FETCH;   yypParser->yyidx--;#ifndef NDEBUG   if( yyTraceFILE ){     fprintf(yyTraceFILE,"%sStack Overflow!/n",yyTracePrompt);   }#endif   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);   /* Here code is inserted which will execute if the parser   ** stack every overflows *//******** Begin %stack_overflow code ******************************************/#line 36 "fts5parse.y"  sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");#line 697 "fts5parse.c"/******** End %stack_overflow code ********************************************/   sqlite3Fts5ParserARG_STORE; /* Suppress warning about unused %extra_argument var */}

/*** The following code executes when the parse fails*/static void yy_parse_failed(  yyParser *yypParser           /* The parser */){  ssiexprparserARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sFail!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser fails */#line 14 "./mod_ssi_exprparser.y"  ctx->ok = 0;#line 771 "mod_ssi_exprparser.c"  ssiexprparserARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following is executed when the parser accepts*/static void yy_accept(  yyParser *yypParser           /* The parser */){  ParseARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sAccept!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser accepts */#line 68 "parser.y"  if (result->error_type == Result::NOT_ACCEPTED) {    result->error_type = Result::ACCEPTED;  }#line 892 "parser.c"  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** The following is executed when the parser accepts*/static void yy_accept(  yyParser *yypParser           /* The parser */){  ParseARG_FETCH;#ifndef NDEBUG  if( yyTraceFILE ){    fprintf(yyTraceFILE,"%sAccept!/n",yyTracePrompt);  }#endif  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);  /* Here code is inserted which will be executed whenever the  ** parser accepts *//*********** Begin %parse_accept code *****************************************/#line 37 "grammar.lemon"  pEval->parseOk();#line 895 "grammar.c"/*********** End %parse_accept code *******************************************/  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */}

/*** Perform a shift action.*/static void yy_shift(  yyParser *yypParser,          /* The parser to be shifted */  int yyNewState,               /* The new state to shift in */  int yyMajor,                  /* The major token to shift in */  YYMINORTYPE *yypMinor         /* Pointer ot the minor token to shift in */){  yyStackEntry *yytos;  yypParser->yyidx++;  if( yypParser->yyidx>=YYSTACKDEPTH ){     configparserARG_FETCH;     yypParser->yyidx--;#ifndef NDEBUG     if( yyTraceFILE ){       fprintf(yyTraceFILE,"%sStack Overflow!/n",yyTracePrompt);     }#endif     while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);     /* Here code is inserted which will execute if the parser     ** stack every overflows */     configparserARG_STORE; /* Suppress warning about unused %extra_argument var */     return;  }  yytos = &yypParser->yystack[yypParser->yyidx];  yytos->stateno = yyNewState;  yytos->major = yyMajor;  yytos->minor = *yypMinor;#ifndef NDEBUG  if( yyTraceFILE && yypParser->yyidx>0 ){    int i;    fprintf(yyTraceFILE,"%sShift %d/n",yyTracePrompt,yyNewState);    fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);    for(i=1; i<=yypParser->yyidx; i++)      fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);    fprintf(yyTraceFILE,"/n");  }#endif}

//.........这里部分代码省略.........  do{    yyact = yy_find_shift_action(yypParser,yymajor);    if( yyact<YYNSTATE ){      yy_shift(yypParser,yyact,yymajor,&yyminorunion);      yypParser->yyerrcnt--;      if( yyendofinput && yypParser->yyidx>=0 ){        yymajor = 0;      }else{        yymajor = YYNOCODE;      }    }else if( yyact < YYNSTATE + YYNRULE ){      yy_reduce(yypParser,yyact-YYNSTATE);    }else if( yyact == YY_ERROR_ACTION ){      int yymx;#ifndef NDEBUG      if( yyTraceFILE ){        fprintf(yyTraceFILE,"%sSyntax Error!/n",yyTracePrompt);      }#endif#ifdef YYERRORSYMBOL      /* A syntax error has occurred.      ** The response to an error depends upon whether or not the      ** grammar defines an error token "ERROR".      **      ** This is what we do if the grammar does define ERROR:      **      **  * Call the %syntax_error function.      **      **  * Begin popping the stack until we enter a state where      **    it is legal to shift the error symbol, then shift      **    the error symbol.      **      **  * Set the error count to three.      **      **  * Begin accepting and shifting new tokens.  No new error      **    processing will occur until three tokens have been      **    shifted successfully.      **      */      if( yypParser->yyerrcnt<0 ){        yy_syntax_error(yypParser,yymajor,yyminorunion);      }      yymx = yypParser->yystack[yypParser->yyidx].major;      if( yymx==YYERRORSYMBOL || yyerrorhit ){#ifndef NDEBUG        if( yyTraceFILE ){          fprintf(yyTraceFILE,"%sDiscard input token %s/n",             yyTracePrompt,yyTokenName[yymajor]);        }#endif        yy_destructor(yymajor,&yyminorunion);        yymajor = YYNOCODE;      }else{         while(          yypParser->yyidx >= 0 &&          yymx != YYERRORSYMBOL &&          (yyact = yy_find_shift_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE        ){          yy_pop_parser_stack(yypParser);        }        if( yypParser->yyidx < 0 || yymajor==0 ){          yy_destructor(yymajor,&yyminorunion);          yy_parse_failed(yypParser);          yymajor = YYNOCODE;        }else if( yymx!=YYERRORSYMBOL ){          YYMINORTYPE u2;          u2.YYERRSYMDT = 0;          yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);        }      }      yypParser->yyerrcnt = 3;      yyerrorhit = 1;#else  /* YYERRORSYMBOL is not defined */      /* This is what we do if the grammar does not define ERROR:      **      **  * Report an error message, and throw away the input token.      **      **  * If the input token is $, then fail the parse.      **      ** As before, subsequent error messages are suppressed until      ** three input tokens have been successfully shifted.      */      if( yypParser->yyerrcnt<=0 ){        yy_syntax_error(yypParser,yymajor,yyminorunion);      }      yypParser->yyerrcnt = 3;      yy_destructor(yymajor,&yyminorunion);      if( yyendofinput ){        yy_parse_failed(yypParser);      }      yymajor = YYNOCODE;#endif    }else{      yy_accept(yypParser);      yymajor = YYNOCODE;    }  }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );  return;}

//.........这里部分代码省略.........		 ** This is what we do if the grammar does define ERROR:		 **		 **  * Call the %syntax_error function.		 **		 **  * Begin popping the stack until we enter a state where		 **    it is legal to shift the error symbol, then shift		 **    the error symbol.		 **		 **  * Set the error count to three.		 **		 **  * Begin accepting and shifting new tokens.  No new error		 **    processing will occur until three tokens have been		 **    shifted successfully.		 **		 */		if (yypParser->yyerrcnt < 0)		  {		      yy_syntax_error (yypParser, yymajor, yyminorunion);		  }		yymx = yypParser->yystack[yypParser->yyidx].major;		if (yymx == YYERRORSYMBOL || yyerrorhit)		  {#ifndef NDEBUG		      if (yyTraceFILE)			{			    fprintf (yyTraceFILE, "%sDiscard input token %s/n",				     yyTracePrompt, yyTokenName[yymajor]);			}#endif		      yy_destructor (yypParser, (YYCODETYPE) yymajor,				     &yyminorunion);		      yymajor = YYNOCODE;		  }		else		  {		      while (yypParser->yyidx >= 0 &&			     yymx != YYERRORSYMBOL &&			     (yyact =			      yy_find_reduce_action (yypParser->yystack						     [yypParser->yyidx].stateno,						     YYERRORSYMBOL)) >=			     YYNSTATE)			{			    yy_pop_parser_stack (yypParser);			}		      if (yypParser->yyidx < 0 || yymajor == 0)			{			    yy_destructor (yypParser, (YYCODETYPE) yymajor,					   &yyminorunion);			    yy_parse_failed (yypParser);			    yymajor = YYNOCODE;			}		      else if (yymx != YYERRORSYMBOL)			{			    YYMINORTYPE u2;			    u2.YYERRSYMDT = 0;			    yy_shift (yypParser, yyact, YYERRORSYMBOL, &u2);			}		  }		yypParser->yyerrcnt = 3;		yyerrorhit = 1;#elif defined(YYNOERRORRECOVERY)		/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to		 ** do any kind of error recovery.  Instead, simply invoke the syntax		 ** error routine and continue going as if nothing had happened.		 **		 ** Applications can set this macro (for example inside %include) if		 ** they intend to abandon the parse upon the first syntax error seen.		 */		yy_syntax_error (yypParser, yymajor, yyminorunion);		yy_destructor (yypParser, (YYCODETYPE) yymajor, &yyminorunion);		yymajor = YYNOCODE;#else /* YYERRORSYMBOL is not defined */		/* This is what we do if the grammar does not define ERROR:		 **		 **  * Report an error message, and throw away the input token.		 **		 **  * If the input token is $, then fail the parse.		 **		 ** As before, subsequent error messages are suppressed until		 ** three input tokens have been successfully shifted.		 */		if (yypParser->yyerrcnt <= 0)		  {		      yy_syntax_error (yypParser, yymajor, yyminorunion);		  }		yypParser->yyerrcnt = 3;		yy_destructor (yypParser, (YYCODETYPE) yymajor, &yyminorunion);		if (yyendofinput)		  {		      yy_parse_failed (yypParser);		  }		yymajor = YYNOCODE;#endif	    }      }    while (yymajor != YYNOCODE && yypParser->yyidx >= 0);    return;}