List of usage examples for org.antlr.v4.runtime Token HIDDEN_CHANNEL
int HIDDEN_CHANNEL
To view the source code for org.antlr.v4.runtime Token HIDDEN_CHANNEL.
Click Source Link
From source file:ai.grakn.graql.Autocomplete.java
License:Open Source License
/** * @param query a graql query//from ww w.j a v a 2 s .co m * @param cursorPosition the cursor position in the query * @return the token at the cursor position in the given graql query */ private static Optional<? extends Token> getCursorToken(String query, int cursorPosition) { if (query == null) return Optional.empty(); return getTokens(query).stream().filter(t -> t.getChannel() != Token.HIDDEN_CHANNEL) .filter(t -> t.getStartIndex() <= cursorPosition && t.getStopIndex() >= cursorPosition - 1) .findFirst(); }
From source file:com.github.jknack.handlebars.internal.MustacheSpec.java
License:Apache License
/** * Move tokens to the hidden channel if necessary. */// w w w.j a v a 2 s . c om private void stripSpaces() { boolean hasTag = this.hasTag == null ? false : this.hasTag.booleanValue(); if (hasTag && !nonSpace) { for (CommonToken space : spaces) { space.setChannel(Token.HIDDEN_CHANNEL); } } else { spaces.clear(); } this.hasTag = null; nonSpace = false; line.setLength(0); }
From source file:com.github.jknack.handlebars.internal.TemplateBuilder.java
License:Apache License
@Override public Template visitSpaces(final SpacesContext ctx) { Token space = ctx.SPACE().getSymbol(); String text = space.getText(); line.append(text);//from ww w . j a v a2 s . co m if (space.getChannel() == Token.HIDDEN_CHANNEL) { return null; } return new Text(text).filename(source.filename()).position(ctx.start.getLine(), ctx.start.getCharPositionInLine()); }
From source file:com.github.jknack.handlebars.internal.TemplateBuilder.java
License:Apache License
@Override public BaseTemplate visitNewline(final NewlineContext ctx) { Token newline = ctx.NL().getSymbol(); if (newline.getChannel() == Token.HIDDEN_CHANNEL) { return null; }/*from w w w . j a v a 2s.c o m*/ line.setLength(0); return new Text(newline.getText()).filename(source.filename()).position(newline.getLine(), newline.getCharPositionInLine()); }
From source file:com.github.jknack.handlebars.internal.WhiteSpaceControl.java
License:Apache License
/** Move space tokens to the hidden channel. */ private void hideSpaces() { for (CommonToken space : spaces) { space.setChannel(Token.HIDDEN_CHANNEL); }/*from w ww .j av a 2s . co m*/ }
From source file:io.prestosql.sql.parser.StatementSplitter.java
License:Apache License
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; }// w w w .j a va2 s . com if (token.getChannel() != Token.HIDDEN_CHANNEL) { return false; } } }
From source file:net.certiv.json.parser.JsonErrorListener.java
License:Open Source License
@Override public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) { Parser parser = (Parser) recognizer; String name = parser.getSourceName(); TokenStream tokens = parser.getInputStream(); Token offSymbol = (Token) offendingSymbol; int thisError = offSymbol.getTokenIndex(); if (offSymbol.getType() == -1 && thisError == tokens.size() - 1) { Log.debug(this, name + ": Incorrect error: " + msg); return;//from ww w . j a va2s . c om } String offSymName = JsonLexer.VOCABULARY.getSymbolicName(offSymbol.getType()); if (thisError > lastError + 10) { lastError = thisError - 10; } for (int idx = lastError + 1; idx <= thisError; idx++) { Token token = tokens.get(idx); if (token.getChannel() != Token.HIDDEN_CHANNEL) Log.error(this, name + ":" + token.toString()); } lastError = thisError; List<String> stack = parser.getRuleInvocationStack(); Collections.reverse(stack); Log.error(this, name + " rule stack: " + stack); Log.error(this, name + " line " + line + ":" + charPositionInLine + " at " + offSymName + ": " + msg); }
From source file:net.openchrom.xxd.processor.supplier.rscripting.ui.editor.RFilter.java
License:Open Source License
public final EatContext eat() throws RecognitionException { EatContext _localctx = new EatContext(_ctx, getState()); enterRule(_localctx, 2, RULE_eat);/*from w w w. j a v a 2 s . c om*/ try { int _alt; enterOuterAlt(_localctx, 1); { setState(22); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(20); ((EatContext) _localctx).NL = match(NL); ((WritableToken) ((EatContext) _localctx).NL).setChannel(Token.HIDDEN_CHANNEL); } } break; default: throw new NoViableAltException(this); } setState(24); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input, 2, _ctx); } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; }
From source file:net.openchrom.xxd.processor.supplier.rscripting.ui.editor.RFilter.java
License:Open Source License
public final ElemContext elem() throws RecognitionException { ElemContext _localctx = new ElemContext(_ctx, getState()); enterRule(_localctx, 4, RULE_elem);// w w w . java2s .c o m int _la; try { setState(146); switch (_input.LA(1)) { case T__59: case T__58: case T__54: case T__53: case T__52: case T__50: case T__49: case T__45: case T__44: case T__40: case T__38: case T__37: case T__35: case T__33: case T__32: case T__29: case T__27: case T__25: case T__21: case T__20: case T__19: case T__17: case T__16: case T__15: case T__14: case T__12: case T__10: case T__9: case T__8: case T__6: case T__5: case T__1: case T__0: case USER_OP: enterOuterAlt(_localctx, 1); { setState(26); op(); setState(28); switch (getInterpreter().adaptivePredict(_input, 3, _ctx)) { case 1: { setState(27); eat(); } break; } } break; case T__46: case T__42: case T__39: case T__30: case T__28: case T__18: case T__13: case T__3: case HEX: case INT: case FLOAT: case COMPLEX: case STRING: case ID: enterOuterAlt(_localctx, 2); { setState(30); atom(); } break; case T__55: enterOuterAlt(_localctx, 3); { setState(31); match(T__55); setState(33); switch (getInterpreter().adaptivePredict(_input, 4, _ctx)) { case 1: { setState(32); eat(); } break; } curlies++; setState(41); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__24) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(39); switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) { case 1: { setState(36); elem(); } break; case 2: { setState(37); match(NL); } break; case 3: { setState(38); match(T__24); } break; } } setState(43); _errHandler.sync(this); _la = _input.LA(1); } curlies--; setState(45); match(T__23); } break; case T__47: enterOuterAlt(_localctx, 4); { setState(46); match(T__47); setState(51); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(49); switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) { case 1: { setState(47); elem(); } break; case 2: { setState(48); eat(); } break; } } setState(53); _errHandler.sync(this); _la = _input.LA(1); } setState(54); match(T__2); } break; case T__11: enterOuterAlt(_localctx, 5); { setState(55); match(T__11); setState(60); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(58); switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) { case 1: { setState(56); elem(); } break; case 2: { setState(57); eat(); } break; } } setState(62); _errHandler.sync(this); _la = _input.LA(1); } setState(63); match(T__34); } break; case T__36: enterOuterAlt(_localctx, 6); { setState(64); match(T__36); setState(69); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(67); switch (getInterpreter().adaptivePredict(_input, 11, _ctx)) { case 1: { setState(65); elem(); } break; case 2: { setState(66); eat(); } break; } } setState(71); _errHandler.sync(this); _la = _input.LA(1); } setState(72); match(T__34); setState(73); match(T__34); } break; case T__31: enterOuterAlt(_localctx, 7); { setState(74); match(T__31); setState(76); _la = _input.LA(1); if (_la == NL) { { setState(75); eat(); } } setState(78); match(T__47); setState(83); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(81); switch (getInterpreter().adaptivePredict(_input, 14, _ctx)) { case 1: { setState(79); elem(); } break; case 2: { setState(80); eat(); } break; } } setState(85); _errHandler.sync(this); _la = _input.LA(1); } setState(86); match(T__2); setState(88); switch (getInterpreter().adaptivePredict(_input, 16, _ctx)) { case 1: { setState(87); eat(); } break; } } break; case T__51: enterOuterAlt(_localctx, 8); { setState(90); match(T__51); setState(92); _la = _input.LA(1); if (_la == NL) { { setState(91); eat(); } } setState(94); match(T__47); setState(99); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(97); switch (getInterpreter().adaptivePredict(_input, 18, _ctx)) { case 1: { setState(95); elem(); } break; case 2: { setState(96); eat(); } break; } } setState(101); _errHandler.sync(this); _la = _input.LA(1); } setState(102); match(T__2); setState(104); switch (getInterpreter().adaptivePredict(_input, 20, _ctx)) { case 1: { setState(103); eat(); } break; } } break; case T__56: enterOuterAlt(_localctx, 9); { setState(106); match(T__56); setState(108); _la = _input.LA(1); if (_la == NL) { { setState(107); eat(); } } setState(110); match(T__47); setState(115); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(113); switch (getInterpreter().adaptivePredict(_input, 22, _ctx)) { case 1: { setState(111); elem(); } break; case 2: { setState(112); eat(); } break; } } setState(117); _errHandler.sync(this); _la = _input.LA(1); } setState(118); match(T__2); setState(120); switch (getInterpreter().adaptivePredict(_input, 24, _ctx)) { case 1: { setState(119); eat(); } break; } } break; case T__22: enterOuterAlt(_localctx, 10); { setState(122); match(T__22); setState(124); _la = _input.LA(1); if (_la == NL) { { setState(123); eat(); } } setState(126); match(T__47); setState(131); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__58) | (1L << T__56) | (1L << T__55) | (1L << T__54) | (1L << T__53) | (1L << T__52) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__47) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__42) | (1L << T__40) | (1L << T__39) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__35) | (1L << T__33) | (1L << T__32) | (1L << T__31) | (1L << T__30) | (1L << T__29) | (1L << T__28) | (1L << T__27) | (1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__16) | (1L << T__15) | (1L << T__14) | (1L << T__13) | (1L << T__12) | (1L << T__11) | (1L << T__10) | (1L << T__9) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__4) | (1L << T__3) | (1L << T__1) | (1L << T__0) | (1L << HEX) | (1L << INT) | (1L << FLOAT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COMPLEX - 64)) | (1L << (STRING - 64)) | (1L << (ID - 64)) | (1L << (USER_OP - 64)) | (1L << (NL - 64)))) != 0)) { { setState(129); switch (getInterpreter().adaptivePredict(_input, 26, _ctx)) { case 1: { setState(127); elem(); } break; case 2: { setState(128); eat(); } break; } } setState(133); _errHandler.sync(this); _la = _input.LA(1); } setState(134); match(T__2); setState(136); switch (getInterpreter().adaptivePredict(_input, 28, _ctx)) { case 1: { setState(135); eat(); } break; } } break; case T__4: case NL: enterOuterAlt(_localctx, 11); { setState(139); _la = _input.LA(1); if (_la == NL) { { setState(138); eat(); } } setState(141); match(T__4); setState(143); switch (getInterpreter().adaptivePredict(_input, 30, _ctx)) { case 1: { setState(142); eat(); } break; } // ``inside a compound expression, a newline before else is discarded, // whereas at the outermost level, the newline terminates the if // construction and a subsequent else causes a syntax error.'' /* * Works here * if (1==0) { print(1) } else { print(2) } * and correctly gets error here: * if (1==0) { print(1) } * else { print(2) } * this works too: * if (1==0) { * if (2==0) print(1) * else print(2) * } */ WritableToken tok = (WritableToken) _input.LT(-2); if (curlies > 0 && tok.getType() == NL) tok.setChannel(Token.HIDDEN_CHANNEL); } break; default: throw new NoViableAltException(this); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; }
From source file:org.ballerinalang.composer.service.workspace.suggetions.CapturePossibleTokenStrategy.java
License:Open Source License
/** * Checks whether cursor is within the whitespace region between current token to last token * @param token Token to be evaluated// w ww . j av a2s . c o m * @param parser Parser Instance * @return true|false */ protected boolean isCursorBetweenGivenTokenAndLastNonHiddenToken(Token token, Parser parser) { boolean isCursorBetween = false; if (cursorPosition.equals(getSourcePosition(token))) { isCursorBetween = true; } else { Token lastNonHiddenToken = null; for (int tokenIdx = token.getTokenIndex() - 1; tokenIdx >= 0; tokenIdx--) { Token lastToken = parser.getTokenStream().get(tokenIdx); if (lastToken.getChannel() != Token.HIDDEN_CHANNEL) { lastNonHiddenToken = lastToken; break; } } if (lastNonHiddenToken != null) { if (cursorPosition.getLine() >= lastNonHiddenToken.getLine() && cursorPosition.getLine() <= token.getLine()) { if (cursorPosition.getLine() == lastNonHiddenToken.getLine()) { isCursorBetween = cursorPosition .getCharacter() >= (lastNonHiddenToken.getCharPositionInLine() + lastNonHiddenToken.getText().length()); } else if (cursorPosition.getLine() == token.getLine()) { isCursorBetween = cursorPosition.getCharacter() <= token.getCharPositionInLine(); } else { isCursorBetween = true; } } } } return isCursorBetween; }