forked from osmocom/wireshark
Lemon: resync with upstream
lemon: Tue Aug 16 16:46:40 2016 lempar: Tue Dec 6 17:59:05 2016 +0000 a copy of all Wireshark changes are available https://github.com/alagoutte/sqlite/tree/wireshark Change-Id: I144d0f983e4ac960b5a7a2fd8cd379f6282579f8 Reviewed-on: https://code.wireshark.org/review/15987 Reviewed-by: Alexis La Goutte <alexis.lagoutte@gmail.com> Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com> Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org> Reviewed-by: Michael Mann <mmann78@netscape.net>
This commit is contained in:
Alexis La Goutte
Michael Mann
parent
d98a3cbf2f
commit
60551ea55a
|
|
@ -269,7 +269,8 @@ struct symbol {
|
|||
int useCnt; /* Number of times used */
|
||||
char *destructor; /* Code which executes whenever this symbol is
|
||||
** popped from the stack during error processing */
|
||||
int destLineno; /* Line number for start of destructor */
|
||||
int destLineno; /* Line number for start of destructor. Set to
|
||||
** -1 for duplicate destructors. */
|
||||
char *datatype; /* The data type of information held by this
|
||||
** object. Only used if type==NONTERMINAL */
|
||||
int dtnum; /* The data type number. In the parser, the value
|
||||
|
|
@ -292,9 +293,15 @@ struct rule {
|
|||
const char **rhsalias; /* An alias for each RHS symbol (NULL if none) */
|
||||
int line; /* Line number at which code begins */
|
||||
const char *code; /* The code executed when this rule is reduced */
|
||||
const char *codePrefix; /* Setup code before code[] above */
|
||||
const char *codeSuffix; /* Breakdown code after code[] above */
|
||||
int noCode; /* True if this rule has no associated C code */
|
||||
int codeEmitted; /* True if the code has been emitted already */
|
||||
struct symbol *precsym; /* Precedence symbol for this rule */
|
||||
int index; /* An index number for this rule */
|
||||
int iRule; /* Rule number as used in the generated tables */
|
||||
Boolean canReduce; /* True if this rule is ever reduced */
|
||||
Boolean doesReduce; /* Reduce actions occur after optimization */
|
||||
struct rule *nextlhs; /* Next rule with the same LHS */
|
||||
struct rule *next; /* Next rule in the global list */
|
||||
};
|
||||
|
|
@ -342,6 +349,7 @@ struct action {
|
|||
struct state *stp; /* The new state, if a shift */
|
||||
struct rule *rp; /* The rule, if a reduce */
|
||||
} x;
|
||||
struct symbol *spOpt; /* SHIFTREDUCE optimization to this symbol */
|
||||
struct action *next; /* Next action for this state */
|
||||
struct action *collide; /* Next action with the same hash */
|
||||
};
|
||||
|
|
@ -352,7 +360,7 @@ struct state {
|
|||
struct config *bp; /* The basis configurations for this state */
|
||||
struct config *cfp; /* All configurations in this set */
|
||||
int statenum; /* Sequential number for this state */
|
||||
struct action *ap; /* Array of actions for this state */
|
||||
struct action *ap; /* List of actions for this state */
|
||||
int nTknAct, nNtAct; /* Number of actions on terminals and nonterminals */
|
||||
int iTknOfst, iNtOfst; /* yy_action[] offset for terminals and nonterms */
|
||||
int iDfltReduce; /* Default action is to REDUCE by this rule */
|
||||
|
|
@ -376,6 +384,7 @@ struct plink {
|
|||
struct lemon {
|
||||
struct state **sorted; /* Table of states sorted by state number */
|
||||
struct rule *rule; /* List of all rules */
|
||||
struct rule *startRule; /* First rule */
|
||||
int nstate; /* Number of states */
|
||||
int nxstate; /* nstate with tail degenerate states removed */
|
||||
int nrule; /* Number of rules */
|
||||
|
|
@ -533,6 +542,7 @@ PRIVATE void Action_add(
|
|||
*app = newaction;
|
||||
newaction->type = type;
|
||||
newaction->sp = sp;
|
||||
newaction->spOpt = 0;
|
||||
if( type==SHIFT ){
|
||||
newaction->x.stp = (struct state *)arg;
|
||||
}else{
|
||||
|
|
@ -859,12 +869,12 @@ void FindStates(struct lemon *lemp)
|
|||
ErrorMsg(lemp->filename,0,
|
||||
"The specified start symbol \"%s\" is not \
|
||||
in a nonterminal of the grammar. \"%s\" will be used as the start \
|
||||
symbol instead.",lemp->start,lemp->rule->lhs->name);
|
||||
symbol instead.",lemp->start,lemp->startRule->lhs->name);
|
||||
lemp->errorcnt++;
|
||||
sp = lemp->rule->lhs;
|
||||
sp = lemp->startRule->lhs;
|
||||
}
|
||||
}else{
|
||||
sp = lemp->rule->lhs;
|
||||
sp = lemp->startRule->lhs;
|
||||
}
|
||||
|
||||
/* Make sure the start symbol doesn't occur on the right-hand side of
|
||||
|
|
@ -1128,9 +1138,9 @@ void FindActions(struct lemon *lemp)
|
|||
/* Add the accepting token */
|
||||
if( lemp->start ){
|
||||
sp = Symbol_find(lemp->start);
|
||||
if( sp==0 ) sp = lemp->rule->lhs;
|
||||
if( sp==0 ) sp = lemp->startRule->lhs;
|
||||
}else{
|
||||
sp = lemp->rule->lhs;
|
||||
sp = lemp->startRule->lhs;
|
||||
}
|
||||
/* Add to the first state (which is always the starting state of the
|
||||
** finite state machine) an action to ACCEPT if the lookahead is the
|
||||
|
|
@ -1531,6 +1541,54 @@ static void handle_T_option(void *arg){
|
|||
lemon_strcpy(user_templatename, z);
|
||||
}
|
||||
|
||||
/* Merge together to lists of rules ordered by rule.iRule */
|
||||
static struct rule *Rule_merge(struct rule *pA, struct rule *pB){
|
||||
struct rule *pFirst = 0;
|
||||
struct rule **ppPrev = &pFirst;
|
||||
while( pA && pB ){
|
||||
if( pA->iRule<pB->iRule ){
|
||||
*ppPrev = pA;
|
||||
ppPrev = &pA->next;
|
||||
pA = pA->next;
|
||||
}else{
|
||||
*ppPrev = pB;
|
||||
ppPrev = &pB->next;
|
||||
pB = pB->next;
|
||||
}
|
||||
}
|
||||
if( pA ){
|
||||
*ppPrev = pA;
|
||||
}else{
|
||||
*ppPrev = pB;
|
||||
}
|
||||
return pFirst;
|
||||
}
|
||||
|
||||
/*
|
||||
** Sort a list of rules in order of increasing iRule value
|
||||
*/
|
||||
static struct rule *Rule_sort(struct rule *rp){
|
||||
unsigned int i;
|
||||
struct rule *pNext;
|
||||
struct rule *x[32];
|
||||
memset(x, 0, sizeof(x));
|
||||
while( rp ){
|
||||
pNext = rp->next;
|
||||
rp->next = 0;
|
||||
for(i=0; i<sizeof(x)/sizeof(x[0]) && x[i]; i++){
|
||||
rp = Rule_merge(x[i], rp);
|
||||
x[i] = 0;
|
||||
}
|
||||
x[i] = rp;
|
||||
rp = pNext;
|
||||
}
|
||||
rp = 0;
|
||||
for(i=0; i<sizeof(x)/sizeof(x[0]); i++){
|
||||
rp = Rule_merge(x[i], rp);
|
||||
}
|
||||
return rp;
|
||||
}
|
||||
|
||||
/* forward reference */
|
||||
static const char *minimum_size_type(int lwr, int upr, int *pnByte);
|
||||
|
||||
|
|
@ -1579,6 +1637,7 @@ int main(int argc _U_, char **argv)
|
|||
int i;
|
||||
int exitcode;
|
||||
struct lemon lem;
|
||||
struct rule *rp;
|
||||
|
||||
OptInit(argv,options,stderr);
|
||||
if( version ){
|
||||
|
|
@ -1628,6 +1687,19 @@ int main(int argc _U_, char **argv)
|
|||
for(i=1; ISUPPER(lem.symbols[i]->name[0]); i++);
|
||||
lem.nterminal = i;
|
||||
|
||||
/* Assign sequential rule numbers. Start with 0. Put rules that have no
|
||||
** reduce action C-code associated with them last, so that the switch()
|
||||
** statement that selects reduction actions will have a smaller jump table.
|
||||
*/
|
||||
for(i=0, rp=lem.rule; rp; rp=rp->next){
|
||||
rp->iRule = rp->code ? i++ : -1;
|
||||
}
|
||||
for(rp=lem.rule; rp; rp=rp->next){
|
||||
if( rp->iRule<0 ) rp->iRule = i++;
|
||||
}
|
||||
lem.startRule = lem.rule;
|
||||
lem.rule = Rule_sort(lem.rule);
|
||||
|
||||
/* Generate a reprint of the grammar, if requested on the command line */
|
||||
if( rpflag ){
|
||||
Reprint(&lem);
|
||||
|
|
@ -2187,6 +2259,7 @@ to follow the previous rule.");
|
|||
}else{
|
||||
psp->prevrule->line = psp->tokenlineno;
|
||||
psp->prevrule->code = &x[1];
|
||||
psp->prevrule->noCode = 0;
|
||||
}
|
||||
}else if( x[0]=='[' ){
|
||||
psp->state = PRECEDENCE_MARK_1;
|
||||
|
|
@ -2293,6 +2366,7 @@ to follow the previous rule.");
|
|||
rp->lhsalias = psp->lhsalias;
|
||||
rp->nrhs = psp->nrhs;
|
||||
rp->code = 0;
|
||||
rp->noCode = 1;
|
||||
rp->precsym = 0;
|
||||
rp->index = psp->gp->nrule++;
|
||||
rp->nextlhs = rp->lhs->rule;
|
||||
|
|
@ -3107,13 +3181,13 @@ PRIVATE int PrintAction(
|
|||
}
|
||||
case REDUCE: {
|
||||
struct rule *rp = ap->x.rp;
|
||||
fprintf(fp,"%*s reduce %-7d",indent,ap->sp->name,rp->index);
|
||||
fprintf(fp,"%*s reduce %-7d",indent,ap->sp->name,rp->iRule);
|
||||
RulePrint(fp, rp, -1);
|
||||
break;
|
||||
}
|
||||
case SHIFTREDUCE: {
|
||||
struct rule *rp = ap->x.rp;
|
||||
fprintf(fp,"%*s shift-reduce %-7d",indent,ap->sp->name,rp->index);
|
||||
fprintf(fp,"%*s shift-reduce %-7d",indent,ap->sp->name,rp->iRule);
|
||||
RulePrint(fp, rp, -1);
|
||||
break;
|
||||
}
|
||||
|
|
@ -3126,7 +3200,7 @@ PRIVATE int PrintAction(
|
|||
case SRCONFLICT:
|
||||
case RRCONFLICT:
|
||||
fprintf(fp,"%*s reduce %-7d ** Parsing conflict **",
|
||||
indent,ap->sp->name,ap->x.rp->index);
|
||||
indent,ap->sp->name,ap->x.rp->iRule);
|
||||
break;
|
||||
case SSCONFLICT:
|
||||
fprintf(fp,"%*s shift %-7d ** Parsing conflict **",
|
||||
|
|
@ -3143,7 +3217,7 @@ PRIVATE int PrintAction(
|
|||
case RD_RESOLVED:
|
||||
if( showPrecedenceConflict ){
|
||||
fprintf(fp,"%*s reduce %-7d -- dropped by precedence",
|
||||
indent,ap->sp->name,ap->x.rp->index);
|
||||
indent,ap->sp->name,ap->x.rp->iRule);
|
||||
}else{
|
||||
result = 0;
|
||||
}
|
||||
|
|
@ -3152,6 +3226,9 @@ PRIVATE int PrintAction(
|
|||
result = 0;
|
||||
break;
|
||||
}
|
||||
if( result && ap->spOpt ){
|
||||
fprintf(fp," /* because %s==%s */", ap->sp->name, ap->spOpt->name);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -3175,7 +3252,7 @@ void ReportOutput(struct lemon *lemp)
|
|||
while( cfp ){
|
||||
char buf[20];
|
||||
if( cfp->dot==cfp->rp->nrhs ){
|
||||
lemon_sprintf(buf,"(%d)",cfp->rp->index);
|
||||
lemon_sprintf(buf,"(%d)",cfp->rp->iRule);
|
||||
fprintf(fp," %5s ",buf);
|
||||
}else{
|
||||
fprintf(fp," ");
|
||||
|
|
@ -3280,8 +3357,8 @@ PRIVATE int compute_action(struct lemon *lemp, struct action *ap)
|
|||
int act;
|
||||
switch( ap->type ){
|
||||
case SHIFT: act = ap->x.stp->statenum; break;
|
||||
case SHIFTREDUCE: act = ap->x.rp->index + lemp->nstate; break;
|
||||
case REDUCE: act = ap->x.rp->index + lemp->nstate+lemp->nrule; break;
|
||||
case SHIFTREDUCE: act = ap->x.rp->iRule + lemp->nstate; break;
|
||||
case REDUCE: act = ap->x.rp->iRule + lemp->nstate+lemp->nrule; break;
|
||||
case ERROR: act = lemp->nstate + lemp->nrule*2; break;
|
||||
case ACCEPT: act = lemp->nstate + lemp->nrule*2 + 1; break;
|
||||
default: act = -1; break;
|
||||
|
|
@ -3494,6 +3571,7 @@ PRIVATE char *append_str(const char *zText, int n, int p1, int p2){
|
|||
int c;
|
||||
char zInt[40];
|
||||
if( zText==0 ){
|
||||
if( used==0 && z!=0 ) z[0] = 0;
|
||||
used = 0;
|
||||
return z;
|
||||
}
|
||||
|
|
@ -3528,15 +3606,23 @@ PRIVATE char *append_str(const char *zText, int n, int p1, int p2){
|
|||
}
|
||||
|
||||
/*
|
||||
** zCode is a string that is the action associated with a rule. Expand
|
||||
** the symbols in this string so that the refer to elements of the parser
|
||||
** stack.
|
||||
** Write and transform the rp->code string so that symbols are expanded.
|
||||
** Populate the rp->codePrefix and rp->codeSuffix strings, as appropriate.
|
||||
**
|
||||
** Return 1 if the expanded code requires that "yylhsminor" local variable
|
||||
** to be defined.
|
||||
*/
|
||||
PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){
|
||||
PRIVATE int translate_code(struct lemon *lemp, struct rule *rp){
|
||||
char *cp, *xp;
|
||||
int i;
|
||||
char lhsused = 0; /* True if the LHS element has been used */
|
||||
char used[MAXRHS]; /* True for each RHS element which is used */
|
||||
int rc = 0; /* True if yylhsminor is used */
|
||||
int dontUseRhs0 = 0; /* If true, use of left-most RHS label is illegal */
|
||||
const char *zSkip = 0; /* The zOvwrt comment within rp->code, or NULL */
|
||||
char lhsused = 0; /* True if the LHS element has been used */
|
||||
char lhsdirect; /* True if LHS writes directly into stack */
|
||||
char used[MAXRHS]; /* True for each RHS element which is used */
|
||||
char zLhs[50]; /* Convert the LHS symbol into this string */
|
||||
char zOvwrt[900]; /* Comment that to allow LHS to overwrite RHS */
|
||||
|
||||
for(i=0; i<rp->nrhs; i++) used[i] = 0;
|
||||
lhsused = 0;
|
||||
|
|
@ -3545,25 +3631,89 @@ PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){
|
|||
static char newlinestr[2] = { '\n', '\0' };
|
||||
rp->code = newlinestr;
|
||||
rp->line = rp->ruleline;
|
||||
rp->noCode = 1;
|
||||
}else{
|
||||
rp->noCode = 0;
|
||||
}
|
||||
|
||||
|
||||
if( rp->nrhs==0 ){
|
||||
/* If there are no RHS symbols, then writing directly to the LHS is ok */
|
||||
lhsdirect = 1;
|
||||
}else if( rp->rhsalias[0]==0 ){
|
||||
/* The left-most RHS symbol has no value. LHS direct is ok. But
|
||||
** we have to call the distructor on the RHS symbol first. */
|
||||
lhsdirect = 1;
|
||||
if( has_destructor(rp->rhs[0],lemp) ){
|
||||
append_str(0,0,0,0);
|
||||
append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
|
||||
rp->rhs[0]->index,1-rp->nrhs);
|
||||
rp->codePrefix = Strsafe(append_str(0,0,0,0));
|
||||
rp->noCode = 0;
|
||||
}
|
||||
}else if( rp->lhsalias==0 ){
|
||||
/* There is no LHS value symbol. */
|
||||
lhsdirect = 1;
|
||||
}else if( strcmp(rp->lhsalias,rp->rhsalias[0])==0 ){
|
||||
/* The LHS symbol and the left-most RHS symbol are the same, so
|
||||
** direct writing is allowed */
|
||||
lhsdirect = 1;
|
||||
lhsused = 1;
|
||||
used[0] = 1;
|
||||
if( rp->lhs->dtnum!=rp->rhs[0]->dtnum ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"%s(%s) and %s(%s) share the same label but have "
|
||||
"different datatypes.",
|
||||
rp->lhs->name, rp->lhsalias, rp->rhs[0]->name, rp->rhsalias[0]);
|
||||
lemp->errorcnt++;
|
||||
}
|
||||
}else{
|
||||
lemon_sprintf(zOvwrt, "/*%s-overwrites-%s*/",
|
||||
rp->lhsalias, rp->rhsalias[0]);
|
||||
zSkip = strstr(rp->code, zOvwrt);
|
||||
if( zSkip!=0 ){
|
||||
/* The code contains a special comment that indicates that it is safe
|
||||
** for the LHS label to overwrite left-most RHS label. */
|
||||
lhsdirect = 1;
|
||||
}else{
|
||||
lhsdirect = 0;
|
||||
}
|
||||
}
|
||||
if( lhsdirect ){
|
||||
sprintf(zLhs, "yymsp[%d].minor.yy%d",1-rp->nrhs,rp->lhs->dtnum);
|
||||
}else{
|
||||
rc = 1;
|
||||
sprintf(zLhs, "yylhsminor.yy%d",rp->lhs->dtnum);
|
||||
}
|
||||
|
||||
append_str(0,0,0,0);
|
||||
|
||||
/* This const cast is wrong but harmless, if we're careful. */
|
||||
for(cp=(char *)rp->code; *cp; cp++){
|
||||
if( cp==zSkip ){
|
||||
append_str(zOvwrt,0,0,0);
|
||||
cp += lemonStrlen(zOvwrt)-1;
|
||||
dontUseRhs0 = 1;
|
||||
continue;
|
||||
}
|
||||
if( ISALPHA(*cp) && (cp==rp->code || (!ISALNUM(cp[-1]) && cp[-1]!='_')) ){
|
||||
char saved;
|
||||
for(xp= &cp[1]; ISALNUM(*xp) || *xp=='_'; xp++);
|
||||
saved = *xp;
|
||||
*xp = 0;
|
||||
if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
|
||||
append_str("yygotominor.yy%d",0,rp->lhs->dtnum,0);
|
||||
append_str(zLhs,0,0,0);
|
||||
cp = xp;
|
||||
lhsused = 1;
|
||||
}else{
|
||||
for(i=0; i<rp->nrhs; i++){
|
||||
if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
|
||||
if( cp!=rp->code && cp[-1]=='@' ){
|
||||
if( i==0 && dontUseRhs0 ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"Label %s used after '%s'.",
|
||||
rp->rhsalias[0], zOvwrt);
|
||||
lemp->errorcnt++;
|
||||
}else if( cp!=rp->code && cp[-1]=='@' ){
|
||||
/* If the argument is of the form @X then substituted
|
||||
** the token number of X, not the value of X */
|
||||
append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0);
|
||||
|
|
@ -3588,6 +3738,11 @@ PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){
|
|||
append_str(cp, 1, 0, 0);
|
||||
} /* End loop */
|
||||
|
||||
/* Main code generation completed */
|
||||
cp = append_str(0,0,0,0);
|
||||
if( cp && cp[0] ) rp->code = Strsafe(cp);
|
||||
append_str(0,0,0,0);
|
||||
|
||||
/* Check to make sure the LHS has been used */
|
||||
if( rp->lhsalias && !lhsused ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
|
|
@ -3596,27 +3751,58 @@ PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){
|
|||
lemp->errorcnt++;
|
||||
}
|
||||
|
||||
/* Generate destructor code for RHS symbols which are not used in the
|
||||
** reduce code */
|
||||
/* Generate destructor code for RHS minor values which are not referenced.
|
||||
** Generate error messages for unused labels and duplicate labels.
|
||||
*/
|
||||
for(i=0; i<rp->nrhs; i++){
|
||||
if( rp->rhsalias[i] && !used[i] ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"Label %s for \"%s(%s)\" is never used.",
|
||||
rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
|
||||
lemp->errorcnt++;
|
||||
}else if( rp->rhsalias[i]==0 ){
|
||||
if( has_destructor(rp->rhs[i],lemp) ){
|
||||
append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
|
||||
rp->rhs[i]->index,i-rp->nrhs+1);
|
||||
}else{
|
||||
/* No destructor defined for this term */
|
||||
if( rp->rhsalias[i] ){
|
||||
if( i>0 ){
|
||||
int j;
|
||||
if( rp->lhsalias && strcmp(rp->lhsalias,rp->rhsalias[i])==0 ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"%s(%s) has the same label as the LHS but is not the left-most "
|
||||
"symbol on the RHS.",
|
||||
rp->rhs[i]->name, rp->rhsalias);
|
||||
lemp->errorcnt++;
|
||||
}
|
||||
for(j=0; j<i; j++){
|
||||
if( rp->rhsalias[j] && strcmp(rp->rhsalias[j],rp->rhsalias[i])==0 ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"Label %s used for multiple symbols on the RHS of a rule.",
|
||||
rp->rhsalias[i]);
|
||||
lemp->errorcnt++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if( !used[i] ){
|
||||
ErrorMsg(lemp->filename,rp->ruleline,
|
||||
"Label %s for \"%s(%s)\" is never used.",
|
||||
rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
|
||||
lemp->errorcnt++;
|
||||
}
|
||||
}else if( i>0 && has_destructor(rp->rhs[i],lemp) ){
|
||||
append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
|
||||
rp->rhs[i]->index,i-rp->nrhs+1);
|
||||
}
|
||||
}
|
||||
if( rp->code ){
|
||||
cp = append_str(0,0,0,0);
|
||||
rp->code = Strsafe(cp?cp:"");
|
||||
|
||||
/* If unable to write LHS values directly into the stack, write the
|
||||
** saved LHS value now. */
|
||||
if( lhsdirect==0 ){
|
||||
append_str(" yymsp[%d].minor.yy%d = ", 0, 1-rp->nrhs, rp->lhs->dtnum);
|
||||
append_str(zLhs, 0, 0, 0);
|
||||
append_str(";\n", 0, 0, 0);
|
||||
}
|
||||
|
||||
/* Suffix code generation complete */
|
||||
cp = append_str(0,0,0,0);
|
||||
if( cp && cp[0] ){
|
||||
rp->codeSuffix = Strsafe(cp);
|
||||
rp->noCode = 0;
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -3631,6 +3817,12 @@ PRIVATE void emit_code(
|
|||
){
|
||||
const char *cp;
|
||||
|
||||
/* Setup code prior to the #line directive */
|
||||
if( rp->codePrefix && rp->codePrefix[0] ){
|
||||
fprintf(out, "{%s", rp->codePrefix);
|
||||
for(cp=rp->codePrefix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
|
||||
}
|
||||
|
||||
/* Generate code to do the reduce action */
|
||||
if( rp->code ){
|
||||
if( !lemp->nolinenosflag ){
|
||||
|
|
@ -3638,15 +3830,23 @@ PRIVATE void emit_code(
|
|||
tplt_linedir(out,rp->line,lemp->filename);
|
||||
}
|
||||
fprintf(out,"{%s",rp->code);
|
||||
for(cp=rp->code; *cp; cp++){
|
||||
if( *cp=='\n' ) (*lineno)++;
|
||||
} /* End loop */
|
||||
for(cp=rp->code; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
|
||||
fprintf(out,"}\n"); (*lineno)++;
|
||||
if( !lemp->nolinenosflag ){
|
||||
(*lineno)++;
|
||||
tplt_linedir(out,*lineno,lemp->outname);
|
||||
}
|
||||
} /* End if( rp->code ) */
|
||||
}
|
||||
|
||||
/* Generate breakdown code that occurs after the #line directive */
|
||||
if( rp->codeSuffix && rp->codeSuffix[0] ){
|
||||
fprintf(out, "%s", rp->codeSuffix);
|
||||
for(cp=rp->codeSuffix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
|
||||
}
|
||||
|
||||
if( rp->codePrefix ){
|
||||
fprintf(out, "}\n"); (*lineno)++;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -4009,6 +4209,18 @@ void ReportTable(
|
|||
}
|
||||
free(ax);
|
||||
|
||||
/* Mark rules that are actually used for reduce actions after all
|
||||
** optimizations have been applied
|
||||
*/
|
||||
for(rp=lemp->rule; rp; rp=rp->next) rp->doesReduce = LEMON_FALSE;
|
||||
for(i=0; i<lemp->nxstate; i++){
|
||||
for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
|
||||
if( ap->type==REDUCE || ap->type==SHIFTREDUCE ){
|
||||
ap->x.rp->doesReduce = i ? LEMON_TRUE : LEMON_FALSE ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Finish rendering the constants now that the action table has
|
||||
** been computed */
|
||||
fprintf(out,"#define YYNSTATE %d\n",lemp->nxstate); lineno++;
|
||||
|
|
@ -4074,20 +4286,21 @@ void ReportTable(
|
|||
fprintf(out, "};\n"); lineno++;
|
||||
|
||||
/* Output the yy_shift_ofst[] table */
|
||||
fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", mnTknOfst-1); lineno++;
|
||||
n = lemp->nxstate;
|
||||
while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--;
|
||||
fprintf(out, "#define YY_SHIFT_COUNT (%d)\n", n-1); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_MIN (%d)\n", mnTknOfst); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_MAX (%d)\n", mxTknOfst); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", lemp->nactiontab); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_COUNT (%d)\n", n-1); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_MIN (%d)\n", mnTknOfst); lineno++;
|
||||
fprintf(out, "#define YY_SHIFT_MAX (%d)\n", mxTknOfst); lineno++;
|
||||
fprintf(out, "static const %s yy_shift_ofst[] = {\n",
|
||||
minimum_size_type(mnTknOfst-1, mxTknOfst, &sz)); lineno++;
|
||||
minimum_size_type(mnTknOfst, lemp->nterminal+lemp->nactiontab, &sz));
|
||||
lineno++;
|
||||
lemp->tablesize += n*sz;
|
||||
for(i=j=0; i<n; i++){
|
||||
int ofst;
|
||||
stp = lemp->sorted[i];
|
||||
ofst = stp->iTknOfst;
|
||||
if( ofst==NO_OFFSET ) ofst = mnTknOfst - 1;
|
||||
if( ofst==NO_OFFSET ) ofst = lemp->nactiontab;
|
||||
if( j==0 ) fprintf(out," /* %5d */ ", i);
|
||||
fprintf(out, " %4d,", ofst);
|
||||
if( j==9 || i==n-1 ){
|
||||
|
|
@ -4177,7 +4390,7 @@ void ReportTable(
|
|||
** when tracing REDUCE actions.
|
||||
*/
|
||||
for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
|
||||
assert( rp->index==i );
|
||||
assert( rp->iRule==i );
|
||||
fprintf(out," /* %3d */ \"", i);
|
||||
writeRuleText(out, rp);
|
||||
fprintf(out,"\",\n"); lineno++;
|
||||
|
|
@ -4227,6 +4440,7 @@ void ReportTable(
|
|||
for(i=0; i<lemp->nsymbol; i++){
|
||||
struct symbol *sp = lemp->symbols[i];
|
||||
if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
|
||||
if( sp->destLineno<0 ) continue; /* Already emitted */
|
||||
fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++;
|
||||
|
||||
/* Combine duplicate destructors into a single case */
|
||||
|
|
@ -4237,7 +4451,7 @@ void ReportTable(
|
|||
&& strcmp(sp->destructor,sp2->destructor)==0 ){
|
||||
fprintf(out," case %d: /* %s */\n",
|
||||
sp2->index, sp2->name); lineno++;
|
||||
sp2->destructor = 0;
|
||||
sp2->destLineno = -1; /* Avoid emitting this destructor again */
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4261,38 +4475,51 @@ void ReportTable(
|
|||
tplt_xfer(lemp->name,in,out,&lineno);
|
||||
|
||||
/* Generate code which execution during each REDUCE action */
|
||||
i = 0;
|
||||
for(rp=lemp->rule; rp; rp=rp->next){
|
||||
translate_code(lemp, rp);
|
||||
i += translate_code(lemp, rp);
|
||||
}
|
||||
if( i ){
|
||||
fprintf(out," YYMINORTYPE yylhsminor;\n"); lineno++;
|
||||
}
|
||||
/* First output rules other than the default: rule */
|
||||
for(rp=lemp->rule; rp; rp=rp->next){
|
||||
struct rule *rp2; /* Other rules with the same action */
|
||||
if( rp->code==0 ) continue;
|
||||
if( rp->code[0]=='\n' && rp->code[1]==0 ) continue; /* Will be default: */
|
||||
fprintf(out," case %d: /* ", rp->index);
|
||||
if( rp->codeEmitted ) continue;
|
||||
if( rp->noCode ){
|
||||
/* No C code actions, so this will be part of the "default:" rule */
|
||||
continue;
|
||||
}
|
||||
fprintf(out," case %d: /* ", rp->iRule);
|
||||
writeRuleText(out, rp);
|
||||
fprintf(out, " */\n"); lineno++;
|
||||
for(rp2=rp->next; rp2; rp2=rp2->next){
|
||||
if( rp2->code==rp->code ){
|
||||
fprintf(out," case %d: /* ", rp2->index);
|
||||
if( rp2->code==rp->code && rp2->codePrefix==rp->codePrefix
|
||||
&& rp2->codeSuffix==rp->codeSuffix ){
|
||||
fprintf(out," case %d: /* ", rp2->iRule);
|
||||
writeRuleText(out, rp2);
|
||||
fprintf(out," */ yytestcase(yyruleno==%d);\n", rp2->index); lineno++;
|
||||
rp2->code = 0;
|
||||
fprintf(out," */ yytestcase(yyruleno==%d);\n", rp2->iRule); lineno++;
|
||||
rp2->codeEmitted = 1;
|
||||
}
|
||||
}
|
||||
emit_code(out,rp,lemp,&lineno);
|
||||
fprintf(out," break;\n"); lineno++;
|
||||
rp->code = 0;
|
||||
rp->codeEmitted = 1;
|
||||
}
|
||||
/* Finally, output the default: rule. We choose as the default: all
|
||||
** empty actions. */
|
||||
fprintf(out," default:\n"); lineno++;
|
||||
for(rp=lemp->rule; rp; rp=rp->next){
|
||||
if( rp->code==0 ) continue;
|
||||
assert( rp->code[0]=='\n' && rp->code[1]==0 );
|
||||
fprintf(out," /* (%d) ", rp->index);
|
||||
if( rp->codeEmitted ) continue;
|
||||
assert( rp->noCode );
|
||||
fprintf(out," /* (%d) ", rp->iRule);
|
||||
writeRuleText(out, rp);
|
||||
fprintf(out, " */ yytestcase(yyruleno==%d);\n", rp->index); lineno++;
|
||||
if( rp->doesReduce ){
|
||||
fprintf(out, " */ yytestcase(yyruleno==%d);\n", rp->iRule); lineno++;
|
||||
}else{
|
||||
fprintf(out, " (OPTIMIZED OUT) */ assert(yyruleno!=%d);\n",
|
||||
rp->iRule); lineno++;
|
||||
}
|
||||
}
|
||||
fprintf(out," break;\n"); lineno++;
|
||||
tplt_xfer(lemp->name,in,out,&lineno);
|
||||
|
|
@ -4363,7 +4590,7 @@ void ReportHeader(struct lemon *lemp)
|
|||
void CompressTables(struct lemon *lemp)
|
||||
{
|
||||
struct state *stp;
|
||||
struct action *ap, *ap2;
|
||||
struct action *ap, *ap2, *nextap;
|
||||
struct rule *rp, *rp2, *rbest;
|
||||
int nbest, n;
|
||||
int i;
|
||||
|
|
@ -4440,6 +4667,36 @@ void CompressTables(struct lemon *lemp)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* If a SHIFTREDUCE action specifies a rule that has a single RHS term
|
||||
** (meaning that the SHIFTREDUCE will land back in the state where it
|
||||
** started) and if there is no C-code associated with the reduce action,
|
||||
** then we can go ahead and convert the action to be the same as the
|
||||
** action for the RHS of the rule.
|
||||
*/
|
||||
for(i=0; i<lemp->nstate; i++){
|
||||
stp = lemp->sorted[i];
|
||||
for(ap=stp->ap; ap; ap=nextap){
|
||||
nextap = ap->next;
|
||||
if( ap->type!=SHIFTREDUCE ) continue;
|
||||
rp = ap->x.rp;
|
||||
if( rp->noCode==0 ) continue;
|
||||
if( rp->nrhs!=1 ) continue;
|
||||
#if 1
|
||||
/* Only apply this optimization to non-terminals. It would be OK to
|
||||
** apply it to terminal symbols too, but that makes the parser tables
|
||||
** larger. */
|
||||
if( ap->sp->index<lemp->nterminal ) continue;
|
||||
#endif
|
||||
/* If we reach this point, it means the optimization can be applied */
|
||||
nextap = ap;
|
||||
for(ap2=stp->ap; ap2 && (ap2==ap || ap2->sp!=rp->lhs); ap2=ap2->next){}
|
||||
assert( ap2!=0 );
|
||||
ap->spOpt = ap2->sp;
|
||||
ap->type = ap2->type;
|
||||
ap->x = ap2->x;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -87,10 +87,6 @@
|
|||
%%
|
||||
/************* End control #defines *******************************************/
|
||||
|
||||
/* The yyzerominor constant is used to initialize instances of
|
||||
** YYMINORTYPE objects to zero. */
|
||||
static const YYMINORTYPE yyzerominor = { 0 };
|
||||
|
||||
/* Define the yytestcase() macro to be a no-op if is not already defined
|
||||
** otherwise.
|
||||
**
|
||||
|
|
@ -120,7 +116,7 @@ static const YYMINORTYPE yyzerominor = { 0 };
|
|||
**
|
||||
** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE
|
||||
** and YY_MAX_REDUCE
|
||||
|
||||
**
|
||||
** N == YY_ERROR_ACTION A syntax error has occurred.
|
||||
**
|
||||
** N == YY_ACCEPT_ACTION The parser accepts its input.
|
||||
|
|
@ -129,16 +125,20 @@ static const YYMINORTYPE yyzerominor = { 0 };
|
|||
** slots in the yy_action[] table.
|
||||
**
|
||||
** The action table is constructed as a single large table named yy_action[].
|
||||
** Given state S and lookahead X, the action is computed as
|
||||
** Given state S and lookahead X, the action is computed as either:
|
||||
**
|
||||
** yy_action[ yy_shift_ofst[S] + X ]
|
||||
** (A) N = yy_action[ yy_shift_ofst[S] + X ]
|
||||
** (B) N = yy_default[S]
|
||||
**
|
||||
** If the index value yy_shift_ofst[S]+X is out of range or if the value
|
||||
** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
|
||||
** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
|
||||
** and that yy_default[S] should be used instead.
|
||||
** The (A) formula is preferred. The B formula is used instead if:
|
||||
** (1) The yy_shift_ofst[S]+X value is out of range, or
|
||||
** (2) yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
|
||||
** (3) yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
|
||||
** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
|
||||
** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
|
||||
** Hence only tests (1) and (2) need to be evaluated.)
|
||||
**
|
||||
** The formula above is for computing the action when the lookahead is
|
||||
** The formulas above are for computing the action when the lookahead is
|
||||
** a terminal symbol. If the lookahead is a non-terminal (as occurs after
|
||||
** a reduce action) then the yy_reduce_ofst[] array is used in place of
|
||||
** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
|
||||
|
|
@ -207,15 +207,18 @@ typedef struct yyStackEntry yyStackEntry;
|
|||
/* The state of the parser is completely contained in an instance of
|
||||
** the following structure */
|
||||
struct yyParser {
|
||||
int yyidx; /* Index of top element in stack */
|
||||
yyStackEntry *yytos; /* Pointer to top element of the stack */
|
||||
#ifdef YYTRACKMAXSTACKDEPTH
|
||||
int yyidxMax; /* Maximum value of yyidx */
|
||||
int yyhwm; /* High-water mark of the stack */
|
||||
#endif
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
int yyerrcnt; /* Shifts left before out of the error */
|
||||
#endif
|
||||
ParseARG_SDECL /* A place to hold %extra_argument */
|
||||
#if YYSTACKDEPTH<=0
|
||||
int yystksz; /* Current side of the stack */
|
||||
yyStackEntry *yystack; /* The parser's stack */
|
||||
yyStackEntry yystk0; /* First stack entry */
|
||||
#else
|
||||
yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
|
||||
#endif
|
||||
|
|
@ -273,24 +276,34 @@ static const char *const yyRuleName[] = {
|
|||
|
||||
#if YYSTACKDEPTH<=0
|
||||
/*
|
||||
** Try to increase the size of the parser stack.
|
||||
** Try to increase the size of the parser stack. Return the number
|
||||
** of errors. Return 0 on success.
|
||||
*/
|
||||
static void yyGrowStack(yyParser *p){
|
||||
static int yyGrowStack(yyParser *p){
|
||||
int newSize;
|
||||
int idx;
|
||||
yyStackEntry *pNew;
|
||||
|
||||
newSize = p->yystksz*2 + 100;
|
||||
pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
|
||||
idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;
|
||||
if( p->yystack==&p->yystk0 ){
|
||||
pNew = malloc(newSize*sizeof(pNew[0]));
|
||||
if( pNew ) pNew[0] = p->yystk0;
|
||||
}else{
|
||||
pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
|
||||
}
|
||||
if( pNew ){
|
||||
p->yystack = pNew;
|
||||
p->yystksz = newSize;
|
||||
p->yytos = &p->yystack[idx];
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
|
||||
yyTracePrompt, p->yystksz);
|
||||
fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
|
||||
yyTracePrompt, p->yystksz, newSize);
|
||||
}
|
||||
#endif
|
||||
p->yystksz = newSize;
|
||||
}
|
||||
return pNew==0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -319,15 +332,24 @@ void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
|
|||
yyParser *pParser;
|
||||
pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
|
||||
if( pParser ){
|
||||
pParser->yyidx = -1;
|
||||
#ifdef YYTRACKMAXSTACKDEPTH
|
||||
pParser->yyidxMax = 0;
|
||||
pParser->yyhwm = 0;
|
||||
#endif
|
||||
#if YYSTACKDEPTH<=0
|
||||
pParser->yytos = NULL;
|
||||
pParser->yystack = NULL;
|
||||
pParser->yystksz = 0;
|
||||
yyGrowStack(pParser);
|
||||
if( yyGrowStack(pParser) ){
|
||||
pParser->yystack = &pParser->yystk0;
|
||||
pParser->yystksz = 1;
|
||||
}
|
||||
#endif
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
pParser->yyerrcnt = -1;
|
||||
#endif
|
||||
pParser->yytos = pParser->yystack;
|
||||
pParser->yystack[0].stateno = 0;
|
||||
pParser->yystack[0].major = 0;
|
||||
}
|
||||
return pParser;
|
||||
}
|
||||
|
|
@ -371,8 +393,9 @@ static void yy_destructor(
|
|||
*/
|
||||
static void yy_pop_parser_stack(yyParser *pParser){
|
||||
yyStackEntry *yytos;
|
||||
assert( pParser->yyidx>=0 );
|
||||
yytos = &pParser->yystack[pParser->yyidx--];
|
||||
assert( pParser->yytos!=0 );
|
||||
assert( pParser->yytos > pParser->yystack );
|
||||
yytos = pParser->yytos--;
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE,"%sPopping %s\n",
|
||||
|
|
@ -399,9 +422,9 @@ void ParseFree(
|
|||
#ifndef YYPARSEFREENEVERNULL
|
||||
if( pParser==0 ) return;
|
||||
#endif
|
||||
while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
|
||||
while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
|
||||
#if YYSTACKDEPTH<=0
|
||||
free(pParser->yystack);
|
||||
if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
|
||||
#endif
|
||||
(*freeProc)((void*)pParser);
|
||||
}
|
||||
|
|
@ -412,7 +435,7 @@ void ParseFree(
|
|||
#ifdef YYTRACKMAXSTACKDEPTH
|
||||
int ParseStackPeak(void *p){
|
||||
yyParser *pParser = (yyParser*)p;
|
||||
return pParser->yyidxMax;
|
||||
return pParser->yyhwm;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -420,61 +443,58 @@ int ParseStackPeak(void *p){
|
|||
** Find the appropriate action for a parser given the terminal
|
||||
** look-ahead token iLookAhead.
|
||||
*/
|
||||
static int yy_find_shift_action(
|
||||
static unsigned int yy_find_shift_action(
|
||||
yyParser *pParser, /* The parser */
|
||||
YYCODETYPE iLookAhead /* The look-ahead token */
|
||||
){
|
||||
int i;
|
||||
int stateno = pParser->yystack[pParser->yyidx].stateno;
|
||||
int stateno = pParser->yytos->stateno;
|
||||
|
||||
if( stateno>=YY_MIN_REDUCE ) return stateno;
|
||||
assert( stateno <= YY_SHIFT_COUNT );
|
||||
do{
|
||||
i = yy_shift_ofst[stateno];
|
||||
if( i==YY_SHIFT_USE_DFLT ) return yy_default[stateno];
|
||||
assert( iLookAhead!=YYNOCODE );
|
||||
i += iLookAhead;
|
||||
if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
|
||||
if( iLookAhead>0 ){
|
||||
#ifdef YYFALLBACK
|
||||
YYCODETYPE iFallback; /* Fallback token */
|
||||
if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
|
||||
&& (iFallback = yyFallback[iLookAhead])!=0 ){
|
||||
YYCODETYPE iFallback; /* Fallback token */
|
||||
if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
|
||||
&& (iFallback = yyFallback[iLookAhead])!=0 ){
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
|
||||
yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
|
||||
}
|
||||
#endif
|
||||
assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
|
||||
iLookAhead = iFallback;
|
||||
continue;
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
|
||||
yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
|
||||
}
|
||||
#endif
|
||||
assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
|
||||
iLookAhead = iFallback;
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
#ifdef YYWILDCARD
|
||||
{
|
||||
int j = i - iLookAhead + YYWILDCARD;
|
||||
if(
|
||||
{
|
||||
int j = i - iLookAhead + YYWILDCARD;
|
||||
if(
|
||||
#if YY_SHIFT_MIN+YYWILDCARD<0
|
||||
j>=0 &&
|
||||
j>=0 &&
|
||||
#endif
|
||||
#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
|
||||
j<YY_ACTTAB_COUNT &&
|
||||
j<YY_ACTTAB_COUNT &&
|
||||
#endif
|
||||
yy_lookahead[j]==YYWILDCARD
|
||||
){
|
||||
yy_lookahead[j]==YYWILDCARD && iLookAhead>0
|
||||
){
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
|
||||
yyTracePrompt, yyTokenName[iLookAhead],
|
||||
yyTokenName[YYWILDCARD]);
|
||||
}
|
||||
#endif /* NDEBUG */
|
||||
return yy_action[j];
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
|
||||
yyTracePrompt, yyTokenName[iLookAhead],
|
||||
yyTokenName[YYWILDCARD]);
|
||||
}
|
||||
#endif /* NDEBUG */
|
||||
return yy_action[j];
|
||||
}
|
||||
#endif /* YYWILDCARD */
|
||||
}
|
||||
#endif /* YYWILDCARD */
|
||||
return yy_default[stateno];
|
||||
}else{
|
||||
return yy_action[i];
|
||||
|
|
@ -516,15 +536,14 @@ static int yy_find_reduce_action(
|
|||
/*
|
||||
** The following routine is called if the stack overflows.
|
||||
*/
|
||||
static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor _U_){
|
||||
static void yyStackOverflow(yyParser *yypParser){
|
||||
ParseARG_FETCH;
|
||||
yypParser->yyidx--;
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
|
||||
}
|
||||
#endif
|
||||
while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
|
||||
while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
|
||||
/* Here code is inserted which will execute if the parser
|
||||
** stack every overflows */
|
||||
/******** Begin %stack_overflow code ******************************************/
|
||||
|
|
@ -541,11 +560,11 @@ static void yyTraceShift(yyParser *yypParser, int yyNewState){
|
|||
if( yyTraceFILE ){
|
||||
if( yyNewState<YYNSTATE ){
|
||||
fprintf(yyTraceFILE,"%sShift '%s', go to state %d\n",
|
||||
yyTracePrompt,yyTokenName[yypParser->yystack[yypParser->yyidx].major],
|
||||
yyTracePrompt,yyTokenName[yypParser->yytos->major],
|
||||
yyNewState);
|
||||
}else{
|
||||
fprintf(yyTraceFILE,"%sShift '%s'\n",
|
||||
yyTracePrompt,yyTokenName[yypParser->yystack[yypParser->yyidx].major]);
|
||||
yyTracePrompt,yyTokenName[yypParser->yytos->major]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -560,33 +579,38 @@ 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 to the minor token to shift in */
|
||||
ParseTOKENTYPE yyMinor /* The minor token to shift in */
|
||||
){
|
||||
yyStackEntry *yytos;
|
||||
yypParser->yyidx++;
|
||||
yypParser->yytos++;
|
||||
#ifdef YYTRACKMAXSTACKDEPTH
|
||||
if( yypParser->yyidx>yypParser->yyidxMax ){
|
||||
yypParser->yyidxMax = yypParser->yyidx;
|
||||
if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
|
||||
yypParser->yyhwm++;
|
||||
assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
|
||||
}
|
||||
#endif
|
||||
#if YYSTACKDEPTH>0
|
||||
if( yypParser->yyidx>=YYSTACKDEPTH ){
|
||||
yyStackOverflow(yypParser, yypMinor);
|
||||
if( yypParser->yytos>=&yypParser->yystack[YYSTACKDEPTH] ){
|
||||
yypParser->yytos--;
|
||||
yyStackOverflow(yypParser);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
if( yypParser->yyidx>=yypParser->yystksz ){
|
||||
yyGrowStack(yypParser);
|
||||
if( yypParser->yyidx>=yypParser->yystksz ){
|
||||
yyStackOverflow(yypParser, yypMinor);
|
||||
if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
|
||||
if( yyGrowStack(yypParser) ){
|
||||
yypParser->yytos--;
|
||||
yyStackOverflow(yypParser);
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
yytos = &yypParser->yystack[yypParser->yyidx];
|
||||
if( yyNewState > YY_MAX_SHIFT ){
|
||||
yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
|
||||
}
|
||||
yytos = yypParser->yytos;
|
||||
yytos->stateno = (YYACTIONTYPE)yyNewState;
|
||||
yytos->major = (YYCODETYPE)yyMajor;
|
||||
yytos->minor = *yypMinor;
|
||||
yytos->minor.yy0 = yyMinor;
|
||||
yyTraceShift(yypParser, yyNewState);
|
||||
}
|
||||
|
||||
|
|
@ -608,24 +632,47 @@ static void yy_accept(yyParser*); /* Forward Declaration */
|
|||
*/
|
||||
static void yy_reduce(
|
||||
yyParser *yypParser, /* The parser */
|
||||
int yyruleno /* Number of the rule by which to reduce */
|
||||
unsigned int yyruleno /* Number of the rule by which to reduce */
|
||||
){
|
||||
int yygoto; /* The next state */
|
||||
int yyact; /* The next action */
|
||||
YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
|
||||
yyStackEntry *yymsp; /* The top of the parser's stack */
|
||||
int yysize; /* Amount to pop the stack */
|
||||
ParseARG_FETCH;
|
||||
yymsp = &yypParser->yystack[yypParser->yyidx];
|
||||
yymsp = yypParser->yytos;
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE && yyruleno>=0
|
||||
&& yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
|
||||
if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
|
||||
yysize = yyRuleInfo[yyruleno].nrhs;
|
||||
fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt,
|
||||
yyRuleName[yyruleno], yymsp[-yysize].stateno);
|
||||
}
|
||||
#endif /* NDEBUG */
|
||||
yygotominor = yyzerominor;
|
||||
|
||||
/* Check that the stack is large enough to grow by a single entry
|
||||
** if the RHS of the rule is empty. This ensures that there is room
|
||||
** enough on the stack to push the LHS value */
|
||||
if( yyRuleInfo[yyruleno].nrhs==0 ){
|
||||
#ifdef YYTRACKMAXSTACKDEPTH
|
||||
if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
|
||||
yypParser->yyhwm++;
|
||||
assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
|
||||
}
|
||||
#endif
|
||||
#if YYSTACKDEPTH>0
|
||||
if( yypParser->yytos>=&yypParser->yystack[YYSTACKDEPTH-1] ){
|
||||
yyStackOverflow(yypParser);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
|
||||
if( yyGrowStack(yypParser) ){
|
||||
yyStackOverflow(yypParser);
|
||||
return;
|
||||
}
|
||||
yymsp = yypParser->yytos;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
switch( yyruleno ){
|
||||
/* Beginning here are the reduction cases. A typical example
|
||||
|
|
@ -640,29 +687,22 @@ static void yy_reduce(
|
|||
%%
|
||||
/********** End reduce actions ************************************************/
|
||||
};
|
||||
assert( yyruleno>=0 && yyruleno<(int)(sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0])) );
|
||||
assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
|
||||
yygoto = yyRuleInfo[yyruleno].lhs;
|
||||
yysize = yyRuleInfo[yyruleno].nrhs;
|
||||
yypParser->yyidx -= yysize;
|
||||
yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
|
||||
if( yyact <= YY_MAX_SHIFTREDUCE ){
|
||||
if( yyact>YY_MAX_SHIFT ) yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
|
||||
/* If the reduce action popped at least
|
||||
** one element off the stack, then we can push the new element back
|
||||
** onto the stack here, and skip the stack overflow test in yy_shift().
|
||||
** That gives a significant speed improvement. */
|
||||
if( yysize ){
|
||||
yypParser->yyidx++;
|
||||
yymsp -= yysize-1;
|
||||
yymsp->stateno = (YYACTIONTYPE)yyact;
|
||||
yymsp->major = (YYCODETYPE)yygoto;
|
||||
yymsp->minor = yygotominor;
|
||||
yyTraceShift(yypParser, yyact);
|
||||
}else{
|
||||
yy_shift(yypParser,yyact,yygoto,&yygotominor);
|
||||
if( yyact>YY_MAX_SHIFT ){
|
||||
yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
|
||||
}
|
||||
yymsp -= yysize-1;
|
||||
yypParser->yytos = yymsp;
|
||||
yymsp->stateno = (YYACTIONTYPE)yyact;
|
||||
yymsp->major = (YYCODETYPE)yygoto;
|
||||
yyTraceShift(yypParser, yyact);
|
||||
}else{
|
||||
assert( yyact == YY_ACCEPT_ACTION );
|
||||
yypParser->yytos -= yysize;
|
||||
yy_accept(yypParser);
|
||||
}
|
||||
}
|
||||
|
|
@ -680,7 +720,7 @@ static void yy_parse_failed(
|
|||
fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
|
||||
}
|
||||
#endif
|
||||
while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
|
||||
while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
|
||||
/* Here code is inserted which will be executed whenever the
|
||||
** parser fails */
|
||||
/************ Begin %parse_failure code ***************************************/
|
||||
|
|
@ -696,10 +736,10 @@ static void yy_parse_failed(
|
|||
static void yy_syntax_error(
|
||||
yyParser *yypParser, /* The parser */
|
||||
int yymajor _U_, /* The major type of the error token */
|
||||
YYMINORTYPE yyminor /* The minor type of the error token */
|
||||
ParseTOKENTYPE yyminor /* The minor type of the error token */
|
||||
){
|
||||
ParseARG_FETCH;
|
||||
#define TOKEN (yyminor.yy0)
|
||||
#define TOKEN yyminor
|
||||
/************ Begin %syntax_error code ****************************************/
|
||||
%%
|
||||
/************ End %syntax_error code ******************************************/
|
||||
|
|
@ -718,7 +758,10 @@ static void yy_accept(
|
|||
fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
|
||||
}
|
||||
#endif
|
||||
while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
yypParser->yyerrcnt = -1;
|
||||
#endif
|
||||
assert( yypParser->yytos==yypParser->yystack );
|
||||
/* Here code is inserted which will be executed whenever the
|
||||
** parser accepts */
|
||||
/*********** Begin %parse_accept code *****************************************/
|
||||
|
|
@ -753,7 +796,7 @@ void Parse(
|
|||
ParseARG_PDECL /* Optional %extra_argument parameter */
|
||||
){
|
||||
YYMINORTYPE yyminorunion;
|
||||
int yyact; /* The parser action. */
|
||||
unsigned int yyact; /* The parser action. */
|
||||
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
|
||||
int yyendofinput; /* True if we are at the end of input */
|
||||
#endif
|
||||
|
|
@ -762,29 +805,8 @@ void Parse(
|
|||
#endif
|
||||
yyParser *yypParser; /* The parser */
|
||||
|
||||
/* (re)initialize the parser, if necessary */
|
||||
yypParser = (yyParser*)yyp;
|
||||
if( yypParser->yyidx<0 ){
|
||||
#if YYSTACKDEPTH<=0
|
||||
if( yypParser->yystksz <=0 ){
|
||||
/*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
|
||||
yyminorunion = yyzerominor;
|
||||
yyStackOverflow(yypParser, &yyminorunion);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
yypParser->yyidx = 0;
|
||||
yypParser->yyerrcnt = -1;
|
||||
yypParser->yystack[0].stateno = 0;
|
||||
yypParser->yystack[0].major = 0;
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
fprintf(yyTraceFILE,"%sInitialize. Empty stack. State 0\n",
|
||||
yyTracePrompt);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
yyminorunion.yy0 = yyminor;
|
||||
assert( yypParser->yytos!=0 );
|
||||
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
|
||||
yyendofinput = (yymajor==0);
|
||||
#endif
|
||||
|
|
@ -799,14 +821,16 @@ void Parse(
|
|||
do{
|
||||
yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
|
||||
if( yyact <= YY_MAX_SHIFTREDUCE ){
|
||||
if( yyact > YY_MAX_SHIFT ) yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
|
||||
yy_shift(yypParser,yyact,yymajor,&yyminorunion);
|
||||
yy_shift(yypParser,yyact,yymajor,yyminor);
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
yypParser->yyerrcnt--;
|
||||
#endif
|
||||
yymajor = YYNOCODE;
|
||||
}else if( yyact <= YY_MAX_REDUCE ){
|
||||
yy_reduce(yypParser,yyact-YY_MIN_REDUCE);
|
||||
}else{
|
||||
assert( yyact == YY_ERROR_ACTION );
|
||||
yyminorunion.yy0 = yyminor;
|
||||
#ifdef YYERRORSYMBOL
|
||||
int yymx;
|
||||
#endif
|
||||
|
|
@ -836,9 +860,9 @@ void Parse(
|
|||
**
|
||||
*/
|
||||
if( yypParser->yyerrcnt<0 ){
|
||||
yy_syntax_error(yypParser,yymajor,yyminorunion);
|
||||
yy_syntax_error(yypParser,yymajor,yyminor);
|
||||
}
|
||||
yymx = yypParser->yystack[yypParser->yyidx].major;
|
||||
yymx = yypParser->yytos->major;
|
||||
if( yymx==YYERRORSYMBOL || yyerrorhit ){
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
|
|
@ -846,26 +870,26 @@ void Parse(
|
|||
yyTracePrompt,yyTokenName[yymajor]);
|
||||
}
|
||||
#endif
|
||||
yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
|
||||
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,
|
||||
while( yypParser->yytos >= yypParser->yystack
|
||||
&& yymx != YYERRORSYMBOL
|
||||
&& (yyact = yy_find_reduce_action(
|
||||
yypParser->yytos->stateno,
|
||||
YYERRORSYMBOL)) >= YY_MIN_REDUCE
|
||||
){
|
||||
yy_pop_parser_stack(yypParser);
|
||||
}
|
||||
if( yypParser->yyidx < 0 || yymajor==0 ){
|
||||
if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
|
||||
yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
|
||||
yy_parse_failed(yypParser);
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
yypParser->yyerrcnt = -1;
|
||||
#endif
|
||||
yymajor = YYNOCODE;
|
||||
}else if( yymx!=YYERRORSYMBOL ){
|
||||
YYMINORTYPE u2;
|
||||
u2.YYERRSYMDT = 0;
|
||||
yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
|
||||
yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
|
||||
}
|
||||
}
|
||||
yypParser->yyerrcnt = 3;
|
||||
|
|
@ -878,7 +902,7 @@ void Parse(
|
|||
** 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_syntax_error(yypParser,yymajor, yyminor);
|
||||
yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
|
||||
yymajor = YYNOCODE;
|
||||
|
||||
|
|
@ -893,24 +917,29 @@ void Parse(
|
|||
** three input tokens have been successfully shifted.
|
||||
*/
|
||||
if( yypParser->yyerrcnt<=0 ){
|
||||
yy_syntax_error(yypParser,yymajor,yyminorunion);
|
||||
yy_syntax_error(yypParser,yymajor, yyminor);
|
||||
}
|
||||
yypParser->yyerrcnt = 3;
|
||||
yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
|
||||
if( yyendofinput ){
|
||||
yy_parse_failed(yypParser);
|
||||
#ifndef YYNOERRORRECOVERY
|
||||
yypParser->yyerrcnt = -1;
|
||||
#endif
|
||||
}
|
||||
yymajor = YYNOCODE;
|
||||
#endif
|
||||
}
|
||||
}while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
|
||||
}while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
|
||||
#ifndef NDEBUG
|
||||
if( yyTraceFILE ){
|
||||
int i;
|
||||
yyStackEntry *i;
|
||||
char cDiv = '[';
|
||||
fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
|
||||
for(i=1; i<=yypParser->yyidx; i++)
|
||||
fprintf(yyTraceFILE,"%c%s", i==1 ? '[' : ' ',
|
||||
yyTokenName[yypParser->yystack[i].major]);
|
||||
for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
|
||||
fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
|
||||
cDiv = ' ';
|
||||
}
|
||||
fprintf(yyTraceFILE,"]\n");
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in New Issue