gen.c

本工具提供一个词法分析器和语法分析器的集成开发环境

		else if ( !r2->noAST && p->astnode == ASTinclude )
		{
			/* rule doesn't have a ! and neither does element */
/* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {
/* MR10 */    _gen("\n");
/* MR10 */    if (GenCC) gen ("if (!guessing) {    /* MR10 */")
/* MR10 */          else gen ("if (!zzguessing) {    /* MR10 */\n");
/* MR10 */    tabs++;
/* MR10 */  };
			if ( GenCC ) {
				_gen("\n");
				gen("if ( _tail==NULL ) _sibling = _ast; else _tail->setRight(_ast);\n");
				gen2("_ast%d%d = (AST *)_ast;\n", BlkLevel-1, p->elnum);
				tab();
			}
			else _gen(" ");
            if ( GenCC ) {
                _gen("ASTBase::"); }
                else _gen("zz");
			_gen("link(_root, &_sibling, &_tail);");

/* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {     /* MR10 */
/* MR10 */    _gen("\n");
/* MR10 */    tabs--;
/* MR10 */    if (GenCC) gen ("};    /* MR10 */")
/* MR10 */          else gen ("};    /* MR10 */");
/* MR10 */  };
		}
	}
	else
	{
		if ( p->assign!=NULL && q->ret!=NULL )                       /* MR8 */
		{
			if ( !HasComma(p->assign) ) {_gen1("%s = ",p->assign);}
			else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
		}
		if ( FoundException ) {
			_gen4("%s%s(&_signal%s%s); ",
				  RulePrefix,
				  p->text,
				  (p->parms!=NULL)?",":"",
				  (p->parms!=NULL)?p->parms:"");
			if ( p->ex_group!=NULL ) {
				_gen("\n");
				gen("if (_signal) {\n");
				tabs++;
				dumpException(p->ex_group, 0);
				tabs--;
				gen("}");
			}
			else {
				_gen1("if (_signal) goto %s_handler;", handler_id);
			}
		}
		else {
			_gen3("%s%s(%s);",
				  RulePrefix,
				  p->text,
				  (p->parms!=NULL)?p->parms:"");
		}
		if ( p->assign!=NULL && q->ret!=NULL ) _gen("\n");           /* MR8 */
	}

	if ( p->assign!=NULL && q->ret!=NULL) {                          /* MR8 */
		if ( HasComma(p->assign) )
		{
			_gen("\n");
			dumpRetValAssign(p->assign, q->ret);
			_gen("}");
		}
	}
	_gen("\n");

	/* Handle element labels now */
	if ( p->el_label!=NULL )
	{
		if ( GenAST )
		{
			if ( GenCC ) {
				gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
			}
			else {gen1("%s_ast = zzastCur;\n", p->el_label);}
		}
       	else if (!GenCC ) {
			gen1("%s = zzaCur;\n", p->el_label);
        }
	}

	if ( FoundGuessBlk && p->assign!=NULL && q->ret!=NULL ) {       /* MR8 */
		/* in guessing mode, don't branch to handler upon error */
        tabs--;                                                     /* MR11 */
		gen("} else {\n");
        tabs++;                                                     /* MR11 */
		if ( FoundException ) {
			gen6("%s%s(%s%s&_signal%s%s);\n",
				 RulePrefix,
				 p->text,
				 parm,
                 (*parm!='\0')?",":"",
                 (p->parms!=NULL)?",":"",
				 (p->parms!=NULL)?p->parms:"");
		}
		else {
			gen5("%s%s(%s%s%s);\n",
				 RulePrefix,
				 p->text,
				 parm,
				 (p->parms!=NULL && *parm!='\0')?",":"",
				 (p->parms!=NULL)?p->parms:"");
		}
        tabs--;                                                     /* MR11 */
		gen("}\n");
	}
	TRANS(p->next)
}

/*
 * Generate code to match a token.
 *
 * Getting the next token is tricky.  We want to ensure that any action
 * following a token is executed before the next GetToken();
 */
void
#ifdef __USE_PROTOS
genToken( TokNode *p )
#else
genToken( p )
TokNode *p;
#endif
{
	RuleEntry *r;
	char *handler_id = "";
	ActionNode *a;
	char *set_name;
	require(p!=NULL,			"genToken: invalid node and/or rule");
	require(p->ntype==nToken,	"genToken: not token");
	
	if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
		handler_id = p->altstart->exception_label;

	r = (RuleEntry *) hash_get(Rname, p->rname);
	if ( r == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}

    OutLineInfo(output,p->line,FileStr[p->file]);

	if ( !set_nil(p->tset) )	/* implies '.', ~Tok, or tokenclass */
	{
		unsigned e;
		set b;
		b = set_dup(p->tset);
		if ( p->tclass!=NULL )			/* token class? */
		{
			static char buf[MaxRuleName+1];
			if ( p->tclass->dumped )
				e = p->tclass->setnum;
			else {
				e = DefErrSet(&b, 0, TokenString(p->token));
				p->tclass->dumped = 1;	/* indicate set has been created */
				p->tclass->setnum = e;
			}
			sprintf(buf, "%s_set", TokenString(p->token));
			set_name = buf;
		}
		else {					/* wild card to ~ operator */
			static char buf[sizeof("zzerr")+10];
			int n = DefErrSet( &b, 0, NULL );
			if ( GenCC ) sprintf(buf, "err%d", n);
			else sprintf(buf, "zzerr%d", n);
			set_name = buf;
		}

		if ( !FoundException )
			{gen1("zzsetmatch(%s);", set_name);}
		else if ( p->ex_group==NULL ) {
            if ( p->use_def_MT_handler )
                gen3("zzsetmatch_wdfltsig(%s,(ANTLRTokenType)%d,%s);",
                     set_name,
                     p->token,
                     tokenFollowSet(p))
            else
                gen2("zzsetmatch_wsig(%s, %s_handler);",
                     set_name,
                     handler_id);
		}
		else
		{
			gen1("if ( !_setmatch_wsig(%s) ) {\n", set_name);
			tabs++;
/* MR6 */	if (FoundGuessBlk) {
/* MR6 */	  if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
/* MR6 */	  else gen("if ( zzguessing ) goto fail;\n");
/* MR6 */	};
			gen("_signal=MismatchedToken;\n");
			dumpException(p->ex_group, 0);
			tabs--;
			gen("}\n");
		}
		set_free(b);
	}
	else if ( TokenString(p->token)!=NULL )
	{
		if ( FoundException ) {
			if ( p->use_def_MT_handler )
				gen2("zzmatch_wdfltsig(%s,%s);",TokenString(p->token),tokenFollowSet(p))
			else if ( p->ex_group==NULL )
			{
				gen2("zzmatch_wsig(%s, %s_handler);",
					 TokenString(p->token),
					 handler_id);
			}
			else
			{
/* MR6 */		if (GenCC) {
/* MR6 */		  gen1("if ( !_match_wsig(%s) ) {\n", TokenString(p->token));
/* MR6 */		} else {
/* MR6 */		  gen1("if ( !_zzmatch_wsig(%s) ) {\n", TokenString(p->token));
/* MR6 */		};
				tabs++;
/* MR6 */		if (FoundGuessBlk) {
/* MR6 */	  	  if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
/* MR6 */		  else gen("if ( zzguessing ) goto fail;\n");
/* MR6 */		};
				gen("_signal=MismatchedToken;\n");
				dumpException(p->ex_group, 0);
				tabs--;
				gen("}\n");
			}
		}
		else gen1("zzmatch(%s);", TokenString(p->token));
	}
	else {
        if ( FoundException ) {
            if ( p->use_def_MT_handler )
				gen2("zzmatch_wdfltsig((ANTLRTokenType)%d,%s);",
					 p->token,tokenFollowSet(p))
            else
                gen2("zzmatch_wsig(%d,%s_handler);",p->token,handler_id);
        }
		else {gen1("zzmatch(%d);", p->token);}
	}

	a = findImmedAction( p->next );
	/* generate the token labels */
	if ( GenCC && p->elnum>0 )
	{
		/* If building trees in C++, always gen the LT() assigns */
		if ( set_el(p->elnum, tokensRefdInBlock) || GenAST )
		{
/* MR10 */	if ( FoundGuessBlk ) {
/* MR10 */    gen("\n");
/* MR10 */    if (p->label_used_in_semantic_pred) {
/* MR10 */		gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);  /* MR10 */\n", BlkLevel-1, p->elnum);
/* MR10 */    } else {
/* MR10 */		gen("if ( !guessing ) {\n"); tab();
/* MR10 */		_gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);\n", BlkLevel-1, p->elnum);
/* MR10 */      _gen("}\n");
/* MR10 */    };
/* MR10 */  } else {
/* MR10 */	  _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);", BlkLevel-1, p->elnum);
/* MR10 */  };
/* MR10 */
		}

		if ( LL_k>1 )
			if ( !DemandLookahead ) _gen(" labase++;");
		_gen("\n");
		tab();
	}
	if ( GenAST )
	{
		if ( FoundGuessBlk && !(p->astnode == ASTexclude || r->noAST) )
		{
			if ( GenCC ) {_gen("if ( !guessing ) {\n"); tab();}
			else {_gen("zzNON_GUESS_MODE {\n"); tab();}
		}
		if ( !r->noAST )
		{
			if ( GenCC && !(p->astnode == ASTexclude || r->noAST) ) {
				_gen("\n");
/* MR13 */      if (NewAST) {
/* MR13 */    	    gen4("_ast%d%d = newAST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      } else {
/* MR13 */    	    gen4("_ast%d%d = new AST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      }
				tab();
			}
			if ( GenCC && !(p->astnode == ASTexclude || r->noAST) )
				{_gen2("_ast%d%d->", BlkLevel-1, p->elnum);}
			else _gen(" ");
			if ( p->astnode==ASTchild ) {
				if ( !GenCC ) _gen("zz");
				_gen("subchild(_root, &_sibling, &_tail);");
			}
			else if ( p->astnode==ASTroot ) {
				if ( !GenCC ) _gen("zz");
				_gen("subroot(_root, &_sibling, &_tail);");
			}
			if ( GenCC && !(p->astnode == ASTexclude || r->noAST) ) {
				_gen("\n");
				tab();
			}
		}
		else if ( !GenCC ) _gen(" zzastDPush;");
		if ( FoundGuessBlk && !(p->astnode == ASTexclude || r->noAST) )
			{_gen("}\n"); tab();}
	}

	/* Handle element labels now */
	if ( p->el_label!=NULL )
	{
        int     done_NON_GUESSMODE=0;

		_gen("\n");

/* MR10 */    /* do Attrib / Token ptr for token label used in semantic pred */
/* MR10 */    /* for these cases do assign even in guess mode                */
/* MR10 */
/* MR10 */    if (p->label_used_in_semantic_pred) {
/* MR10 */      if ( GenCC ) {
/* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
/* MR10 */          gen3("%s = _t%d%d;", p->el_label, BlkLevel-1, p->elnum);
/* MR10 */        } else {
/* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
/* MR10 */        };
/* MR10 */      } else {
/* MR10 */		  gen1("%s = zzaCur;", p->el_label);
/* MR10 */      };
/* MR10 */      if (FoundGuessBlk) _gen("  /* MR10 */");
/* MR10 */      _gen("\n");
/* MR10 */    };

		/* Do Attrib / Token ptr */

/* MR10 */  if (! p->label_used_in_semantic_pred) {
/* MR10 */
/* MR10 */      if ( FoundGuessBlk ) {
/* MR10 */        if (! done_NON_GUESSMODE) {
/* MR10 */          done_NON_GUESSMODE=1;
/* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
/* MR10 */          else {gen("zzNON_GUESS_MODE {\n"); tab();}
/* MR10 */        };
/* MR10 */      };
/* MR10 */
/* MR10 */      if ( GenCC ) {
/* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
/* MR10 */          gen3("%s = _t%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
/* MR10 */        } else {
/* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
/* MR10 */        };
/* MR10 */      } else {
/* MR10 */        gen1("%s = zzaCur;\n", p->el_label);
/* MR10 */      };
/* MR10 */  };

		/* Do AST ptr */
		if ( GenAST && !(p->astnode == ASTexclude || r->noAST) )
		{

/* MR10 */      if ( FoundGuessBlk ) {
/* MR10 */        if (! done_NON_GUESSMODE) {
/* MR10 */          done_NON_GUESSMODE=1;
/* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
/* MR10 */          else {gen("zzNON_GUESS_MODE {\n"); tab();}
/* MR10 */        };
/* MR10 */      };

			if ( GenCC ) {
				gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
			}
			else {gen1("%s_ast = zzastCur;\n", p->el_label);}
		}

/* MR10 */  if (done_NON_GUESSMODE) {
/* MR10 */    gen("}\n"); tab();
/* MR10 */  };

	}

	/* Handle any actions immediately following action */
	if ( a != NULL )  /* MR10 */ /* MR11 */
    {
    	/* delay next token fetch until after action */
		_gen("\n");
		if ( a->is_predicate)
		{
		gen("if (!(");
			/* make sure that '#line n' is on front of line */  /* MR14 */
			if ( GenLineInfo && p->file != -1 ) _gen("\n");     /* MR14 */
			dumpPredAction(a,a->action, output, 0, a->file, a->line, 0);
			if ( a->pred_fail != NULL )
			{
				_gen(")) {\n");
/**************	if ( FoundGuessBlk ) gen("zzNON_GUESS_MODE {\n"); *****/
				tabs++;
/* MR1				                                                        */
/* MR1  10-Apr-97 MR1  Put {...} envelope around failed semantic predicates */
/* MR1				                                                        */
				gen1("{%s};\n", a->pred_fail);
				tabs--;
				gen("}\n");
/**************	if ( FoundGuessBlk ) gen("}\n"); *****/
			}
/* MR1					                                		    */
/* MR1  10-Apr-97 MR1	Properly stringize failed semantic predicates 	    */
/* MR1						                                                */
			else
            {
                 _gen1(")) {zzfailed_pred(\"%s\");}\n",              /* MR1 */
					stringize(a->action));	                     /* MR1 */
            }
		}
		else    /* MR9 a regular action - not a predicate action */
		{
			if ( FoundGuessBlk )
				if ( GenCC ) {gen("if ( !guessing ) {\n");}
				else gen("zzNON_GUESS_MODE {\n");
			dumpAction(a->action, output, tabs, a->file, a->line, 1);
			if ( FoundGuessBlk ) gen("}\n");
		}
		a->done = 1;
		if ( !DemandLookahead ) {
			if ( GenCC ) {
				if ( FoundException && p->use_def_MT_handler ) gen("if (!_signal)");
				_gen(" consume();")
                if ( FoundException && p->use_def_MT_handler )
                    _gen(" _signal=NoSignal;");
                _gen("\n");
			}
            else
            {
                if ( FoundException && p->use_def_MT_handler ) _gen("if (!_signal)");
					_gen(" zzCONSUME;\n");
                if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
                _gen("\n");
            }
		}
		else gen("\n");
		TRANS( a->next );
	}
	else
	{
        if ( !DemandLookahead ) {
			if ( GenCC ) {
				if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
				_gen(" consume();")
				if (FoundException&&p->use_def_MT_handler) _gen(" _signal=NoSignal;");
				_gen("\n");
			}
			else {
				if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
				_gen(" zzCONSUME;");
				if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
				_gen("\n");
			}
		}
		else _gen("\n");
		TRANS(p->next);
	}
}

void
#ifdef __USE_PROTOS
genOptBlk( Junction *q )
#else
genOptBlk( q )
Junction *q;
#endif
{
	int max_k;
	set f;
	int need_right_curly;
	set savetkref;
	savetkref = tokensRefdInBlock;
	require(q!=NULL,				"genOptBlk: invalid node and/or rule");
	require(q->ntype == nJunction,	"genOptBlk: not junction");
	require(q->jtype == aOptBlk,	"genOptBlk: not optional block");

    OutLineInfo(output,q->line,FileStr[q->file]);

	BLOCK_Preamble(q);
	BlkLevel++;
	f = genBlk(q, aOptBlk, &max_k, &need_right_curly);
	set_free(f);
	freeBlkFsets(q);
	BlkLevel--;
    if ( first_item_is_guess_block((Junction *)q->p1)!=NULL )
	{
		gen("else if ( !zzrv ) zzGUESS_DONE;\n");
	}
	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	BLOCK_Tail();
	tokensRefdInBlock = savetkref;
	if (q->end->p1 != NULL) TRANS(q->end->p1);
}

/*
 * Generate code for a loop blk of form:
 *
 *				 |---|
 *				 v