java类org.antlr.v4.runtime.misc.Pair的实例源码

/** Return a new map from rulename to List of (a,b) pairs stripped of
 *  tuples (a,b) where a or b is in rule repeated token set.
 *  E.g., before removing repeated token ',', we see:
 *
 *  elementValueArrayInitializer: 4:'{',',' 1:'{','}' 4:',','}'
 *
 *  After removing tuples containing repeated tokens, we get:
 *
 *  elementValueArrayInitializer: 1:'{','}'
*/
protected Map<RuleAltKey,List<Pair<Integer,Integer>>> stripPairsWithRepeatedTokens() {
    Map<RuleAltKey,List<Pair<Integer,Integer>>> ruleToPairsWoRepeats = new HashMap<>();
    // For each rule
    for (RuleAltKey ruleAltKey : ruleToPairsBag.keySet()) {
        Set<Integer> ruleRepeatedTokens = ruleToRepeatedTokensSet.get(ruleAltKey);
        Set<Pair<Integer, Integer>> pairsBag = ruleToPairsBag.get(ruleAltKey);
        // If there are repeated tokens for this rule
        if ( ruleRepeatedTokens!=null ) {
            // Remove all (a,b) for b in repeated token set
            List<Pair<Integer, Integer>> pairsWoRepeats =
                BuffUtils.filter(pairsBag,
                                    p -> !ruleRepeatedTokens.contains(p.a) && !ruleRepeatedTokens.contains(p.b));
            ruleToPairsWoRepeats.put(ruleAltKey, pairsWoRepeats);
        }
        else {
            ruleToPairsWoRepeats.put(ruleAltKey, new ArrayList<>(pairsBag));
        }
    }
    return ruleToPairsWoRepeats;
}

public void visitNonSingletonWithSeparator(ParserRuleContext ctx,
                                           List<? extends ParserRuleContext> siblings,
                                           Token separator)
{
    boolean oversize = isOversizeList(ctx, siblings, separator);
    Map<Token, Pair<Boolean, Integer>> tokenInfo =
        getInfoAboutListTokens(ctx, tokens, tokenToNodeMap, siblings, oversize);

    // copy sibling list info for associated tokens into overall list
    // but don't overwrite existing so that most general (largest construct)
    // list information is use/retained (i.e., not overwritten).
    for (Token t : tokenInfo.keySet()) {
        if ( !tokenToListInfo.containsKey(t) ) {
            tokenToListInfo.put(t, tokenInfo.get(t));
        }
    }
}

/**
 * Get {@code #} labels. The keys of the map are the labels applied to outer
 * alternatives of a lexer rule, and the values are collections of pairs
 * (alternative number and {@link AltAST}) identifying the alternatives with
 * this label. Unlabeled alternatives are not included in the result.
 */
public Map<String, List<Pair<Integer, AltAST>>> getAltLabels() {
    Map<String, List<Pair<Integer, AltAST>>> labels = new LinkedHashMap<String, List<Pair<Integer, AltAST>>>();
    for (int i=1; i<=numberOfAlts; i++) {
        GrammarAST altLabel = alt[i].ast.altLabel;
        if ( altLabel!=null ) {
            List<Pair<Integer, AltAST>> list = labels.get(altLabel.getText());
            if (list == null) {
                list = new ArrayList<Pair<Integer, AltAST>>();
                labels.put(altLabel.getText(), list);
            }

            list.add(new Pair<Integer, AltAST>(i, alt[i].ast));
        }
    }
    if ( labels.isEmpty() ) return null;
    return labels;
}

@Override
    public void suffixAlt(AltAST originalAltTree, int alt) {
        AltAST altTree = (AltAST)originalAltTree.dupTree();
        String altLabel = altTree.altLabel!=null ? altTree.altLabel.getText() : null;

        String label = null;
        boolean isListLabel = false;
        GrammarAST lrlabel = stripLeftRecursion(altTree);
        if ( lrlabel!=null ) {
            label = lrlabel.getText();
            isListLabel = lrlabel.getParent().getType() == PLUS_ASSIGN;
            leftRecursiveRuleRefLabels.add(new Pair<GrammarAST,String>(lrlabel,altLabel));
        }
        stripAltLabel(altTree);
        String altText = text(altTree);
        altText = altText.trim();
        LeftRecursiveRuleAltInfo a =
            new LeftRecursiveRuleAltInfo(alt, altText, label, altLabel, isListLabel, originalAltTree);
        suffixAlts.put(alt, a);
//      System.out.println("suffixAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
    }

public ListenerFile(OutputModelFactory factory, String fileName) {
    super(factory, fileName);
    Grammar g = factory.getGrammar();
    parserName = g.getRecognizerName();
    grammarName = g.name;
    for (Rule r : g.rules.values()) {
        Map<String, List<Pair<Integer,AltAST>>> labels = r.getAltLabels();
        if ( labels!=null ) {
            for (Map.Entry<String, List<Pair<Integer, AltAST>>> pair : labels.entrySet()) {
                listenerNames.add(pair.getKey());
                listenerLabelRuleNames.put(pair.getKey(), r.name);
            }
        }
        else {
            // only add rule context if no labels
            listenerNames.add(r.name);
        }
    }
    ActionAST ast = g.namedActions.get("header");
    if ( ast!=null ) header = new Action(factory, ast);
    genPackage = factory.getGrammar().tool.genPackage;
}

public VisitorFile(OutputModelFactory factory, String fileName) {
    super(factory, fileName);
    Grammar g = factory.getGrammar();
    parserName = g.getRecognizerName();
    grammarName = g.name;
    for (Rule r : g.rules.values()) {
        Map<String, List<Pair<Integer, AltAST>>> labels = r.getAltLabels();
        if ( labels!=null ) {
            for (Map.Entry<String, List<Pair<Integer, AltAST>>> pair : labels.entrySet()) {
                visitorNames.add(pair.getKey());
                visitorLabelRuleNames.put(pair.getKey(), r.name);
            }
        }
        else {
            // if labels, must label all. no need for generic rule visitor then
            visitorNames.add(r.name);
        }
    }
    ActionAST ast = g.namedActions.get("header");
    if ( ast!=null ) header = new Action(factory, ast);
    genPackage = factory.getGrammar().tool.genPackage;
}

@Override
  public void enterEveryRule(ParserRuleContext ctx) { 
      String ruleName = extractRuleName(ctx);
      Pair<Integer, Integer> interval = getLineRange(ctx);
      Element newNode = (Element) domDoc.createElement(ruleName);
if (interval != null) {
    newNode.setAttribute("start", Integer.toString(interval.a));
    newNode.setAttribute("end", Integer.toString(interval.b));
}

if (debugMode) {
    System.out.println("enter->" + ruleName);
}
if (ctx.getText() != null && ctx.getChildCount() == 0) {
    //newNode.setTextContent(ctx.getText());
    newNode.appendChild(domDoc.createTextNode(ctx.getText()));
}
nodeStack.peek().appendChild(newNode);
nodeStack.push(newNode);
  }

public static Pair<Parser, Lexer> parsePHP(String filePath) {
    AntlrCaseInsensitiveFileStream input;
try {
    input = new AntlrCaseInsensitiveFileStream(filePath);
} catch (IOException e) {
    e.printStackTrace();
    return null;
}
      PHPLexer lexer = new PHPLexer(input);
      CommonTokenStream tokens = new CommonTokenStream(lexer);
      PHPParser parser = new InterruptablePHPParser(tokens, filePath);
      /* turn on prediction mode to speed up parsing */
      parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
      Pair<Parser, Lexer> retval = new Pair<Parser, Lexer>(parser, lexer);
      return retval;
  }

public static Document processFile(String filePath) {
    Pair<Parser, Lexer> pl = parsePHP(filePath);
    PHPParser parser = (PHPParser) pl.a;
    parser.setBuildParseTree(true);
    /* 
     * htmlDocument is the start rule (the top-level rule)
     * for the PHP grammar
     */
    ParserRuleContext tree =   parser.htmlDocument();
    List<String> ruleNames = Arrays.asList(parser.getRuleNames());
    Map<Integer, String> invTokenMap = getInvTokenMap(parser);
    TokenStream tokenStream = parser.getTokenStream();
    ParseTreeDOMSerializer ptSerializer = new ParseTreeDOMSerializer(ruleNames, invTokenMap, tokenStream);
    ParseTreeWalker.DEFAULT.walk(ptSerializer, tree);
    Document result= ptSerializer.getDOMDocument();
    return result;
}

/** Create an ANTLR Token from the current token type of the builder
     *  then advance the builder to next token (which ultimately calls an
     *  ANTLR lexer).  The {@link ANTLRLexerAdaptor} creates tokens via
     *  an ANTLR lexer but converts to {@link TokenIElementType} and here
     *  we have to convert back to an ANTLR token using what info we
     *  can get from the builder. We lose info such as the original channel.
     *  So, whitespace and comments (typically hidden channel) will look like
     *  real tokens. Jetbrains uses {@link ParserDefinition#getWhitespaceTokens()}
     *  and {@link ParserDefinition#getCommentTokens()} to strip these before
     *  our ANTLR parser sees them.
     */
    @Override
    public Token nextToken() {
        ProgressIndicatorProvider.checkCanceled();

        TokenIElementType ideaTType = (TokenIElementType)builder.getTokenType();
        int type = ideaTType!=null ? ideaTType.getANTLRTokenType() : Token.EOF;

        int channel = Token.DEFAULT_CHANNEL;
        Pair<TokenSource, CharStream> source = new Pair<TokenSource, CharStream>(this, null);
        String text = builder.getTokenText();
        int start = builder.getCurrentOffset();
        int length = text != null ? text.length() : 0;
        int stop = start + length - 1;
        // PsiBuilder doesn't provide line, column info
        int line = 0;
        int charPositionInLine = 0;
        Token t = tokenFactory.create(source, type, text, channel, start, stop, line, charPositionInLine);
        builder.advanceLexer();
//      System.out.println("TOKEN: "+t);
        return t;
    }