antlr.c

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

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

				}
				else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
			}
		}
		zzEXIT(zztasp2);
		}
	}
	if ( go ) list_add(&(e->elist), t);
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (setwd3[LA(1)]&0x8) ) {
			{
				zzBLOCK(zztasp3);
				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;

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

						}
						else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
					}
				}
				zzEXIT(zztasp3);
				}
			}
			if ( go ) list_add(&(e->elist), t);
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	zzmatch(96); zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x10);
	}
}

void
#ifdef __USE_PROTOS
tclass(void)
#else
tclass()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *t=NULL; TCnode *e; int go=1,tok,totok; TermEntry *p, *term, *toterm;
	char *totext=NULL;
	zzmatch(116); zzCONSUME;
	zzmatch(TokenTerm);
	t=mystrdup(LATEXT(1));
 zzCONSUME;

	e = newTCnode;
	require(e!=NULL, "cannot allocate token class node");
	e->lexclass = CurrentLexClass;
	if ( Tnum( t ) == 0 )
	{
		e->tok = addTname( t );
		set_orel(e->tok, &imag_tokens);
		set_orel(e->tok, &tokclasses);
		require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
		"hash table mechanism is broken");
		p->classname = 1;	/* entry is class name, not token */
		p->tclass = e;		/* save ptr to this tclass def */
		list_add(&tclasses, (char *)e);
	}
	else
	{
	warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
	free( (char *)e );
	go=0;
}
	zzmatch(100); zzCONSUME;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (setwd3[LA(1)]&0x20) ) {
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (LA(1)==TokenTerm) ) {
					zzmatch(TokenTerm);
					if ( go ) {
						term = (TermEntry *) hash_get(Tname, LATEXT(1));
						if ( term==NULL && UserDefdTokens ) {
							err("implicit token definition not allowed with #tokdefs");
							go = 0;
						}
						else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
					}
 zzCONSUME;

					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==117) ) {
							zzmatch(117); zzCONSUME;
							zzmatch(TokenTerm);
							if ( go ) {
								toterm = (TermEntry *) hash_get(Tname, LATEXT(1));
								if ( toterm==NULL && UserDefdTokens ) {
									err("implicit token definition not allowed with #tokdefs");
									go = 0;
								} else {
									totext=mystrdup(LATEXT(1)); totok=addTname(LATEXT(1));
								}
							}
 zzCONSUME;

						}
						zzEXIT(zztasp4);
						}
					}
				}
				else {
					if ( (LA(1)==QuotedTerm) ) {
						zzmatch(QuotedTerm);
						if ( go ) {
							term = (TermEntry *) hash_get(Texpr, LATEXT(1));
							if ( term==NULL && UserDefdTokens ) {
								err("implicit token definition not allowed with #tokdefs");
								go = 0;
							}
							else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
						}
 zzCONSUME;

					}
					else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
				}
				zzEXIT(zztasp3);
				}
			}
			if ( go ) {
				if (totext == NULL) {
					list_add(&(e->tlist), t);
				} else {
					list_add(&(e->tlist),"..");
					list_add(&(e->tlist),t);
					list_add(&(e->tlist),totext);
				}
				totext=NULL;
			}
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	zzmatch(96); zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x40);
	}
}

void
#ifdef __USE_PROTOS
token(void)
#else
token()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	char *t=NULL, *e=NULL, *a=NULL; int tnum=0;
	char *akaString=NULL; TermEntry *te;int save_file=0,save_line=0;
	zzmatch(118);
	tokenActionActive=1;
 zzCONSUME;

	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==TokenTerm) ) {
			zzmatch(TokenTerm);
			t=mystrdup(LATEXT(1));
 zzCONSUME;

			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (LA(1)==112) ) {
					zzmatch(112); zzCONSUME;
					zzmatch(QuotedTerm);
					akaString=mystrdup(StripQuotes(LATEXT(1)));
					/* MR11 */                   save_file=CurFile;save_line=zzline;
					/* MR11 */
 zzCONSUME;

					zzmatch(113); zzCONSUME;
				}
				zzEXIT(zztasp3);
				}
			}
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (LA(1)==119) ) {
					zzmatch(119); zzCONSUME;
					zzmatch(120);
					tnum = atoi(LATEXT(1));
 zzCONSUME;

				}
				zzEXIT(zztasp3);
				}
			}
		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==QuotedTerm) ) {
			zzmatch(QuotedTerm);
			e=mystrdup(LATEXT(1));
 zzCONSUME;

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

		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==105) ) {
			zzmatch(105); zzCONSUME;
		}
		zzEXIT(zztasp2);
		}
	}
	chkToken(t, e, a, tnum);
	if (t != NULL) {
		te=(TermEntry *)hash_get(Tname,t);
		if (te != NULL && akaString != NULL) {
			if (te->akaString != NULL) {
				if (strcmp(te->akaString,akaString) != 0) {
					warnFL(eMsg2("this #token statment conflicts with a previous #token %s(\"%s\") statement",
					t,te->akaString),
					FileStr[save_file],save_line);
				};
			} else {
				te->akaString=akaString;
			};
		};
	};
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd3, 0x80);
	}
}

void
#ifdef __USE_PROTOS
block( set *toksrefd, set *rulesrefd )
#else
block(toksrefd,rulesrefd)
 set *toksrefd;
set *rulesrefd ;
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	
	Graph g, b;
	set saveblah;
	int saveinalt = inAlt;
	ExceptionGroup *eg;
	* toksrefd = empty;
	* rulesrefd = empty;
	set_clr(AST_nodes_refd_in_actions);
	CurBlockID++;
	CurAltNum = 1;
	saveblah = attribsRefdFromAction;
	attribsRefdFromAction = empty;
	alt( toksrefd,rulesrefd );
	b = g = zzaArg(zztasp1,1);
	
	if ( ((Junction *)g.left)->p1->ntype == nAction )
	{
		ActionNode *actionNode=(ActionNode *)
		( ( (Junction *)g.left) ->p1);
		if (!actionNode->is_predicate )
		{
			actionNode->init_action = TRUE;
			/* MR12c */  		if (actionNode->noHoist) {
				/* MR12c */           errFL("<<nohoist>> appears as init-action - use <<>> <<nohoist>>",
				/* MR12c */                       FileStr[actionNode->file],actionNode->line);
				/* MR12c */         };
		}
	}
	((Junction *)g.left)->blockid = CurBlockID;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==132) ) {
			 eg  = exception_group();

			
			if ( eg!=NULL ) {
				/* MR7 *****       	eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
				/* MR7 *****		CurAltStart->exception_label = eg->altID;           *****/
				list_add(&CurExGroups, (void *)eg);
			}
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	CurAltNum++;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==121) ) {
			zzmatch(121);
			inAlt=1;
 zzCONSUME;

			alt( toksrefd,rulesrefd );
			g = Or(g, zzaArg(zztasp2,2));
			
			((Junction *)g.left)->blockid = CurBlockID;
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				while ( (LA(1)==132) ) {
					 eg  = exception_group();

					
					if ( eg!=NULL ) {
						/* MR7 *****       	eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
						/* MR7 *****		CurAltStart->exception_label = eg->altID;           *****/
						list_add(&CurExGroups, (void *)eg);
					}
					zzLOOP(zztasp3);
				}
				zzEXIT(zztasp3);
				}
			}
			CurAltNum++;
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	zzaArg(zztasp1,0) = b;
	attribsRefdFromAction = saveblah; inAlt = saveinalt;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd4, 0x1);
	}
}

void
#ifdef __USE_PROTOS
alt( set *toksrefd, set *rulesrefd )
#else
alt(toksrefd,rulesrefd)
 set *toksrefd;
set *rulesrefd ;
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	int n=0,ne=0; Graph g; int e_num=0, not=0; Node *node; set elems, dif;
	int first_on_line = 1, use_def_MT_handler = 0;
	g.left=NULL; g.right=NULL;
	
			CurAltStart = NULL;
	elems = empty;
	inAlt = 1;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==88) ) {
			zzmatch(88);
			use_def_MT_handler = 1;
 zzCONSUME;

		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		;
		while ( (setwd4[LA(1)]&0x2) ) {
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				not=0;
				if ( (LA(1)==122) ) {
					zzmatch(122);
					not=1;
 zzCONSUME;

				}
				zzEXIT(zztasp3);
				}
			}
			 node  = element( not, first_on_line, use_def_MT_handler );

			if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;
			
			if ( zzaArg(zztasp2,2 ).left!=NULL ) {
				g = Cat(g, zzaArg(zztasp2,2));
				n++;
				if ( node!=NULL ) {
					if ( node->ntype!=nAction ) e_num++;
					/* record record number of all rule and token refs */
					if ( node->ntype==nToken ) {
						TokNode *tk = (TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
						tk->elnum = e_num;
						set_orel(e_num, &elems);
					}
					else if ( node->ntype==nRuleRef ) {
						RuleRefNode *rn = (RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
						rn->elnum = e_num;
						set_orel(e_num,  rulesrefd);
					}
				}
			}
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	if ( n == 0 ) g = emptyAlt();
	zzaArg(zztasp1,0) = g;
	/* We want to reduce number of LT(i) calls and the number of
	* local attribute variables in C++ mode (for moment, later we'll
	* do for C also).  However, if trees are being built, they
	* require most of the attrib variables to create the tree nodes
	* with; therefore, we gen a token ptr for each token ref in C++
	*/
	if ( GenCC && !GenAST )
	{
	/* This now free's the temp set -ATG 5/6/95 */
	set temp;
	temp = set_and(elems, attribsRefdFromAction);
	set_orin( toksrefd, temp);
	set_free(temp);
}
else set_orin( toksrefd, elems);
if ( GenCC ) {
	dif = set_dif(attribsRefdFromAction, elems);
	if ( set_deg(dif)>0 )
	err("one or more $i in action(s) refer to non-token elements");
	set_free(dif);
}
set_free(elems);
set_free(attribsRefdFromAction);
inAlt = 0;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd4, 0x4);
	}
}

 LabelEntry *
#ifdef __USE_PROTOS
element_label(void)
#else
element_label()
#endif
{
	 LabelEntry * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( LabelEntry * 	))
	zzMake0;
	{
	TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;
	zzmatch(LABEL);
	lab = mystrdup(LATEXT(1));
 zzCONSUME;

	
	UsedNewStyleLabel = 1;
	if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
	t = (TermEntry *) hash_get(Tname, lab);
	if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
	if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
	if ( t!=NULL ) {
		err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
		_retv = NULL;
	}
	else if ( r!=NULL ) {
		err(eMsg1("label definition clashes with rule definition: '%s'", lab));
		_retv = NULL;
	}
	else {
		/* we don't clash with anybody else */
		l = (LabelEntry *) hash_get(Elabel, lab);
		if ( l==NULL ) {	/* ok to add new element label */
		l = (LabelEntry *)hash_add(Elabel,
		lab,
		(Entry *)newLabelEntry(lab));
		/* add to list of element labels for this rule */
		list_add(&CurElementLabels, (void *)lab);
		/* MR7 */       leAdd(l);  /* list of labels waiting for exception group definitions */
		_retv = l;
	}
	else {
	err(eMsg1("label definitions must be unique per rule: '%s'", lab));
	_retv = NULL;