antlr.c

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

	CurRuleBlk->jtype = RuleBlk;
	if ( q!=NULL ) CurRuleBlk->rname = q->str;
	CurRuleBlk->file = f;
	CurRuleBlk->line = l;
	CurRuleBlk->pdecl = pdecl;
	CurRuleBlk->ret = ret;
	CurRuleBlk->lock = makelocks();
	CurRuleBlk->pred_lock = makelocks();
	CurRuleBlk->tokrefs = toksrefd;
	CurRuleBlk->rulerefs = rulesrefd;
	p = newJunction();	/* add EndRule Node */
	((Junction *)r.right)->p1 = (Node *)p;
	r.right = (Node *) p;
	p->jtype = EndRule;
	p->lock = makelocks();
	p->pred_lock = makelocks();
	CurRuleBlk->end = p;
	if ( q!=NULL ) q->rulenum = NumRules;
	zzaArg(zztasp1,7) = r;
	--BlkLevel;
	altFixup();leFixup();egFixup();
	zzmatch(105);
	inAlt=0;
 zzCONSUME;

	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==Action) ) {
			zzmatch(Action);
			a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
			require(a!=NULL, "rule rule: cannot allocate error action");
			strcpy(a, LATEXT(1));
			CurRuleBlk->erraction = a;
 zzCONSUME;

		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==132) ) {
			 eg  = exception_group();

			if ( eg!=NULL ) {
				list_add(&CurExGroups, (void *)eg);
				if (eg->label == NULL || *eg->label=='\0' ) q->has_rule_exception = 1;
			}
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);
	CurRuleNode = NULL;
	CurRuleBlk->exceptions = CurExGroups;
	CurRuleBlk->el_labels = CurElementLabels;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x1);
	}
}

void
#ifdef __USE_PROTOS
laction(void)
#else
laction()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *a;
	zzmatch(106); zzCONSUME;
	zzmatch(Action);
	
	a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
	require(a!=NULL, "rule laction: cannot allocate action");
	strcpy(a, LATEXT(1));
	list_add(&LexActions, a);
 zzCONSUME;

	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x2);
	}
}

void
#ifdef __USE_PROTOS
lmember(void)
#else
lmember()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *a;
	zzmatch(107); zzCONSUME;
	zzmatch(Action);
	
	/* MR1 */		if (! GenCC) {
		/* MR1 */		  err("Use #lexmember only in C++ mode (to insert code in DLG class header");
		/* MR1 */	        } else {
		/* MR1 */		  a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
		/* MR1 */		  require(a!=NULL, "rule lmember: cannot allocate action");
		/* MR1 */		  strcpy(a, LATEXT(1));
		/* MR1 */		  list_add(&LexMemberActions, a);
		/* MR1 */		};
	/* MR1 */
 zzCONSUME;

	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x4);
	}
}

void
#ifdef __USE_PROTOS
lprefix(void)
#else
lprefix()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *a;
	zzmatch(108); zzCONSUME;
	zzmatch(Action);
	
	/* MR1 */		if (! GenCC) {
		/* MR1 */		  err("Use #lexprefixr only in C++ mode (to insert code in DLG class header");
		/* MR1 */	        } else {
		/* MR1 */		  a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
		/* MR1 */		  require(a!=NULL, "rule lprefix: cannot allocate action");
		/* MR1 */		  strcpy(a, LATEXT(1));
		/* MR1 */		  list_add(&LexPrefixActions, a);
		/* MR1 */		};
	/* MR1 */
 zzCONSUME;

	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x8);
	}
}

void
#ifdef __USE_PROTOS
aPred(void)
#else
aPred()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	PredEntry     *predEntry=NULL;
	char          *name=NULL;
	Predicate     *predExpr=NULL;
	char          *predLiteral=NULL;
	int           save_file;
	int           save_line;
	int           predExprPresent=0;
	zzmatch(109);
	
	MR_usingPredNames=1;      /* will need to use -mrhoist version of genPredTree */
 zzCONSUME;

	zzmatch(TokenTerm);
	name=mystrdup(LATEXT(1));
 zzCONSUME;

	
	/* don't free - referenced in predicates */
	
            CurPredName=(char *)calloc(1,strlen(name) + 10);
	strcat("#pred ",CurPredName);
	strcat(name,CurPredName);
	
            predEntry=(PredEntry *) hash_get(Pname,name);
	if (predEntry != NULL) {
	warnFL(eMsg1("#pred %s previously defined - ignored",name),
	FileStr[action_file],action_line);
	name=NULL;
};
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==Pred) ) {
			zzmatch(Pred);
			predLiteral=mystrdup(LATEXT(1));
			save_line=action_line;
			save_file=action_file;
 zzCONSUME;

			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (setwd2[LA(1)]&0x10) ) {
					 predExpr  = predOrExpr();

					predExprPresent=1;
				}
				zzEXIT(zztasp3);
				}
			}
			if (predLiteral != NULL && name != NULL) {
				
                      /*
				*  predExpr may be NULL due to syntax errors
				*    or simply omitted by the user
				*/
				
                      predEntry=newPredEntry(name);
				predEntry->file=save_file;
				predEntry->line=save_line;
				predExpr=MR_predFlatten(predExpr);
				predEntry->predLiteral=predLiteral;
				if (! predExprPresent || predExpr == NULL) {
					predExpr=new_pred();
					predExpr->expr=predLiteral;
					predExpr->source=newActionNode();
					predExpr->source->action=predExpr->expr;
					predExpr->source->rname=CurPredName;
					predExpr->source->line=action_line;
					predExpr->source->file=action_file;
					predExpr->source->is_predicate=1;
					predExpr->k=predicateLookaheadDepth(predExpr->source);
				};
				predEntry->pred=predExpr;
				hash_add(Pname,name,(Entry *)predEntry);
				predExpr=NULL;
			};
			predicate_free(predExpr);
		}
		else {
			if ( (setwd2[LA(1)]&0x20) ) {
				save_line=zzline; save_file=CurFile;
				 predExpr  = predOrExpr();

				if (predExpr != NULL && name != NULL) {
					predEntry=newPredEntry(name);
					predEntry->file=CurFile;
					predEntry->line=zzline;
					predExpr=MR_predFlatten(predExpr);
					predEntry->pred=predExpr;
					hash_add(Pname,name,(Entry *)predEntry);
					predExpr=NULL;
				};
				predicate_free(predExpr);
			}
			else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==105) ) {
			zzmatch(105); zzCONSUME;
		}
		zzEXIT(zztasp2);
		}
	}
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	predicate_free(predExpr);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x40);
	}
}

 Predicate *
#ifdef __USE_PROTOS
predOrExpr(void)
#else
predOrExpr()
#endif
{
	 Predicate * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( Predicate * 	))
	zzMake0;
	{
	Predicate     *ORnode;
	Predicate     *predExpr;
	Predicate     **tail=NULL;
	 predExpr  = predAndExpr();

	
	ORnode=new_pred();
	ORnode->expr=PRED_OR_LIST;
	if (predExpr != NULL) {
		ORnode->down=predExpr;
		tail=&predExpr->right;
	};
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==110) ) {
			zzmatch(110); zzCONSUME;
			 predExpr  = predAndExpr();

			
			if (predExpr != NULL) {
				*tail=predExpr;
				tail=&predExpr->right;
			};
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	
	_retv=ORnode;
	ORnode=NULL;
	zzEXIT(zztasp1);
	return _retv;
fail:
	zzEXIT(zztasp1);
	predicate_free(ORnode);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd2, 0x80);
	return _retv;
	}
}

 Predicate *
#ifdef __USE_PROTOS
predAndExpr(void)
#else
predAndExpr()
#endif
{
	 Predicate * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( Predicate * 	))
	zzMake0;
	{
	Predicate     *ANDnode;
	Predicate     *predExpr;
	Predicate     **tail=NULL;
	 predExpr  = predPrimary();

	
	ANDnode=new_pred();
	ANDnode->expr=PRED_AND_LIST;
	if (predExpr != NULL) {
		ANDnode->down=predExpr;
		tail=&predExpr->right;
	};
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==111) ) {
			zzmatch(111); zzCONSUME;
			 predExpr  = predPrimary();

			
			if (predExpr != NULL) {
				*tail=predExpr;
				tail=&predExpr->right;
			};
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	
	_retv=ANDnode;
	ANDnode=NULL;
	zzEXIT(zztasp1);
	return _retv;
fail:
	zzEXIT(zztasp1);
	predicate_free(ANDnode);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x1);
	return _retv;
	}
}

 Predicate *
#ifdef __USE_PROTOS
predPrimary(void)
#else
predPrimary()
#endif
{
	 Predicate * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( Predicate * 	))
	zzMake0;
	{
	
	char          *name=NULL;
	PredEntry     *predEntry=NULL;
	Predicate     *predExpr=NULL;
	int           inverted=0;
	if ( (LA(1)==TokenTerm) ) {
		zzmatch(TokenTerm);
		name=mystrdup(LATEXT(1));
 zzCONSUME;

		
		predEntry=(PredEntry *) hash_get(Pname,name);
		if (predEntry == NULL) {
			warnFL(eMsg1("no previously defined #pred with name \"%s\"",name),
			FileStr[CurFile],zzline);
			name=NULL;
			_retv=NULL;
		} else {
			predExpr=predicate_dup(predEntry->pred);
			predExpr->predEntry=predEntry;
			_retv=predExpr;
		};
	}
	else {
		if ( (LA(1)==112) ) {
			zzmatch(112); zzCONSUME;
			 predExpr  = predOrExpr();

			zzmatch(113);
			
			_retv=predExpr;
 zzCONSUME;

		}
		else {
			if ( (LA(1)==101) ) {
				zzmatch(101); zzCONSUME;
				 predExpr  = predPrimary();

				
				predExpr->inverted=!predExpr->inverted;
				_retv=predExpr;
			}
			else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
		}
	}
	zzEXIT(zztasp1);
	return _retv;
fail:
	zzEXIT(zztasp1);
	
	predicate_free(predExpr);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x2);
	return _retv;
	}
}

void
#ifdef __USE_PROTOS
aLexclass(void)
#else
aLexclass()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(114); zzCONSUME;
	zzmatch(TokenTerm);
	lexclass(mystrdup(LATEXT(1)));
 zzCONSUME;

	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x4);
	}
}

void
#ifdef __USE_PROTOS
error(void)
#else
error()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *t=NULL; ECnode *e; int go=1; TermEntry *p;
	zzmatch(115); zzCONSUME;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		;
		if ( (LA(1)==TokenTerm) ) {
			zzmatch(TokenTerm);
			t=mystrdup(LATEXT(1));
 zzCONSUME;

		}
		else {
			if ( (LA(1)==QuotedTerm) ) {
				zzmatch(QuotedTerm);
				t=mystrdup(LATEXT(1));
 zzCONSUME;

			}
			else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
		}
		zzEXIT(zztasp2);
		}
	}
	e = newECnode;
	require(e!=NULL, "cannot allocate error class node");
	e->lexclass = CurrentLexClass;
	if ( Tnum( (t=StripQuotes(t)) ) == 0 )
	{
		if ( hash_get(Texpr, t) != NULL )
		warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
		e->tok = addTname( t );
		set_orel(e->tok, &imag_tokens);
		require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
		"hash table mechanism is broken");
		p->classname = 1;	/* entry is errclass name, not token */
		list_add(&eclasses, (char *)e);
	}
	else
	{
	warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
	free( (char *)e );
	go=0;
}
	zzmatch(100); zzCONSUME;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==NonTerminal) ) {
			zzmatch(NonTerminal);
			if ( go ) t=mystrdup(LATEXT(1));
 zzCONSUME;

		}
		else {
			if ( (LA(1)==TokenTerm) ) {
				zzmatch(TokenTerm);
				if ( go ) t=mystrdup(LATEXT(1));
 zzCONSUME;

			}