protected void checkError(ErrorQueue equeue,
GrammarSemanticsMessage expectedMessage)
//throws Exception
{
/*
* System.out.println(equeue.infos);
* System.out.println(equeue.warnings);
* System.out.println(equeue.errors);
*/
Message foundMsg = null;
for (int i = 0; i < equeue.errors.Count; i++)
{
Message m = (Message)equeue.errors[i];
if (m.msgID == expectedMessage.msgID)
{
foundMsg = m;
}
}
assertTrue("no error; " + expectedMessage.msgID + " expected", equeue.errors.Count > 0);
assertTrue("too many errors; " + equeue.errors, equeue.errors.Count <= 1);
assertTrue("couldn't find expected error: " + expectedMessage.msgID, foundMsg != null);
assertTrue("error is not a GrammarSemanticsMessage",
foundMsg is GrammarSemanticsMessage);
assertEquals(expectedMessage.arg, foundMsg.arg);
assertEquals(expectedMessage.arg2, foundMsg.arg2);
}
public void TestCannotHaveSpaceAfterDot() /*throws Exception*/
{
string action = "%x. y = z;";
//String expecting = null;
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
Grammar g = new Grammar(
"grammar t;\n" +
"options {\n" +
" output=template;\n" +
"}\n" +
"\n" +
"a : ID {" + action + "}\n" +
" ;\n" +
"\n" +
"ID : 'a';\n");
AntlrTool antlr = newTool();
CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
g.CodeGenerator = generator;
generator.GenRecognizer(); // forces load of templates
int expectedMsgID = ErrorManager.MSG_INVALID_TEMPLATE_ACTION;
object expectedArg = "%x.";
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkError(equeue, expectedMessage);
}
public void TestSameStringTwoNames() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
string slave =
"parser grammar S;\n" +
"tokens { A='a'; }\n" +
"x : A {System.out.println(\"S.x\");} ;\n";
mkdir(tmpdir);
writeFile(tmpdir, "S.g", slave);
string slave2 =
"parser grammar T;\n" +
"tokens { X='a'; }\n" +
"y : X {System.out.println(\"T.y\");} ;\n";
mkdir(tmpdir);
writeFile(tmpdir, "T.g", slave2);
string master =
"grammar M;\n" +
"import S,T;\n" +
"s : x y ;\n" +
"WS : (' '|'\\n') {skip();} ;\n";
writeFile(tmpdir, "M.g", master);
AntlrTool antlr = newTool(new string[] { "-lib", tmpdir });
CompositeGrammar composite = new CompositeGrammar();
Grammar g = new Grammar(antlr, tmpdir + "/M.g", composite);
composite.SetDelegationRoot(g);
g.ParseAndBuildAST();
g.composite.AssignTokenTypes();
string expectedTokenIDToTypeMap = "[A=4, WS=5, X=6]";
string expectedStringLiteralToTypeMap = "{'a'=4}";
string expectedTypeToTokenList = "[A, WS, X]";
Assert.AreEqual(expectedTokenIDToTypeMap,
realElements(g.composite.TokenIDToTypeMap).ToElementString());
Assert.AreEqual(expectedStringLiteralToTypeMap, g.composite.StringLiteralToTypeMap.ToElementString());
Assert.AreEqual(expectedTypeToTokenList,
realElements(g.composite.TypeToTokenList).ToElementString());
object expectedArg = "X='a'";
object expectedArg2 = "A";
int expectedMsgID = ErrorManager.MSG_TOKEN_ALIAS_CONFLICT;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);
checkGrammarSemanticsError(equeue, expectedMessage);
Assert.AreEqual(1, equeue.errors.Count, "unexpected errors: " + equeue);
string expectedError =
"error(158): T.g:2:10: cannot alias X='a'; string already assigned to A";
Assert.AreEqual(expectedError, equeue.errors[0].ToString());
}
public void TestSameNameTwoStrings() /*throws Exception*/
{
Assert.Inconclusive("May be failing on just my port...");
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
string slave =
"parser grammar S;\n" +
"tokens { A='a'; }\n" +
"x : A {System.out.println(\"S.x\");} ;\n";
mkdir(tmpdir);
writeFile(tmpdir, "S.g", slave);
string slave2 =
"parser grammar T;\n" +
"tokens { A='x'; }\n" +
"y : A {System.out.println(\"T.y\");} ;\n";
writeFile(tmpdir, "T.g", slave2);
string master =
"grammar M;\n" +
"import S,T;\n" +
"s : x y ;\n" +
"WS : (' '|'\\n') {skip();} ;\n";
writeFile(tmpdir, "M.g", master);
AntlrTool antlr = newTool(new string[] { "-lib", tmpdir });
CompositeGrammar composite = new CompositeGrammar();
Grammar g = new Grammar(antlr, tmpdir + "/M.g", composite);
composite.SetDelegationRoot(g);
g.ParseAndBuildAST();
g.composite.AssignTokenTypes();
string expectedTokenIDToTypeMap = "[A=4, T__6=6, WS=5]";
string expectedStringLiteralToTypeMap = "{'a'=4, 'x'=6}";
string expectedTypeToTokenList = "[A, WS, T__6]";
assertEquals(expectedTokenIDToTypeMap,
realElements(g.composite.tokenIDToTypeMap).ToElementString());
assertEquals(expectedStringLiteralToTypeMap, sortMapToString(g.composite.stringLiteralToTypeMap));
assertEquals(expectedTypeToTokenList,
realElements(g.composite.typeToTokenList).ToElementString());
object expectedArg = "A='x'";
object expectedArg2 = "'a'";
int expectedMsgID = ErrorManager.MSG_TOKEN_ALIAS_REASSIGNMENT;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);
checkGrammarSemanticsError(equeue, expectedMessage);
assertEquals("unexpected errors: " + equeue, 1, equeue.errors.Count);
string expectedError =
"error(159): T.g:2:10: cannot alias A='x'; token name already assigned to 'a'";
assertEquals(expectedError, equeue.errors[0].ToString());
}
public void TestMessageStringificationIsConsistent() /*throws Exception*/
{
string action = "$other.tree = null;";
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
Grammar g = new Grammar(
"grammar a;\n" +
"options { output = AST;}" +
"otherrule\n" +
" : 'y' ;" +
"rule\n" +
" : other=otherrule {" + action + "}\n" +
" ;");
AntlrTool antlr = newTool();
CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
g.CodeGenerator = generator;
generator.GenRecognizer(); // forces load of templates
ActionTranslator translator = new ActionTranslator(generator,
"rule",
new CommonToken(ANTLRParser.ACTION, action), 1);
string rawTranslation =
translator.Translate();
int expectedMsgID = ErrorManager.MSG_WRITE_TO_READONLY_ATTR;
object expectedArg = "other";
object expectedArg2 = "tree";
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);
string expectedMessageString = expectedMessage.ToString();
Assert.AreEqual(expectedMessageString, expectedMessage.ToString());
}
public void TestParserRuleInLexer() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"lexer grammar t;\n" +
"a : ;");
object expectedArg = "a";
int expectedMsgID = ErrorManager.MSG_PARSER_RULES_NOT_ALLOWED;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestUndefinedRule() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"grammar t;\n" +
"x : r ;");
object expectedArg = "r";
int expectedMsgID = ErrorManager.MSG_UNDEFINED_RULE_REF;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestUndefinedToken() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"grammar t;\n" +
"x : ID ;");
object expectedArg = "ID";
int expectedMsgID = ErrorManager.MSG_NO_TOKEN_DEFINITION;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsWarning(equeue, expectedMessage);
}
public void TestParserCharLiterals() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
Grammar g = new Grammar(
"parser grammar t;\n" +
"a : '(' b ;\n" +
"b : C ;");
object expectedArg = "'('";
int expectedMsgID = ErrorManager.MSG_LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestLexerRuleRedefinition() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"lexer grammar t;\n" +
"ID : 'a' ;\n" +
"ID : 'd' ;");
object expectedArg = "ID";
int expectedMsgID = ErrorManager.MSG_RULE_REDEFINITION;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestEmptyNotSet() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
Grammar g = new Grammar(
"grammar foo;\n" +
"a : (~(A|B))+ ;\n");
g.BuildNFA();
object expectedArg = null;
int expectedMsgID = ErrorManager.MSG_EMPTY_COMPLEMENT;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestLabelAndParameterConflict() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"parser grammar t;\n" +
"a[int i] returns [int x]: x=ID \n" +
" ;\n");
object expectedArg = "x";
int expectedMsgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_RULE_ARG_RETVAL;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestBadRuleOption() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"grammar t;\n" +
"a\n" +
"options {k=3; tokenVocab=blort;}\n" +
" : 'a';\n");
object expectedArg = "tokenVocab";
int expectedMsgID = ErrorManager.MSG_ILLEGAL_OPTION;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestCharLiteralInLexerTokensSection() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"lexer grammar t;\n" +
"tokens {\n" +
" B='(';\n" +
"}\n" +
"ID : 'a';\n");
object expectedArg = "'('";
int expectedMsgID = ErrorManager.MSG_CANNOT_ALIAS_TOKENS_IN_LEXER;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestBadGrammarOption() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
AntlrTool antlr = newTool();
Grammar g = new Grammar(antlr,
"grammar t;\n" +
"options {foo=3; language=Java;}\n" +
"a : 'a';\n");
object expectedArg = "foo";
int expectedMsgID = ErrorManager.MSG_ILLEGAL_OPTION;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestImportedTokenVocabIgnoredWithWarning() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue);
string slave =
"parser grammar S;\n" +
"options {tokenVocab=whatever;}\n" +
"tokens { A='a'; }\n" +
"x : A {System.out.println(\"S.x\");} ;\n";
mkdir(tmpdir);
writeFile(tmpdir, "S.g", slave);
string master =
"grammar M;\n" +
"import S;\n" +
"s : x ;\n" +
"WS : (' '|'\\n') {skip();} ;\n";
writeFile(tmpdir, "M.g", master);
AntlrTool antlr = newTool(new string[] { "-lib", tmpdir });
CompositeGrammar composite = new CompositeGrammar();
Grammar g = new Grammar(antlr, tmpdir + "/M.g", composite);
composite.SetDelegationRoot(g);
g.ParseAndBuildAST();
g.composite.AssignTokenTypes();
object expectedArg = "S";
int expectedMsgID = ErrorManager.MSG_TOKEN_VOCAB_IN_DELEGATE;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsWarning(equeue, expectedMessage);
assertEquals("unexpected errors: " + equeue, 0, equeue.errors.Count);
assertEquals("unexpected errors: " + equeue, 1, equeue.warnings.Count);
string expectedError =
"warning(160): S.g:2:10: tokenVocab option ignored in imported grammar S";
assertEquals(expectedError, equeue.warnings[0].ToString());
}
public void TestCharLiteralInParserTokensSection() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"parser grammar t;\n" +
"tokens {\n" +
" B='(';\n" +
"}\n" +
"a : A B;\n" +
"b : C ;");
object expectedArg = "'('";
int expectedMsgID = ErrorManager.MSG_LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestLabelAndTokenNameConflict() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"parser grammar t;\n" +
"a : ID=b \n" +
" ;\n" +
"b : ID ;\n" +
"c : ;\n");
object expectedArg = "ID";
int expectedMsgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_TOKEN;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestBadSubRuleOption() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"grammar t;\n" +
"a : ( options {k=3; language=Java;}\n" +
" : 'a'\n" +
" | 'b'\n" +
" )\n" +
" ;\n");
object expectedArg = "language";
int expectedMsgID = ErrorManager.MSG_ILLEGAL_OPTION;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
public void TestTokenLabelScopeConflict() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"parser grammar t;\n" +
"scope s {\n" +
" int n;\n" +
"}\n" +
"a : s=ID \n" +
" ;\n");
object expectedArg = "s";
int expectedMsgID = ErrorManager.MSG_SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg);
checkGrammarSemanticsError(equeue, expectedMessage);
}
protected void checkGrammarSemanticsWarning(ErrorQueue equeue,
GrammarSemanticsMessage expectedMessage)
{
ANTLRMessage foundMsg = null;
for (int i = 0; i < equeue.warnings.Count; i++)
{
ANTLRMessage m = equeue.warnings.get(i);
if (m.getErrorType() == expectedMessage.getErrorType())
{
foundMsg = m;
}
}
assertNotNull("no error; " + expectedMessage.getErrorType() + " expected", foundMsg);
Assert.IsTrue("error is not a GrammarSemanticsMessage",
foundMsg is GrammarSemanticsMessage);
assertEquals(Arrays.tostring(expectedMessage.getArgs()), Arrays.tostring(foundMsg.getArgs()));
if (equeue.Count != 1)
{
Console.Error.WriteLine(equeue);
}
}
public void TestRuleScopeRuleNameConflict() /*throws Exception*/
{
ErrorQueue equeue = new ErrorQueue();
ErrorManager.SetErrorListener(equeue); // unique listener per thread
Grammar g = new Grammar(
"parser grammar t;\n" +
"a\n" +
"scope {" +
" int a;" +
"}\n" +
" : \n" +
" ;\n");
object expectedArg = "a";
object expectedArg2 = null;
int expectedMsgID = ErrorManager.MSG_ATTRIBUTE_CONFLICTS_WITH_RULE;
GrammarSemanticsMessage expectedMessage =
new GrammarSemanticsMessage(expectedMsgID, g, null, expectedArg, expectedArg2);
checkGrammarSemanticsError(equeue, expectedMessage);
}
