Java Code Examples for org.antlr.v4.runtime.Token#getChannel()

@Override
public void exitNonReserved(SqlBaseParser.NonReservedContext context)
{
    // we can't modify the tree during rule enter/exit event handling unless we're dealing with a terminal.
    // Otherwise, ANTLR gets confused an fires spurious notifications.
    if (!(context.getChild(0) instanceof TerminalNode)) {
        int rule = ((ParserRuleContext) context.getChild(0)).getRuleIndex();
        throw new AssertionError("nonReserved can only contain tokens. Found nested rule: " + ruleNames.get(rule));
    }

    // replace nonReserved words with IDENT tokens
    context.getParent().removeLastChild();

    Token token = (Token) context.getChild(0).getPayload();
    Token newToken = new CommonToken(
            new Pair<>(token.getTokenSource(), token.getInputStream()),
            SqlBaseLexer.IDENTIFIER,
            token.getChannel(),
            token.getStartIndex(),
            token.getStopIndex());

    context.getParent().addChild(parser.createTerminalNode(context.getParent(), newToken));
}
 

/**
 * Prints warnings for unused documentation comments.
 */
public void printWarnings()
{
    if (currentTokenStream == null)
        return;

    for (int i = 0; i < currentTokenStream.size(); ++i)
    {
        final Token token = currentTokenStream.get(i);
        if (token.getChannel() == ZserioLexer.DOC)
        {
            if (!currentUsedComments.contains(token))
            {
                ZserioToolPrinter.printWarning(new AstLocation(token),
                        "Documentation comment is not used!");
            }
        }
    }
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _lastTokenType = token.getType();
  }
}
 

public static boolean isEmptyStatement(String sql)
{
    TokenSource tokens = getLexer(sql, ImmutableSet.of());
    while (true) {
        Token token = tokens.nextToken();
        if (token.getType() == Token.EOF) {
            return true;
        }
        if (token.getChannel() != Token.HIDDEN_CHANNEL) {
            return false;
        }
    }
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

@Override
public void exitS_groups_named(S_groups_namedContext ctx) {
  String groupName = unquote(ctx.name.getText());
  HierarchyTree tree = _hierarchy.getTree(groupName);
  if (tree == null) {
    tree = _hierarchy.newTree(groupName);
  }
  StatementContext statement = ctx.s_groups_tail().statement();
  if (statement == null) {
    return;
  }
  Interval interval = ctx.s_groups_tail().getSourceInterval();
  List<Token> unfilteredTokens = _combinedParser.getTokens().getTokens(interval.a, interval.b);
  HierarchyPath path = new HierarchyPath();
  for (Token currentToken : unfilteredTokens) {
    if (currentToken.getChannel() != Lexer.HIDDEN) {
      String text = currentToken.getText();
      int line = currentToken.getLine();
      if (currentToken.getType() == FlatJuniperLexer.WILDCARD) {
        path.addWildcardNode(text, line);
      } else {
        path.addNode(text, line);
      }
    }
  }
  path.setStatement(statement);
  tree.addPath(path, _currentSetLine, null);
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

private String printToken(Token token) {
  int modeAsInt = _combinedParser.getTokenMode(token);
  String mode = _combinedParser.getLexer().getModeNames()[modeAsInt];
  String rawTokenText = token.getText();
  String tokenText = BatfishCombinedParser.escape(rawTokenText);
  int tokenType = token.getType();
  String channel = token.getChannel() == Lexer.HIDDEN ? "(HIDDEN) " : "";
  String tokenName;
  int line = token.getLine();
  int col = token.getCharPositionInLine();
  if (tokenType == -1) {
    tokenName = "EOF";
  } else {
    tokenName = _combinedParser.getParser().getVocabulary().getSymbolicName(tokenType);
    tokenText = "'" + tokenText + "'";
  }
  return " line "
      + line
      + ":"
      + col
      + " "
      + channel
      + " "
      + tokenName
      + ":"
      + tokenText
      + (!"DEFAULT_MODE".equals(mode) ? "  <== mode:" + mode : "");
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

public List<Token> getRealTokens(int from, int to) {
	List<Token> real = new ArrayList<Token>();
	for (int i=from; i<=to; i++) {
		Token t = tokens.get(i);
		if ( t.getChannel()==Lexer.DEFAULT_TOKEN_CHANNEL ) real.add(t);
	}
	if ( real.size()==0 ) return null;
	return real;
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _lastTokenType = token.getType();
  }
}
 

/**
 * Return the next token from the character stream and records this last
 * token in case it resides on the default channel. This recorded token
 * is used to determine when the lexer could possibly match a regex
 * literal. Also changes scopeStrictModes stack if tokenize special
 * string 'use strict';
 *
 * @return the next token from the character stream.
 */
@Override
public Token nextToken() {
    Token next = super.nextToken();

    if (next.getChannel() == Token.DEFAULT_CHANNEL) {
        // Keep track of the last token on the default channel.
        this.lastToken = next;
    }

    return next;
}
 

@Override
public final void emit(Token token) {
  super.emit(token);
  if (token.getChannel() != HIDDEN) {
    _secondToLastTokenType = _lastTokenType;
    _lastTokenType = token.getType();
  }
}
 

/**
 * Return the next token from the character stream and records this last
 * token in case it resides on the default channel. This recorded token
 * is used to determine when the lexer could possibly match a regex
 * literal.
 *
 * @return the next token from the character stream.
 */
@Override
public Token nextToken() {

    // Get the next token.
    Token next = super.nextToken();

    if (next.getChannel() == Token.DEFAULT_CHANNEL) {
        // Keep track of the last token on the default channel.
        this.lastToken = next;
    }

    return next;
}
 

public static boolean isEmptyStatement(String sql)
{
    TokenSource tokens = getLexer(sql, ImmutableSet.of());
    while (true) {
        Token token = tokens.nextToken();
        if (token.getType() == Token.EOF) {
            return true;
        }
        if (token.getChannel() != Token.HIDDEN_CHANNEL) {
            return false;
        }
    }
}
 

private boolean isWhitespace(Token token) {
    return token.getChannel() == ProtoLexer.HIDDEN
            && token.getType() != ProtoLexer.LINE_COMMENT;
}
 

/**
 * Returns {@code true} iff on the current index of the parser's
 * token stream a token of the given {@code type} exists on the
 * {@code HIDDEN} channel.
 *
 * @param type the type of the token on the {@code HIDDEN} channel
 *             to check.
 * @return {@code true} iff on the current index of the parser's
 * token stream a token of the given {@code type} exists on the
 * {@code HIDDEN} channel.
 */
private boolean here(final int type) {

    // Get the token ahead of the current index.
    int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1;
    Token ahead = _input.get(possibleIndexEosToken);

    // Check if the token resides on the HIDDEN channel and if it's of the
    // provided type.
    return (ahead.getChannel() == Lexer.HIDDEN) && (ahead.getType() == type);
}