import org.antlr.tool.ErrorManager; //导入依赖的package包/类
protected void checkError(ErrorQueue equeue,
						  GrammarSemanticsMessage expectedMessage)
	throws Exception
{
	//System.out.println("errors="+equeue);
	Message foundMsg = null;
	for (int i = 0; i < equeue.errors.size(); i++) {
		Message m = (Message)equeue.errors.get(i);
		if (m.msgID==expectedMessage.msgID ) {
			foundMsg = m;
		}
	}
	assertTrue("no error; "+expectedMessage.msgID+" expected", equeue.errors.size()>0);
	assertTrue("too many errors; "+equeue.errors, equeue.errors.size()<=1);
	assertNotNull("couldn't find expected error: "+expectedMessage.msgID, foundMsg);
	assertTrue("error is not a GrammarSemanticsMessage",
			   foundMsg instanceof GrammarSemanticsMessage);
	assertEquals(expectedMessage.arg, foundMsg.arg);
	assertEquals(expectedMessage.arg2, foundMsg.arg2);
	ErrorManager.resetErrorState(); // wack errors for next test
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testRewriteRuleAndRewriteModeOnSimpleElements() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);
	Grammar g = new Grammar(
		"tree grammar TP;\n"+
		"options {ASTLabelType=CommonTree; output=template; rewrite=true;}\n" +
		"a: ^(A B) -> {ick}\n" +
		" | y+=INT -> {ick}\n" +
		" | x=ID -> {ick}\n" +
		" | BLORT -> {ick}\n" +
		" ;\n"
	);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	assertEquals("unexpected errors: "+equeue, 0, equeue.warnings.size());
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testRewriteRuleAndRewriteModeIgnoreActionsPredicates() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);
	Grammar g = new Grammar(
		"tree grammar TP;\n"+
		"options {ASTLabelType=CommonTree; output=template; rewrite=true;}\n" +
		"a: {action} {action2} x=A -> {ick}\n" +
		" | {pred1}? y+=B -> {ick}\n" +
		" | C {action} -> {ick}\n" +
		" | {pred2}?=> z+=D -> {ick}\n" +
		" | (E)=> ^(F G) -> {ick}\n" +
		" ;\n"
	);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	assertEquals("unexpected errors: "+equeue, 0, equeue.warnings.size());
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testRewriteRuleAndRewriteModeNotSimple() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);
	Grammar g = new Grammar(
		"tree grammar TP;\n"+
		"options {ASTLabelType=CommonTree; output=template; rewrite=true;}\n" +
		"a  : ID+ -> {ick}\n" +
		"   | INT INT -> {ick}\n" +
		"   ;\n"
	);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	assertEquals("unexpected errors: "+equeue, 2, equeue.warnings.size());
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testRewriteRuleAndRewriteModeRefRule() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);
	Grammar g = new Grammar(
		"tree grammar TP;\n"+
		"options {ASTLabelType=CommonTree; output=template; rewrite=true;}\n" +
		"a  : b+ -> {ick}\n" +
		"   | b b A -> {ick}\n" +
		"   ;\n" +
		"b  : B ;\n"
	);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	assertEquals("unexpected errors: "+equeue, 2, equeue.warnings.size());
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void addTransition(Transition e) {
	if ( e==null ) {
		throw new IllegalArgumentException("You can't add a null transition");			
	}
	if ( numTransitions>transition.length ) {
		throw new IllegalArgumentException("You can only have "+transition.length+" transitions");
	}
	if ( e!=null ) {
		transition[numTransitions] = e;
		numTransitions++;
		// Set the "back pointer" of the target state so that it
		// knows about the label of the incoming edge.
		Label label = e.label;
		if ( label.isAtom() || label.isSet() ) {
			if ( ((NFAState)e.target).incidentEdgeLabel!=null ) {
				ErrorManager.internalError("Clobbered incident edge");
			}
			((NFAState)e.target).incidentEdgeLabel = e.label;
		}
	}
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testWeirdRuleRef() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);
	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : ID a -> $a | INT ;\n"+
		"ID : 'a'..'z'+ ;\n" +
		"INT: '0'..'9'+ ;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	// $a is ambig; is it previous root or ref to a ref in alt?
	assertEquals("unexpected errors: "+equeue, 1, equeue.errors.size());		
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public int size() {
     if ( elements.size()!=super.size() ) {
ErrorManager.internalError("OrderedHashSet: elements and set size differs; "+
						   elements.size()+"!="+super.size());
     }
     return elements.size();
 }
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void run() {
	for (int decision=i; decision<=j; decision++) {
		NFAState decisionStartState = grammar.getDecisionNFAStartState(decision);
		if ( decisionStartState.getNumberOfTransitions()>1 ) {
			grammar.createLookaheadDFA(decision);
		}
	}
	// now wait for others to finish
	try {
		barrier.waitForRelease();
	}
	catch(InterruptedException e) {
		ErrorManager.internalError("what the hell? DFA interruptus", e);
	}
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testUnknownRule() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> ugh ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_UNDEFINED_RULE_REF;
	Object expectedArg = "ugh";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testKnownRuleButNotInLHS() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> b ;\n" +
		"b : 'b' ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_REWRITE_ELEMENT_NOT_PRESENT_ON_LHS;
	Object expectedArg = "b";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testUnknownToken() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> ICK ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_UNDEFINED_TOKEN_REF_IN_REWRITE;
	Object expectedArg = "ICK";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testUnknownLabel() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> $foo ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_UNDEFINED_LABEL_REF_IN_REWRITE;
	Object expectedArg = "foo";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testUnknownCharLiteralToken() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> 'a' ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_UNDEFINED_TOKEN_REF_IN_REWRITE;
	Object expectedArg = "'a'";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void testUnknownStringLiteralToken() throws Exception {
	ErrorQueue equeue = new ErrorQueue();
	ErrorManager.setErrorListener(equeue);

	String grammar =
		"grammar T;\n" +
		"options {output=AST;}\n" +
		"a : INT -> 'foo' ;\n" +
		"ID : 'a'..'z'+ ;\n" +
		"INT : '0'..'9'+;\n" +
		"WS : (' '|'\\n') {$channel=HIDDEN;} ;\n";

	Grammar g = new Grammar(grammar);
	Tool antlr = newTool();
	antlr.setOutputDirectory(null); // write to /dev/null
	CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
	g.setCodeGenerator(generator);
	generator.genRecognizer();

	int expectedMsgID = ErrorManager.MSG_UNDEFINED_TOKEN_REF_IN_REWRITE;
	Object expectedArg = "'foo'";
	Object expectedArg2 = null;
	GrammarSemanticsMessage expectedMessage =
		new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);

	checkError(equeue, expectedMessage);
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
public void run() {
	for (int decision=i; decision<=j; decision++) {
		NFAState decisionStartState = grammar.getDecisionNFAStartState(decision);
		if ( decisionStartState.getNumberOfTransitions()>1 ) {
			grammar.createLookaheadDFA(decision,true);
		}
	}
	// now wait for others to finish
	try {
		barrier.waitForRelease();
	}
	catch(InterruptedException e) {
		ErrorManager.internalError("what the hell? DFA interruptus", e);
	}
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
protected void issueRecursionWarnings() {
	// RECURSION OVERFLOW
	Set dfaStatesWithRecursionProblems =
		stateToRecursionOverflowConfigurationsMap.keySet();
	// now walk truly unique (unaliased) list of dfa states with inf recur
	// Goal: create a map from alt to map<target,List<callsites>>
	// Map<Map<String target, List<NFAState call sites>>
	Map altToTargetToCallSitesMap = new HashMap();
	// track a single problem DFA state for each alt
	Map altToDFAState = new HashMap();
	computeAltToProblemMaps(dfaStatesWithRecursionProblems,
							stateToRecursionOverflowConfigurationsMap,
							altToTargetToCallSitesMap, // output param
							altToDFAState);            // output param

	// walk each alt with recursion overflow problems and generate error
	Set alts = altToTargetToCallSitesMap.keySet();
	List sortedAlts = new ArrayList(alts);
	Collections.sort(sortedAlts);
	for (Iterator altsIt = sortedAlts.iterator(); altsIt.hasNext();) {
		Integer altI = (Integer) altsIt.next();
		Map targetToCallSiteMap =
			(Map)altToTargetToCallSitesMap.get(altI);
		Set targetRules = targetToCallSiteMap.keySet();
		Collection callSiteStates = targetToCallSiteMap.values();
		DFAState sampleBadState = (DFAState)altToDFAState.get(altI);
		ErrorManager.recursionOverflow(this,
									   sampleBadState,
									   altI.intValue(),
									   targetRules,
									   callSiteStates);
	}
}
 

import org.antlr.tool.ErrorManager; //导入依赖的package包/类
/**
 * @see IActionDelegate#run(IAction)
 */
public void run(IAction action) {
	
	ErrorManager.resetErrorState();
	ErrorManager.setErrorListener(this);
			
	writeMessage("Compile: " + iAntLRSourceFile.getLocationURI().toString());
			
	Tool antLRCompiler;		
	antLRCompiler = new Tool(new String[] {new File(iAntLRSourceFile.getLocationURI()).getAbsolutePath()});
	
	antLRCompiler.process();
	
	if (ErrorManager.getNumErrors() == 0) {
		writeMessage("Compile AntLR grammar was executed.");
		MessageDialog.openInformation(shell,
									  "ParserTools",
									   "Compile AntLR grammar was executed.");
	} else {
		writeMessage("Cannot compile AntLT grammar");
	}
	
	
	try {
		iProject.refreshLocal(IResource.DEPTH_INFINITE, null);
	} catch (CoreException e) {

	}
}