Example 6 with org.antlr.v4.runtime.tree
use of org.antlr.v4.runtime.tree in project antlr4 by tunnelvisionlabs.
the class TimeLexerSpeed method lex_legacy_grapheme_utf8.
public void lex_legacy_grapheme_utf8(String fileName, int n, boolean clearLexerDFACache) throws Exception {
InputStream is = TimeLexerSpeed.class.getClassLoader().getResourceAsStream(PerfDir + "/" + fileName);
try {
InputStreamReader isr = new InputStreamReader(is, Charset.forName("UTF-8"));
try {
BufferedReader br = new BufferedReader(isr);
try {
@SuppressWarnings("deprecation") CharStream input = new org.antlr.v4.runtime.ANTLRInputStream(br);
graphemesLexer lexer = new graphemesLexer(input);
double avg = tokenize(lexer, n, clearLexerDFACache);
String currentMethodName = new Exception().getStackTrace()[0].getMethodName();
if (output)
System.out.printf("%27s average time %5dus over %4d runs of %5d symbols from %s%s\n", currentMethodName, (int) avg, n, input.size(), fileName, clearLexerDFACache ? " DFA cleared" : "");
} finally {
br.close();
}
} finally {
isr.close();
}
} finally {
is.close();
}
}
Also used :
InputStreamReader(java.io.InputStreamReader)
InputStream(java.io.InputStream)
CharStream(org.antlr.v4.runtime.CharStream)
IOException(java.io.IOException)
BufferedReader(java.io.BufferedReader)
Example 7 with org.antlr.v4.runtime.tree
use of org.antlr.v4.runtime.tree in project antlr4 by antlr.
the class ParserATNFactory method createATN.
@Override
public ATN createATN() {
_createATN(g.rules.values());
assert atn.maxTokenType == g.getMaxTokenType();
addRuleFollowLinks();
addEOFTransitionToStartRules();
ATNOptimizer.optimize(g, atn);
for (Triple<Rule, ATNState, ATNState> pair : preventEpsilonClosureBlocks) {
LL1Analyzer analyzer = new LL1Analyzer(atn);
ATNState blkStart = pair.b;
ATNState blkStop = pair.c;
IntervalSet lookahead = analyzer.LOOK(blkStart, blkStop, null);
if (lookahead.contains(org.antlr.v4.runtime.Token.EPSILON)) {
ErrorType errorType = pair.a instanceof LeftRecursiveRule ? ErrorType.EPSILON_LR_FOLLOW : ErrorType.EPSILON_CLOSURE;
g.tool.errMgr.grammarError(errorType, g.fileName, ((GrammarAST) pair.a.ast.getChild(0)).getToken(), pair.a.name);
}
}
optionalCheck: for (Triple<Rule, ATNState, ATNState> pair : preventEpsilonOptionalBlocks) {
int bypassCount = 0;
for (int i = 0; i < pair.b.getNumberOfTransitions(); i++) {
ATNState startState = pair.b.transition(i).target;
if (startState == pair.c) {
bypassCount++;
continue;
}
LL1Analyzer analyzer = new LL1Analyzer(atn);
if (analyzer.LOOK(startState, pair.c, null).contains(org.antlr.v4.runtime.Token.EPSILON)) {
g.tool.errMgr.grammarError(ErrorType.EPSILON_OPTIONAL, g.fileName, ((GrammarAST) pair.a.ast.getChild(0)).getToken(), pair.a.name);
continue optionalCheck;
}
}
if (bypassCount != 1) {
throw new UnsupportedOperationException("Expected optional block with exactly 1 bypass alternative.");
}
}
return atn;
}
Also used :
LeftRecursiveRule(org.antlr.v4.tool.LeftRecursiveRule)
Triple(org.antlr.v4.runtime.misc.Triple)
LL1Analyzer(org.antlr.v4.runtime.atn.LL1Analyzer)
ErrorType(org.antlr.v4.tool.ErrorType)
IntervalSet(org.antlr.v4.runtime.misc.IntervalSet)
GrammarAST(org.antlr.v4.tool.ast.GrammarAST)
Rule(org.antlr.v4.tool.Rule)
LeftRecursiveRule(org.antlr.v4.tool.LeftRecursiveRule)
ATNState(org.antlr.v4.runtime.atn.ATNState)
Example 8 with org.antlr.v4.runtime.tree
use of org.antlr.v4.runtime.tree in project sts4 by spring-projects.
the class AntlrParser method parse.
@Override
public ParseResults parse(String text) {
ArrayList<Problem> syntaxErrors = new ArrayList<>();
ArrayList<Problem> problems = new ArrayList<>();
ArrayList<PropertiesAst.Node> astNodes = new ArrayList<>();
JavaPropertiesLexer lexer = new JavaPropertiesLexer(new ANTLRInputStream(text.toCharArray(), text.length()));
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavaPropertiesParser parser = new JavaPropertiesParser(tokens);
// To avoid printing parse errors in the console
parser.removeErrorListener(ConsoleErrorListener.INSTANCE);
// Add listener to collect various parser errors
parser.addErrorListener(new ANTLRErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
syntaxErrors.add(createProblem(msg, ProblemCodes.PROPERTIES_SYNTAX_ERROR, (Token) offendingSymbol));
}
@Override
public void reportAmbiguity(org.antlr.v4.runtime.Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) {
problems.add(createProblem("Ambiguity detected!", ProblemCodes.PROPERTIES_AMBIGUITY_ERROR, recognizer.getCurrentToken()));
}
@Override
public void reportAttemptingFullContext(org.antlr.v4.runtime.Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs) {
problems.add(createProblem("Full-Context attempt detected!", ProblemCodes.PROPERTIES_FULL_CONTEXT_ERROR, recognizer.getCurrentToken()));
}
@Override
public void reportContextSensitivity(org.antlr.v4.runtime.Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs) {
problems.add(createProblem("Context sensitivity detected!", ProblemCodes.PROPERTIES_CONTEXT_SENSITIVITY_ERROR, recognizer.getCurrentToken()));
}
});
// Add listener to the parse tree to collect AST nodes
parser.addParseListener(new JavaPropertiesBaseListener() {
private Key key = null;
private Value value = null;
@Override
public void exitPropertyLine(PropertyLineContext ctx) {
KeyValuePair pair = new KeyValuePair(ctx, key, value);
key.parent = value.parent = pair;
astNodes.add(pair);
key = null;
value = null;
}
@Override
public void exitCommentLine(CommentLineContext ctx) {
astNodes.add(new Comment(ctx));
}
@Override
public void exitKey(KeyContext ctx) {
key = new Key(ctx);
}
@Override
public void exitSeparatorAndValue(SeparatorAndValueContext ctx) {
value = new Value(ctx);
}
@Override
public void exitEmptyLine(EmptyLineContext ctx) {
astNodes.add(new EmptyLine(ctx));
}
});
parser.parse();
// Collect and return parse results
return new ParseResults(new PropertiesAst(ImmutableList.copyOf(astNodes)), ImmutableList.copyOf(syntaxErrors), ImmutableList.copyOf(problems));
}
Also used :
ATNConfigSet(org.antlr.v4.runtime.atn.ATNConfigSet)
CommentLineContext(org.springframework.ide.vscode.java.properties.antlr.parser.JavaPropertiesParser.CommentLineContext)
ArrayList(java.util.ArrayList)
ANTLRErrorListener(org.antlr.v4.runtime.ANTLRErrorListener)
PropertiesAst(org.springframework.ide.vscode.java.properties.parser.PropertiesAst)
KeyContext(org.springframework.ide.vscode.java.properties.antlr.parser.JavaPropertiesParser.KeyContext)
SeparatorAndValueContext(org.springframework.ide.vscode.java.properties.antlr.parser.JavaPropertiesParser.SeparatorAndValueContext)
EmptyLineContext(org.springframework.ide.vscode.java.properties.antlr.parser.JavaPropertiesParser.EmptyLineContext)
CommonTokenStream(org.antlr.v4.runtime.CommonTokenStream)
BitSet(java.util.BitSet)
PropertyLineContext(org.springframework.ide.vscode.java.properties.antlr.parser.JavaPropertiesParser.PropertyLineContext)
Problem(org.springframework.ide.vscode.java.properties.parser.Problem)
ParseResults(org.springframework.ide.vscode.java.properties.parser.ParseResults)
ANTLRInputStream(org.antlr.v4.runtime.ANTLRInputStream)
RecognitionException(org.antlr.v4.runtime.RecognitionException)
DFA(org.antlr.v4.runtime.dfa.DFA)
Example 9 with org.antlr.v4.runtime.tree
use of org.antlr.v4.runtime.tree in project L42 by ElvisResearchGroup.
the class ReplState method start.
public static ReplState start(String code) {
try {
Expression.ClassReuse code1 = (ClassReuse) Parser.parse("Repl", code);
auxiliaryGrammar.WellFormedness.checkAll(code1);
Expression.ClassReuse code2 = (ClassReuse) Desugar.of(code1);
assert auxiliaryGrammar.WellFormedness.checkAll(code2);
ExpCore.ClassB code3 = (ExpCore.ClassB) code2.accept(new InjectionOnCore());
assert coreVisitors.CheckNoVarDeclaredTwice.of(code3);
// TODO: will die after new reduction Refresh of position identities, it is used to generate correct Java code.
code3 = (ExpCore.ClassB) code3.accept(new CloneVisitor() {
@Override
public ExpCore visit(ExpCore.ClassB cb) {
Position p = cb.getP();
cb = cb.withP(new Position(p.getFile(), p.getLine1(), p.getPos1(), p.getLine2(), p.getPos2(), p.get_next()));
return super.visit(cb);
}
});
ExpCore.ClassB result = ProgramReduction.allSteps(code3);
return new ReplState(code, code2, result);
} catch (org.antlr.v4.runtime.misc.ParseCancellationException parser) {
System.out.println(parser.getMessage());
return null;
} catch (ErrorMessage msg) {
ErrorFormatter.topFormatErrorMessage(msg);
return null;
}
}
Also used :
ExpCore(ast.ExpCore)
ParseCancellationException(org.antlr.v4.runtime.misc.ParseCancellationException)
Position(ast.Ast.Position)
CloneVisitor(coreVisitors.CloneVisitor)
Expression(ast.Expression)
ClassReuse(ast.Expression.ClassReuse)
ErrorMessage(ast.ErrorMessage)
ClassReuse(ast.Expression.ClassReuse)
ClassB(ast.Expression.ClassB)
InjectionOnCore(sugarVisitors.InjectionOnCore)
Example 10 with org.antlr.v4.runtime.tree
use of org.antlr.v4.runtime.tree in project oxTrust by GluuFederation.
the class ScimFilterParser method expression.
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 2;
enterRecursionRule(_localctx, 2, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(92);
_errHandler.sync(this);
switch(getInterpreter().adaptivePredict(_input, 11, _ctx)) {
case 1:
{
_localctx = new NOT_EXPRContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(17);
match(NOT);
setState(19);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(18);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(21);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 1, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(23);
expression(9);
}
break;
case 2:
{
_localctx = new ATTR_OPER_EXPRContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(24);
match(ATTRNAME);
setState(26);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(25);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(28);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 2, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(30);
operator();
setState(32);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(31);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(34);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 3, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(36);
expression(4);
}
break;
case 3:
{
_localctx = new ATTR_PRContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(38);
match(ATTRNAME);
setState(40);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(39);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(42);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 4, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(44);
match(PR);
}
break;
case 4:
{
_localctx = new ATTR_OPER_CRITERIAContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(45);
match(ATTRNAME);
setState(47);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(46);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(49);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 5, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(51);
operator();
setState(53);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(52);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(55);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 6, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(57);
criteria();
}
break;
case 5:
{
_localctx = new LPAREN_EXPR_RPARENContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(59);
match(LPAREN);
setState(63);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 7, _ctx);
while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1 + 1) {
{
{
setState(60);
match(WS);
}
}
}
setState(65);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 7, _ctx);
}
setState(66);
expression(0);
setState(70);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 8, _ctx);
while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1 + 1) {
{
{
setState(67);
match(WS);
}
}
}
setState(72);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 8, _ctx);
}
setState(73);
match(RPAREN);
}
break;
case 6:
{
_localctx = new LBRAC_EXPR_RBRACContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(75);
match(ATTRNAME);
setState(76);
match(LBRAC);
setState(80);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 9, _ctx);
while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1 + 1) {
{
{
setState(77);
match(WS);
}
}
}
setState(82);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 9, _ctx);
}
setState(83);
expression(0);
setState(87);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 10, _ctx);
while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1 + 1) {
{
{
setState(84);
match(WS);
}
}
}
setState(89);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 10, _ctx);
}
setState(90);
match(RBRAC);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(136);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 19, _ctx);
while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1) {
if (_parseListeners != null)
triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(134);
_errHandler.sync(this);
switch(getInterpreter().adaptivePredict(_input, 18, _ctx)) {
case 1:
{
_localctx = new EXPR_AND_EXPRContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(94);
if (!(precpred(_ctx, 8)))
throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(96);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(95);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(98);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 12, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(100);
match(AND);
setState(102);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(101);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(104);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 13, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(106);
expression(9);
}
break;
case 2:
{
_localctx = new EXPR_OR_EXPRContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(107);
if (!(precpred(_ctx, 7)))
throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(109);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(108);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(111);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 14, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(113);
match(OR);
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(114);
match(WS);
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
} while (_la == WS);
setState(119);
expression(8);
}
break;
case 3:
{
_localctx = new EXPR_OPER_EXPRContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(120);
if (!(precpred(_ctx, 6)))
throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(122);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(121);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(124);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 16, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(126);
operator();
setState(128);
_errHandler.sync(this);
_alt = 1 + 1;
do {
switch(_alt) {
case 1 + 1:
{
{
setState(127);
match(WS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(130);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 17, _ctx);
} while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
setState(132);
expression(7);
}
break;
}
}
}
setState(138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 19, _ctx);
}
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
Also used :
ParserRuleContext(org.antlr.v4.runtime.ParserRuleContext)
NoViableAltException(org.antlr.v4.runtime.NoViableAltException)
FailedPredicateException(org.antlr.v4.runtime.FailedPredicateException)
RecognitionException(org.antlr.v4.runtime.RecognitionException)
Aggregations
IOException (java.io.IOException)7
InputStream (java.io.InputStream)6
CharStream (org.antlr.v4.runtime.CharStream)5
RecognitionException (org.antlr.v4.runtime.RecognitionException)5
CommonTokenStream (org.antlr.v4.runtime.CommonTokenStream)4
NoViableAltException (org.antlr.v4.runtime.NoViableAltException)4
BufferedReader (java.io.BufferedReader)3
InputStreamReader (java.io.InputStreamReader)3
ANTLRInputStream (org.antlr.v4.runtime.ANTLRInputStream)3
ParseCancellationException (org.antlr.v4.runtime.misc.ParseCancellationException)3
ByteArrayInputStream (java.io.ByteArrayInputStream)2
FileNotFoundException (java.io.FileNotFoundException)2
BailErrorStrategy (org.antlr.v4.runtime.BailErrorStrategy)2
DefaultErrorStrategy (org.antlr.v4.runtime.DefaultErrorStrategy)2
ATNState (org.antlr.v4.runtime.atn.ATNState)2
LL1Analyzer (org.antlr.v4.runtime.atn.LL1Analyzer)2
IntervalSet (org.antlr.v4.runtime.misc.IntervalSet)2
ParseTree (org.antlr.v4.runtime.tree.ParseTree)2
ParseTreeWalker (org.antlr.v4.runtime.tree.ParseTreeWalker)2
ErrorType (org.antlr.v4.tool.ErrorType)2
