antlr.c

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

														predMsgDone=1;                                                /* MR10 */
													} else {                                                        /* MR10 */
														act->guardNodes=(Junction *)blk.left;                       /* MR11 */
														pred->expr = act->action;
														pred->source = act;
														/* MR10 */                  pred->ampersandStyle = ampersandStyle;  /* 0 means (g)? => ... 1 means (g)? && ... */
														/* MR13 */                  if (pred->tcontext != NULL) {
															/* MR13 */                    height=MR_max_height_of_tree(pred->tcontext);
															/* MR13 */                    equal_height=MR_all_leaves_same_height(pred->tcontext,height);
															/* MR13 */                    if (! equal_height) {
																/* MR13 */                       errFL("in guarded predicates all tokens in the guard must be at the same height",
																/* MR13 */                              FileStr[act->file],act->line);
																/* MR13 */                    };
															/* MR13 */                  }
														/* MR10 */                  if (ampersandStyle) {
															/* MR10 */			  		  act->ampersandPred = pred;
															/* MR11 */                    if (! HoistPredicateContext) {
																/* MR11 */                      errFL("without \"-prc on\" (guard)? && <<pred>>? ... doesn't make sense",
																/* MR11 */                              FileStr[act->file],act->line);
																/* MR11 */                    };
															/* MR10 */                  } else {
															/* MR10 */			  		  act->guardpred = pred;
															/* MR10 */                  };
														/* MR10 */                  if (pred->k != semDepth) {
															/* MR10 */                     warn(eMsgd2("length of guard (%d) does not match the length of semantic predicate (%d)",
															/* MR10 */                                  pred->k,semDepth));
															/* MR10 */                  };
													}
												}
												else {
													if ( (setwd5[LA(1)]&0x8) ) {
														zzaRet = makeBlk(zzaRet,approx);
														FoundGuessBlk = 1;
														((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
														if ( ! first_on_line ) {
															err("(...)? predicate must be first element of production");
														}
													}
													else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
												}
												zzEXIT(zztasp4);
												}
											}
										}
										else {
											if ( (setwd5[LA(1)]&0x10) ) {
												zzaRet = makeBlk(zzaRet,approx);
											}
											else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
										}
									}
								}
								zzEXIT(zztasp3);
								}
							}
							
							if ( pred==NULL && !predMsgDone) {                                      /* MR10 */
								((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
								((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
								((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
								if (  first_on_line ) {                         /* MR7 */
									CurAltStart = (Junction *)((Junction *)((Junction *)zzaRet.left)->p1);  /* MR7 */
									altAdd(CurAltStart);                         /* MR7 */
								};                                              /* MR7 */
								_retv = (Node *) ((Junction *)zzaRet.left)->p1;
							}
						}
						else {
							if ( (LA(1)==100) ) {
								zzmatch(100); zzCONSUME;
								block( &toksrefd,&rulesrefd );
								zzaRet = makeOpt(zzaArg(zztasp2,2),approx); --BlkLevel;
								zzmatch(96);
								
								((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
								((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
								((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
 zzCONSUME;

								if (  first_on_line ) {                            /* MR7 */
									CurAltStart = (Junction *) ((Junction *)((Junction *)zzaRet.left)->p1);  /* MR7 */
									altAdd(CurAltStart);                             /* MR7 */
								};
								_retv = (Node *) ((Junction *)zzaRet.left)->p1;
							}
							else {zzFAIL(1,zzerr19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
						}
						zzEXIT(zztasp2);
						}
					}
				}
				else {
					if ( (LA(1)==128) ) {
						zzmatch(128);
						warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;
 zzCONSUME;

					}
					else {
						if ( (LA(1)==129) ) {
							zzmatch(129);
							warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;
 zzCONSUME;

						}
						else {
							if ( (LA(1)==103) ) {
								zzmatch(103);
								warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;
 zzCONSUME;

							}
							else {
								if ( (LA(1)==PassAction) ) {
									zzmatch(PassAction);
									warn("[...] out of context 'rule > [...]'");
									CannotContinue=TRUE;
 zzCONSUME;

								}
								else {zzFAIL(1,zzerr20,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
							}
						}
					}
				}
			}
		}
	}
	zzEXIT(zztasp1);
	return _retv;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd5, 0x20);
	return _retv;
	}
}

void
#ifdef __USE_PROTOS
default_exception_handler(void)
#else
default_exception_handler()
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	 DefaultExGroup  = exception_group();

	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd5, 0x40);
	}
}

 ExceptionGroup *
#ifdef __USE_PROTOS
exception_group(void)
#else
exception_group()
#endif
{
	 ExceptionGroup * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( ExceptionGroup * 	))
	zzMake0;
	{
	ExceptionHandler *h; LabelEntry *label=NULL;	  /* MR6 */
	FoundException = 1; FoundExceptionGroup = 1;
	zzmatch(132);
	_retv = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));
 zzCONSUME;

	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		char *p;
		if ( (LA(1)==PassAction) ) {
			zzmatch(PassAction);
			
			p = LATEXT(1)+1;
			p[strlen(p)-1] = '\0';		/* kill trailing space */
			label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
			if ( label==NULL )
			{
				err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
			}
 zzCONSUME;

		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==134) ) {
			 h  = exception_handler();

			list_add(&(_retv->handlers), (void *)h);
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==133) ) {
			zzmatch(133); zzCONSUME;
			zzmatch(104); zzCONSUME;
			zzmatch(Action);
			{
				ExceptionHandler *eh = (ExceptionHandler *)
				calloc(1, sizeof(ExceptionHandler));
				char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
				require(eh!=NULL, "exception: cannot allocate handler");
				require(a!=NULL, "exception: cannot allocate action");
				strcpy(a, LATEXT(1));
				eh->action = a;
				eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
				require(eh->signalname!=NULL, "exception: cannot allocate sig name");
				strcpy(eh->signalname, "default");
				list_add(&(_retv->handlers), (void *)eh);
			}
 zzCONSUME;

		}
		zzEXIT(zztasp2);
		}
	}
	
	if ( label!=NULL ) {
		/* Record ex group in sym tab for this label */
		if ( label->ex_group!=NULL ) {
			err(eMsg1("duplicate exception handler for label '%s'",label->str));
		} else {
			label->ex_group = _retv;
			/* Label the exception group itself */
			_retv->label = label->str;
			/* Make the labelled element pt to the exception also */
			/* MR6 */	  if (label->elem == NULL) {
				/* MR6 */	     err(eMsg1("reference in exception handler to undefined label '%s'",label->str));
				/* MR6 */	  } else {
				switch ( label->elem->ntype ) {
					case nRuleRef :
					{
						RuleRefNode *r = (RuleRefNode *)label->elem;
						r->ex_group = _retv;
						break;
					}
					case nToken :
					{
						TokNode *t = (TokNode *)label->elem;
						t->ex_group = _retv;
						break;
					}
				} /* end switch */
				/* MR6 */	  }; /* end test on label->elem */
		} /* end test on label->ex_group */
		
		} /* end test on exception label */
	
/* MR7 */
	/* MR7 */   if (BlkLevel == 1 && label == NULL) {
		/* MR7 */     _retv->forRule=1;
		/* MR7 */   } else if (label == NULL) {
		/* MR7 */     _retv->altID = makeAltID(CurBlockID,CurAltNum);
		/* MR7 */     egAdd(_retv);
		/* MR7 */   } else {
		/* MR7 */     _retv->labelEntry=label;
		/* MR7 */   };
	/* MR7 */
	/* MR7 */	    /* You may want to remove this exc from the rule list  */
	/* MR7 */		/* and handle at the labeled element site.             */
	/* MR7 */
	/* MR7 */   if (label != NULL) {
		/* MR7 */     _retv = NULL;
		/* MR7 */   };
	zzEXIT(zztasp1);
	return _retv;
fail:
	zzEXIT(zztasp1);
	CannotContinue=TRUE;
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd5, 0x80);
	return _retv;
	}
}

 ExceptionHandler *
#ifdef __USE_PROTOS
exception_handler(void)
#else
exception_handler()
#endif
{
	 ExceptionHandler * 	 _retv;
	zzRULE;
	zzBLOCK(zztasp1);
	PURIFY(_retv,sizeof( ExceptionHandler * 	))
	zzMake0;
	{
	;
	zzmatch(134);
	
	_retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
	require(_retv!=NULL, "exception: cannot allocate handler");
 zzCONSUME;

	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==NonTerminal) ) {
			zzmatch(NonTerminal);
			
			_retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
			require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
			strcpy(_retv->signalname, LATEXT(1));
 zzCONSUME;

		}
		else {
			if ( (LA(1)==TokenTerm) ) {
				zzmatch(TokenTerm);
				
				_retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
				require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
				strcpy(_retv->signalname, LATEXT(1));
 zzCONSUME;

			}
			else {zzFAIL(1,zzerr21,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
		}
		zzEXIT(zztasp2);
		}
	}
	zzmatch(104); zzCONSUME;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		_retv->action = NULL;
		if ( (LA(1)==Action) ) {
			zzmatch(Action);
			
			_retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
			require(_retv->action!=NULL, "exception: cannot allocate action");
			strcpy(_retv->action, LATEXT(1));
 zzCONSUME;

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

void
#ifdef __USE_PROTOS
enum_file( char *fname )
#else
enum_file(fname)
 char *fname ;
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (setwd6[LA(1)]&0x2) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			if ( (LA(1)==142) ) {
				zzmatch(142); zzCONSUME;
				zzmatch(ID); zzCONSUME;
				{
					zzBLOCK(zztasp3);
					zzMake0;
					{
					if ( (LA(1)==148) ) {
						zzmatch(148); zzCONSUME;
						zzmatch(ID); zzCONSUME;
					}
					zzEXIT(zztasp3);
					}
				}
			}
			zzEXIT(zztasp2);
			}
		}
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			if ( (LA(1)==150) ) {
				{
					zzBLOCK(zztasp3);
					int zzcnt=1;
					zzMake0;
					{
					do {
						enum_def(  fname );
						zzLOOP(zztasp3);
					} while ( (LA(1)==150) );
					zzEXIT(zztasp3);
					}
				}
			}
			else {
				if ( (LA(1)==148) ) {
					defines(  fname );
				}
				else {zzFAIL(1,zzerr22,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else {
		if ( (LA(1)==Eof) ) {
		}
		else {zzFAIL(1,zzerr23,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
	}
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd6, 0x4);
	}
}

void
#ifdef __USE_PROTOS
defines( char *fname )
#else
defines(fname)
 char *fname ;
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	int v; int maxt=(-1); char *t;
	{
		zzBLOCK(zztasp2);
		int zzcnt=1;
		zzMake0;
		{
		do {
			zzmatch(148); zzCONSUME;
			zzmatch(ID);
			t = mystrdup(LATEXT(1));
 zzCONSUME;

			zzmatch(INT);
			
			v = atoi(LATEXT(1));
			/*			fprintf(stderr, "#token %s=%d\n", t, v);*/
			
	/* MR2 Andreas Magnusson ([e-mail]) */
			/* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
			/* MR2 Don't let #tokdefs be confused by 			*/
			/* MR2   DLGminToken and DLGmaxToken     			*/
			
			if ( ! isDLGmaxToken(t)) {		/* MR2 */
			TokenNum = v;
			if ( v>maxt ) maxt=v;
			if ( Tnum( t ) == 0 ) {
			addForcedTname( t, v );
		} else {
		warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
	};
};
 zzCONSUME;

			zzLOOP(zztasp2);
		} while ( (LA(1)==148) );
		zzEXIT(zztasp2);
		}
	}
	TokenNum = maxt + 1;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
	zzresynch(setwd6, 0x8);
	}
}

void
#ifdef __USE_PROTOS
enum_def( char *fname )
#else
enum_def(fname)
 char *fname ;
#endif
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	int v= 0; int maxt=(-1); char *t;
	zzmatch(150); zzCONSUME;
	zzmatch(ID); zzCONSUME;
	zzmatch(151); zzCONSUME;
	zzmatch(ID);
	t = mystrdup(LATEXT(1));
 zzCONSUME;

	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		if ( (LA(1)==152) ) {
			zzmatch(152); zzCONSUME;
			zzmatch(INT);
			v=atoi(LATEXT(1));
 zzCONSUME;

		}
		else {
			if ( (setwd6[LA(1)]&0x10) ) {
				v++;
			}
			else {zzFAIL(1,zzerr24,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
		}
		zzEXIT(zztasp2);
		}
	}
	
	/*			fprintf(stderr, "#token %s=%d\n", t, v);*/
	TokenNum = v;
	if ( v>maxt ) maxt=v;				/* MR3 */
	if ( Tnum( t ) == 0 ) addForcedTname( t, v );
	else {
		warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==153) ) {
			zzmatch(153); zzCONSUME;
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (LA(1)==ID)&&(isDLGmaxToken(LATEXT(1))) ) {
					if (!(isDLGmaxToken(LATEXT(1)))) {zzfailed_pred("  isDLGmaxToken(LATEXT(1))");}
					zzmatch(ID); zzCONSUME;
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==152) ) {
							zzmatch(152); zzCONSUME;
							zzmatch(INT); zzCONSUME;
						}
						zzEXIT(zztasp4);
						}
					}
				}
				else {
					if ( (LA(1)==ID) ) {