org.antlr.v4.runtime.Vocabulary Java Examples

private static Set<Keyword> identifierCandidates() {
    HashSet<Keyword> candidates = new HashSet<>();
    Vocabulary vocabulary = SqlBaseLexer.VOCABULARY;
    for (int i = 0; i < vocabulary.getMaxTokenType(); i++) {
        String literal = vocabulary.getLiteralName(i);
        if (literal == null) {
            continue;
        }
        literal = literal.replace("'", "");

        Matcher matcher = IDENTIFIER.matcher(literal.toLowerCase(Locale.ENGLISH));
        if (matcher.matches()) {
            candidates.add(new Keyword(literal, reserved(literal)));
        }
    }
    return candidates;
}
 

@Test
void reportInputMismatch() {
    InputMismatchException error = mock(InputMismatchException.class);

    when(error.getOffendingToken()).thenReturn(token);
    when(error.getExpectedTokens()).thenReturn(set);
    when(set.toString(any(Vocabulary.class))).thenReturn("foo");
    when(recognizer.getVocabulary()).thenReturn(mock(Vocabulary.class));

    strategy.reportInputMismatch(recognizer, error);

    verify(recognizer).notifyErrorListeners(token, "Expected foo", error);
}
 

public GrammarParserInterpreter(Grammar g,
								String grammarFileName,
								Vocabulary vocabulary,
								Collection<String> ruleNames,
								ATN atn,
								TokenStream input) {
	super(grammarFileName, vocabulary, ruleNames, atn, input);
	this.g = g;
}
 

public static TerminalNode getMatchingLeftSymbol(Corpus corpus,
                                                 InputDocument doc,
                                                 TerminalNode node)
{
	ParserRuleContext parent = (ParserRuleContext)node.getParent();
	int curTokensParentRuleIndex = parent.getRuleIndex();
	Token curToken = node.getSymbol();
	if (corpus.ruleToPairsBag != null) {
		String ruleName = doc.parser.getRuleNames()[curTokensParentRuleIndex];
		RuleAltKey ruleAltKey = new RuleAltKey(ruleName, parent.getAltNumber());
		List<Pair<Integer, Integer>> pairs = corpus.ruleToPairsBag.get(ruleAltKey);
		if ( pairs!=null ) {
			// Find appropriate pair given current token
			// If more than one pair (a,b) with b=current token pick first one
			// or if a common pair like ({,}), then give that one preference.
			// or if b is punctuation, prefer a that is punct
			List<Integer> viableMatchingLeftTokenTypes = viableLeftTokenTypes(parent, curToken, pairs);
			Vocabulary vocab = doc.parser.getVocabulary();
			if ( !viableMatchingLeftTokenTypes.isEmpty() ) {
				int matchingLeftTokenType =
					CollectTokenPairs.getMatchingLeftTokenType(curToken, viableMatchingLeftTokenTypes, vocab);
				List<TerminalNode> matchingLeftNodes = parent.getTokens(matchingLeftTokenType);
				// get matching left node by getting last node to left of current token
				List<TerminalNode> nodesToLeftOfCurrentToken =
					filter(matchingLeftNodes, n -> n.getSymbol().getTokenIndex()<curToken.getTokenIndex());
				TerminalNode matchingLeftNode = nodesToLeftOfCurrentToken.get(nodesToLeftOfCurrentToken.size()-1);
				if (matchingLeftNode == null) {
					System.err.println("can't find matching node for "+node.getSymbol());
				}
				return matchingLeftNode;
			}
		}
	}
	return null;
}
 

public ParserWrapper(ParserFactory parserFactory, Vocabulary lexerVocabulary) {
    this.lexerVocabulary = lexerVocabulary;
    
    Parser parserForAtnOnly = parserFactory.createParser(null);
    this.parserAtn = parserForAtnOnly.getATN();
    this.parserRuleNames = parserForAtnOnly.getRuleNames();
    logger.debug("Parser rule names: " + StringUtils.join(parserForAtnOnly.getRuleNames(), ", "));
}
 

public static Set<String> sqlKeywords()
{
    ImmutableSet.Builder<String> names = ImmutableSet.builder();
    Vocabulary vocabulary = SqlBaseLexer.VOCABULARY;
    for (int i = 0; i <= vocabulary.getMaxTokenType(); i++) {
        String name = nullToEmpty(vocabulary.getLiteralName(i));
        Matcher matcher = IDENTIFIER.matcher(name);
        if (matcher.matches()) {
            names.add(matcher.group(1));
        }
    }
    return names.build();
}
 

@Test
void reportMissingToken() {
    when(recognizer.getCurrentToken()).thenReturn(token);
    when(recognizer.getExpectedTokens()).thenReturn(set);
    when(set.toString(any(Vocabulary.class))).thenReturn("foo");
    when(recognizer.getVocabulary()).thenReturn(mock(Vocabulary.class));

    strategy.reportMissingToken(recognizer);

    assertThat(strategy.inErrorRecoveryMode(recognizer)).isTrue();
    verify(recognizer).notifyErrorListeners(token, "Missing foo", null);
}
 

private static Set<String> possibleIdentifiers()
{
    ImmutableSet.Builder<String> names = ImmutableSet.builder();
    Vocabulary vocabulary = SqlBaseLexer.VOCABULARY;
    for (int i = 0; i <= vocabulary.getMaxTokenType(); i++) {
        String name = nullToEmpty(vocabulary.getLiteralName(i));
        Matcher matcher = IDENTIFIER.matcher(name);
        if (matcher.matches()) {
            names.add(matcher.group(1));
        }
    }
    return names.build();
}
 

@Override
public Vocabulary getVocabulary() {
	return VOCABULARY;
}
 

@Override
public Vocabulary getVocabulary() {
  return VOCABULARY;
}
 

@Override
public Vocabulary getVocabulary() {
  return VOCABULARY;
}
 

@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}
 

@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}
 

@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}
 

@Override
public Vocabulary getVocabulary() {
	return VOCABULARY;
}
 

/** {@inheritDoc} */
@Override public Vocabulary getVocabulary() {
    return VOCABULARY;
}
 

/** {@inheritDoc} */
@Override public Vocabulary getVocabulary() {
    return VOCABULARY;
}
 

/**
 * Gets a {@link Vocabulary} instance describing the vocabulary used by the
 * grammar.
 */

public Vocabulary getVocabulary() {
	return new VocabularyImpl(getTokenLiteralNames(), getTokenSymbolicNames());
}
 

public CollectTokenPairs(Vocabulary vocab, String[] ruleNames) {
	this.vocab = vocab;
	this.ruleNames = ruleNames;
}
 

public static String _toString(FeatureMetaData[] FEATURES, InputDocument doc, int[] features,
                               boolean showInfo) {
	Vocabulary v = doc.parser.getVocabulary();
	String[] ruleNames = doc.parser.getRuleNames();
	StringBuilder buf = new StringBuilder();
	for (int i=0; i<FEATURES.length; i++) {
		if ( FEATURES[i].type.equals(UNUSED) ) continue;
		if ( i>0 ) buf.append(" ");
		if ( i==INDEX_CUR_TOKEN_TYPE ) {
			buf.append("| "); // separate prev from current tokens
		}
		int displayWidth = FEATURES[i].type.displayWidth;
		switch ( FEATURES[i].type ) {
			case TOKEN :
				String tokenName = v.getDisplayName(features[i]);
				String abbrev = StringUtils.abbreviateMiddle(tokenName, "*", displayWidth);
				String centered = StringUtils.center(abbrev, displayWidth);
				buf.append(String.format("%"+displayWidth+"s", centered));
				break;
			case RULE :
				if ( features[i]>=0 ) {
					String ruleName = ruleNames[unrulealt(features[i])[0]];
					int ruleAltNum = unrulealt(features[i])[1];
					ruleName += ":"+ruleAltNum;
					abbrev = StringUtils.abbreviateMiddle(ruleName, "*", displayWidth);
					buf.append(String.format("%"+displayWidth+"s", abbrev));
				}
				else {
					buf.append(Tool.sequence(displayWidth, " "));
				}
				break;
			case INT :
			case INFO_LINE:
			case INFO_CHARPOS:
				if ( showInfo ) {
					if ( features[i]>=0 ) {
						buf.append(String.format("%"+displayWidth+"s", StringUtils.center(String.valueOf(features[i]), displayWidth)));
					}
					else {
						buf.append(Tool.sequence(displayWidth, " "));
					}
				}
				break;
			case INFO_FILE:
				if ( showInfo ) {
					String fname = new File(doc.fileName).getName();
					fname = StringUtils.abbreviate(fname, displayWidth);
					buf.append(String.format("%"+displayWidth+"s", fname));
				}
				break;
			case BOOL :
				if ( features[i]!=-1 ) {
					buf.append(features[i] == 1 ? "true " : "false");
				}
				else {
					buf.append(Tool.sequence(displayWidth, " "));
				}
				break;
			default :
				System.err.println("NO STRING FOR FEATURE TYPE: "+ FEATURES[i].type);
		}
	}
	return buf.toString();
}
 

@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}
 

@Override

  public Vocabulary getVocabulary() {
    return VOCABULARY;
  }
 

@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}
 

private CustomErrorListener(Vocabulary vocabulary) {
    this.vocabulary = vocabulary;
}
 

public Vocabulary getVocabulary() {
    return getCachedLexer().getVocabulary();
}