Examples of org.antlr.v4.runtime.tree.pattern.ParseTreePatternMatcher$CannotInvokeStartRule

Package org.antlr.v4.runtime.tree.pattern

Examples of org.antlr.v4.runtime.tree.pattern.ParseTreePatternMatcher$CannotInvokeStartRule

org.antlr.v4.runtime.tree.pattern.ParseTreePatternMatcher
A tree pattern matching mechanism for ANTLR {@link ParseTree}s.
Patterns are strings of source input text with special tags representing token or rule references such as:

{@code = ;}

Given a pattern start rule such as {@code statement}, this object constructs a {@link ParseTree} with placeholders for the {@code ID} and {@code expr}subtree. Then the {@link #match} routines can compare an actual{@link ParseTree} from a parse with this pattern. Tag {@code } matchesany {@code ID} token and tag {@code } references the result of the{@code expr} rule (generally an instance of {@code ExprContext}.

Pattern {@code x = 0;} is a similar pattern that matches the same patternexcept that it requires the identifier to be {@code x} and the expression tobe {@code 0}.

The {@link #matches} routines return {@code true} or {@code false} basedupon a match for the tree rooted at the parameter sent in. The {@link #match} routines return a {@link ParseTreeMatch} object thatcontains the parse tree, the parse tree pattern, and a map from tag name to matched nodes (more below). A subtree that fails to match, returns with {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did notmatch.

For efficiency, you can compile a tree pattern in string form to a {@link ParseTreePattern} object.
See {@code TestParseTreeMatcher} for lots of examples.{@link ParseTreePattern} has two static helper methods:{@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} thatare easy to use but not super efficient because they create new {@link ParseTreePatternMatcher} objects each time and have to compile thepattern in string form before using it.

The lexer and parser that you pass into the {@link ParseTreePatternMatcher}constructor are used to parse the pattern in string form. The lexer converts the {@code = ;} into a sequence of four tokens (assuming lexerthrows out whitespace or puts it on a hidden channel). Be aware that the input stream is reset for the lexer (but not the parser; a {@link ParserInterpreter} is created to parse the input.). Any user-definedfields you have put into the lexer might get changed when this mechanism asks it to scan the pattern string.

Normally a parser does not accept token {@code } as a valid{@code expr} but, from the parser passed in, we create a special version ofthe underlying grammar representation (an {@link ATN}) that allows imaginary tokens representing rules ( {@code }) to match entire rules. We call these bypass alternatives.

Delimiters are {@code <} and {@code>}, with {@code \} as the escape stringby default, but you can set them to whatever you want using {@link #setDelimiters}. You must escape both start and stop strings {@code \<} and {@code \>}.

  @NotNull
  @Override
  public Handle wildcard(@NotNull GrammarAST node) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new WildcardTransition(right));
    node.atnState = left;
    return new Handle(left, right);
  }

View Full Code Here

    // ignore tokens from existing option subtrees like:
    //    (ELEMENT_OPTIONS (= assoc right))
    //
    // element options are added back according to the values in the map
    // returned by getOptions().
    IntervalSet ignore = new IntervalSet();
    List<GrammarAST> optionsSubTrees = t.getNodesWithType(ELEMENT_OPTIONS);
    for (GrammarAST sub : optionsSubTrees) {
      ignore.add(sub.getTokenStartIndex(), sub.getTokenStopIndex());
    }


    // Individual labels appear as RULE_REF or TOKEN_REF tokens in the tree,
    // but do not support the ELEMENT_OPTIONS syntax. Make sure to not try
    // and add the tokenIndex option when writing these tokens.
    IntervalSet noOptions = new IntervalSet();
    List<GrammarAST> labeledSubTrees = t.getNodesWithType(new IntervalSet(ASSIGN,PLUS_ASSIGN));
    for (GrammarAST sub : labeledSubTrees) {
      noOptions.add(sub.getChild(0).getTokenStartIndex());
    }


    StringBuilder buf = new StringBuilder();
    for (int i=tokenStartIndex; i<=tokenStopIndex; i++) {
      if ( ignore.contains(i) ) {
        continue;
      }


      Token tok = tokenStream.get(i);


      StringBuilder elementOptions = new StringBuilder();
      if (!noOptions.contains(i)) {
        GrammarAST node = t.getNodeWithTokenIndex(tok.getTokenIndex());
        if ( node!=null &&
           (tok.getType()==TOKEN_REF ||
            tok.getType()==STRING_LITERAL ||
            tok.getType()==RULE_REF) )

View Full Code Here

  @NotNull
  @Override
  public Handle set(@NotNull GrammarAST associatedAST, @NotNull List<GrammarAST> terminals, boolean invert) {
    ATNState left = newState(associatedAST);
    ATNState right = newState(associatedAST);
    IntervalSet set = new IntervalSet();
    for (GrammarAST t : terminals) {
      int ttype = g.getTokenType(t.getText());
      set.add(ttype);
    }
    if ( invert ) {
      left.addTransition(new NotSetTransition(right, set));
    }
    else {

View Full Code Here

          }
        }
      }
      if(arg0.getParent() instanceof ExpressionContext) {
        // we are the leftmost child of the expression
        ParseTree chld = arg0.getParent().getChild(arg0.getParent().getChildCount()-1);
        if(!chld.equals(arg0)) return;
        addQuery(classUtils.expandExpression(arg0.getParent().getText(), registry));
      }
    }
  }

View Full Code Here

//    parser.setTokenFactory(factory);
    parser.addErrorListener(new DiagnosticErrorListener());
    parser.getInterpreter().setPredictionMode(
        PredictionMode.LL_EXACT_AMBIG_DETECTION);
    parser.setBuildParseTree(true);
    ParseTree tree = parser.mson();
    // show tree in text form
    // System.out.println(tree.toStringTree(parser));


    ParseTreeWalker walker = new ParseTreeWalker();
    SymbolTable symtab = new SymbolTable();

View Full Code Here

    JavaParser parser = new JavaParser(tokens);
    parser.removeErrorListeners();
    
    // start parsing at the compilationUnit rule
    ParserRuleContext t = parser.compilationUnit();
    ParseTreeWalker walker = new ParseTreeWalker();
    List<AutocompleteCandidate> q = new ArrayList<AutocompleteCandidate>();
          
    ImportDeclarationCompletion extractor = new ImportDeclarationCompletion(txt,cur,registry,cps,cu);
    NameBuilder extractor2 = new NameBuilder(registry,cu );
    NodeCompletion extractor3 = new NodeCompletion(txt,cur, registry, cu);
    walker.walk(extractor, t);
    if(extractor.getQuery()!=null)
      q.addAll(extractor.getQuery());
    walker.walk(extractor2, t);
    walker.walk(extractor3, t);
    if(extractor3.getQuery()!=null)
      q.addAll(extractor3.getQuery());
    List<String> ret = registry.searchCandidates(q);


    // this shows the GUI

View Full Code Here

    parser.setBuildParseTree(true);
    ParseTree tree = parser.mson();
    // show tree in text form
    // System.out.println(tree.toStringTree(parser));


    ParseTreeWalker walker = new ParseTreeWalker();
    SymbolTable symtab = new SymbolTable();
    DefPhase def = new DefPhase(symtab);
    walker.walk(def, tree);
    // create next phase and feed symbol table info from def to ref phase
    RefPhase ref = new RefPhase(symtab, def.scopes);
    walker.walk(ref, tree);
  }

View Full Code Here

   * {@link Lexer} rather than trying to deduce it from this parser.
   */
  public ParseTreePattern compileParseTreePattern(String pattern, int patternRuleIndex,
                          Lexer lexer)
  {
    ParseTreePatternMatcher m = new ParseTreePatternMatcher(lexer, this);
    return m.compile(pattern, patternRuleIndex);
  }

View Full Code Here

import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;


public class TestParseTreeMatcher extends BaseTest {
  @Test public void testChunking() throws Exception {
    ParseTreePatternMatcher m = new ParseTreePatternMatcher(null, null);
    assertEquals("[ID, ' = ', expr, ' ;']", m.split("<ID> = <expr> ;").toString());
    assertEquals("[' ', ID, ' = ', expr]", m.split(" <ID> = <expr>").toString());
    assertEquals("[ID, ' = ', expr]", m.split("<ID> = <expr>").toString());
    assertEquals("[expr]", m.split("<expr>").toString());
    assertEquals("['<x> foo']", m.split("\\<x\\> foo").toString());
    assertEquals("['foo <x> bar ', tag]", m.split("foo \\<x\\> bar <tag>").toString());
  }

View Full Code Here

    assertEquals("['<x> foo']", m.split("\\<x\\> foo").toString());
    assertEquals("['foo <x> bar ', tag]", m.split("foo \\<x\\> bar <tag>").toString());
  }


  @Test public void testDelimiters() throws Exception {
    ParseTreePatternMatcher m = new ParseTreePatternMatcher(null, null);
    m.setDelimiters("<<", ">>", "$");
    String result = m.split("<<ID>> = <<expr>> ;$<< ick $>>").toString();
    assertEquals("[ID, ' = ', expr, ' ;<< ick >>']", result);
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.antlr.v4.runtime.tree.pattern.ParseTreePatternMatcher$CannotInvokeStartRule

org.antlr.runtime.ANTLRFileStream

org.antlr.runtime.ANTLRStringStream

org.antlr.runtime.CharStream

org.antlr.runtime.CommonToken

org.antlr.runtime.tree.CommonTree

org.antlr.runtime.tree.CommonTreeNodeStream

org.antlr.runtime.tree.Tree

org.antlr.runtime.tree.TreeVisitor

org.antlr.runtime.tree.TreeVisitorAction

org.antlr.v4.analysis.LeftRecursionDetector

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.