Example usage for org.antlr.v4.runtime Token getText

Introduction

In this page you can find the example usage for org.antlr.v4.runtime Token getText.

Prototype

String getText();

Source Link

Document

Get the text of the token.

Usage

From source file:org.ballerinalang.composer.service.workspace.langserver.util.resolvers.parsercontext.ParserRuleExpressionVariableDefStatementContextResolver.java

License:Open Source License

/**
 * Get the index of the given token/*from  w  w w .j  a  v a2 s  . co m*/
 * @param dataModel suggestions filter data model
 * @param tokenString token string to be found
 * @return {@link Integer}
 */
private int getTokenIndexOf(SuggestionsFilterDataModel dataModel, String tokenString) {
    TokenStream tokenStream = dataModel.getTokenStream();
    int currentTokenIndex = dataModel.getTokenIndex();
    int searchIndex = currentTokenIndex - 1;
    List<String> terminatingCharacters = Arrays.asList(";", "{", "}", "@");

    while (true) {
        if (tokenStream != null && searchIndex < tokenStream.size()) {
            Token token = tokenStream.get(searchIndex);
            String tokenStr = token.getText();

            if (token.getChannel() == Token.DEFAULT_CHANNEL && terminatingCharacters.contains(tokenStr)) {
                return -1;
            } else if (tokenStr.equals(tokenString)) {
                return searchIndex;
            } else {
                searchIndex--;
            }
        } else {
            return -1;
        }
    }
}

---

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/*from  w w w .  java 2  s . com*/
 * @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;
}

---

From source file:org.ballerinalang.langserver.completions.BallerinaCustomErrorStrategy.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 w  w.j av  a 2s  .c  o  m*/
 * @param parser Parser Instance
 * @return true|false
 */
private boolean isCursorBetweenGivenTokenAndLastNonHiddenToken(Token token, Parser parser) {
    this.setContextException(parser);
    boolean isCursorBetween = false;
    int line = this.context.get(DocumentServiceKeys.POSITION_KEY).getPosition().getLine();
    int character = this.context.get(DocumentServiceKeys.POSITION_KEY).getPosition().getCharacter();

    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) {

        // Convert the token lines and char positions to zero based indexing
        int lastNonHiddenTokenLine = lastNonHiddenToken.getLine() - 1;
        int lastNonHiddenTokenChar = lastNonHiddenToken.getCharPositionInLine();
        int tokenLine = token.getLine() - 1;
        int tokenChar = token.getCharPositionInLine();

        if (line >= lastNonHiddenTokenLine && line <= tokenLine) {
            if (line == lastNonHiddenTokenLine) {
                isCursorBetween = character >= (lastNonHiddenTokenChar + lastNonHiddenToken.getText().length());
            } else {
                isCursorBetween = line != tokenLine || character <= tokenChar;
            }
        }
    }
    return isCursorBetween;
}

---

From source file:org.ballerinalang.langserver.completions.CompletionCustomErrorStrategy.java

License:Open Source License

private Token getLastTerminationToken(TokenStream tokenStream) {
    Token lastTerminationToken = null;/*from  w ww.j  a  v a2s  .c  om*/
    Position cursorPosition = this.context.get(DocumentServiceKeys.POSITION_KEY).getPosition();
    int cursorLine = cursorPosition.getLine() + 1;
    int cursorCol = cursorPosition.getCharacter() + 1;

    int index = 1;
    Token beforeCursorToken = tokenStream.LT(index);
    int type = beforeCursorToken.getType();
    int tLine = beforeCursorToken.getLine();
    int tCol = beforeCursorToken.getCharPositionInLine();

    while (type != BallerinaParser.EOF && ((tLine < cursorLine) || (tLine == cursorLine && tCol < cursorCol))) {
        // Checking for terminating tokens with the type number is inconsistent. Thus, uses string comparisons
        String tokenText = beforeCursorToken.getText();
        if (UtilSymbolKeys.SEMI_COLON_SYMBOL_KEY.equals(tokenText)
                || UtilSymbolKeys.OPEN_BRACE_KEY.equals(tokenText)
                || UtilSymbolKeys.CLOSE_BRACE_KEY.equals(tokenText)
                || UtilSymbolKeys.COMMA_SYMBOL_KEY.equals(tokenText)) {
            lastTerminationToken = beforeCursorToken;
        }
        index++;
        beforeCursorToken = tokenStream.LT(index);
        type = beforeCursorToken.getType();
        tLine = beforeCursorToken.getLine();
        tCol = beforeCursorToken.getCharPositionInLine();
    }
    return lastTerminationToken;
}

---

From source file:org.ballerinalang.langserver.completions.CompletionSubRuleParser.java

License:Open Source License

private static boolean fillAnnotationAttachmentMetaInfo(LSContext ctx) {
    if (ctx.get(CompletionKeys.TOKEN_STREAM_KEY) == null) {
        return false;
    }//from  ww w. ja va 2 s.com
    TokenStream tokenStream = ctx.get(CompletionKeys.TOKEN_STREAM_KEY);
    Position cursorPosition = ctx.get(DocumentServiceKeys.POSITION_KEY).getPosition();
    Queue<String> fieldsQueue = new LinkedList<>();
    ArrayList<String> terminalTokens = new ArrayList<>(
            Arrays.asList(UtilSymbolKeys.FUNCTION_KEYWORD_KEY, UtilSymbolKeys.SERVICE_KEYWORD_KEY,
                    UtilSymbolKeys.ENDPOINT_KEYWORD_KEY, UtilSymbolKeys.OPEN_PARENTHESES_KEY));
    int currentTokenIndex = CommonUtil.getCurrentTokenFromTokenStream(ctx);
    int startIndex = currentTokenIndex;
    int line = cursorPosition.getLine();
    int col = cursorPosition.getCharacter();
    String annotationName;
    String pkgAlias = "";

    while (true) {
        if (startIndex > tokenStream.size()
                || CommonUtil.getPreviousDefaultToken(tokenStream, startIndex) == null) {
            return false;
        }
        Token token = CommonUtil.getPreviousDefaultToken(tokenStream, startIndex);
        if (token == null || terminalTokens.contains(token.getText())) {
            return false;
        }
        if (token.getText().equals(UtilSymbolKeys.ANNOTATION_START_SYMBOL_KEY)) {
            // Breaks when we meet the first annotation start before the given start index
            break;
        } else if (token.getText().equals(UtilSymbolKeys.OPEN_BRACE_KEY)) {
            startIndex = token.getTokenIndex();
            // For each annotation found, capture the package alias
            if (UtilSymbolKeys.PKG_DELIMITER_KEYWORD
                    .equals(CommonUtil.getNthDefaultTokensToLeft(tokenStream, startIndex, 2).getText())) {
                pkgAlias = CommonUtil.getNthDefaultTokensToLeft(tokenStream, startIndex, 3).getText();
            }
        } else {
            startIndex = token.getTokenIndex();
        }
    }

    String tempTokenString = "";
    while (true) {
        if (startIndex > tokenStream.size()) {
            return false;
        }
        Token token = CommonUtil.getNextDefaultToken(tokenStream, startIndex);
        int tokenLine = token.getLine() - 1;
        int tokenCol = token.getCharPositionInLine();
        if (terminalTokens.contains(token.getText()) || line < tokenLine
                || (line == tokenLine - 1 && col - 1 < tokenCol)) {
            break;
        } else if (UtilSymbolKeys.OPEN_BRACE_KEY.equals(token.getText())) {
            fieldsQueue.add(tempTokenString);
        } else if (UtilSymbolKeys.CLOSE_BRACE_KEY.equals(token.getText())) {
            fieldsQueue.remove();
        } else if (!UtilSymbolKeys.PKG_DELIMITER_KEYWORD.equals(token.getText())) {
            tempTokenString = token.getText();
        }
        startIndex = token.getTokenIndex();
    }

    annotationName = fieldsQueue.poll();
    ctx.put(CompletionKeys.ANNOTATION_ATTACHMENT_META_KEY, new AnnotationAttachmentMetaInfo(annotationName,
            fieldsQueue, pkgAlias, getNextNodeTypeFlag(tokenStream, currentTokenIndex, ctx)));
    ctx.put(CompletionKeys.SYMBOL_ENV_NODE_KEY, new BLangAnnotationAttachment());

    return true;
}

---

From source file:org.ballerinalang.langserver.completions.CompletionSubRuleParser.java

License:Open Source License

private static AnnotationNodeKind getNextNodeTypeFlag(TokenStream tokenStream, int index, LSContext context) {
    AnnotationNodeKind nodeType = context.get(CompletionKeys.NEXT_NODE_KEY);
    Map<String, AnnotationNodeKind> flagsMap = new HashMap<>();
    flagsMap.put(UtilSymbolKeys.SERVICE_KEYWORD_KEY, AnnotationNodeKind.SERVICE);
    flagsMap.put(UtilSymbolKeys.RESOURCE_KEYWORD_KEY, AnnotationNodeKind.RESOURCE);

    while (true) {
        if (tokenStream == null || index >= tokenStream.size()) {
            break;
        }/*from w  w w . jav  a 2 s  .co m*/
        Token token = CommonUtil.getNextDefaultToken(tokenStream, index);
        if (token.getText().equals(UtilSymbolKeys.SEMI_COLON_SYMBOL_KEY)) {
            break;
        } else if (flagsMap.containsKey(token.getText())) {
            nodeType = flagsMap.get(token.getText());
            break;
        }
        index = token.getTokenIndex();
    }

    return nodeType;
}

---

From source file:org.ballerinalang.langserver.completions.CompletionSubRuleParser.java

License:Open Source License

private static void reCalculatePoppedTokensForTopLevel(LSContext ctx) {
    if (ctx.get(CompletionKeys.TOKEN_STREAM_KEY) == null) {
        return;/*from  www. ja  va  2s . c  om*/
    }
    int currentTokenIndex = CommonUtil.getCurrentTokenFromTokenStream(ctx);
    TokenStream tokenStream = ctx.get(CompletionKeys.TOKEN_STREAM_KEY);
    Stack<Token> tokenStack = new Stack<>();
    while (true) {
        if (currentTokenIndex < 0) {
            break;
        }
        Token token = CommonUtil.getPreviousDefaultToken(tokenStream, currentTokenIndex);
        if (token == null) {
            return;
        }
        String tokenString = token.getText();
        tokenStack.push(token);
        if (tokenString.equals(ItemResolverConstants.SERVICE)
                || tokenString.equals(ItemResolverConstants.FUNCTION)
                || tokenString.equals(ItemResolverConstants.TYPE)
                || tokenString.equals(ItemResolverConstants.ENDPOINT)) {
            break;
        }
        currentTokenIndex = token.getTokenIndex();
    }
    Collections.reverse(tokenStack);
    ctx.put(CompletionKeys.FORCE_CONSUMED_TOKENS_KEY, tokenStack);
}

---

From source file:org.ballerinalang.langserver.completions.providers.subproviders.parsercontext.ParserRuleServiceDefinitionCompletionProvider.java

License:Open Source License

@Override
public List<CompletionItem> resolveItems(LSContext ctx) {
    List<CompletionItem> completionItems = new ArrayList<>();
    TokenStream tokenStream = ctx.get(CompletionKeys.TOKEN_STREAM_KEY);
    Stack<Token> poppedTokens = ctx.get(CompletionKeys.FORCE_CONSUMED_TOKENS_KEY);
    int startIndex = poppedTokens.peek().getTokenIndex() + 1;
    String stopToken = "";

    // Backtrack the tokens from the head of the popped tokens in order determine the cursor position
    tokenScanner: while (true) {
        Token token = CommonUtil.getPreviousDefaultToken(tokenStream, startIndex);
        String tokenString = token.getText();
        switch (tokenString) {
        case ItemResolverConstants.SERVICE:
        case ItemResolverConstants.ON:
        case ItemResolverConstants.NEW:
        case UtilSymbolKeys.PKG_DELIMITER_KEYWORD:
            stopToken = tokenString;/*from   ww w.j  av  a 2 s  .c o m*/
            break tokenScanner;
        default:
            break;
        }

        startIndex = token.getTokenIndex();
    }

    boolean isSnippet = ctx.get(CompletionKeys.CLIENT_CAPABILITIES_KEY).getCompletionItem().getSnippetSupport();

    switch (stopToken) {
    case ItemResolverConstants.ON: {
        // suggest all the visible, defined listeners
        List<SymbolInfo> filtered = this.filterListenerVariables(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY));
        completionItems.addAll(this.getCompletionItemList(filtered, ctx));
        completionItems.add(Snippet.KW_NEW.get().build(ctx, isSnippet));
        break;
    }
    case ItemResolverConstants.NEW: {
        List<SymbolInfo> filteredSymbols = this
                .filterListenerTypes(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY));
        completionItems.addAll(this.getCompletionItemList(filteredSymbols, ctx));
        completionItems.addAll(this.getPackagesCompletionItems(ctx));
        break;
    }
    case UtilSymbolKeys.PKG_DELIMITER_KEYWORD: {
        Either<List<CompletionItem>, List<SymbolInfo>> eitherList = SymbolFilters
                .get(DelimiterBasedContentFilter.class).filterItems(ctx);
        completionItems.addAll(this.getCompletionItemList(eitherList, ctx));
        break;
    }
    default: {
        // Fill the on keyword completion item
        completionItems.add(Snippet.KW_ON.get().build(ctx, isSnippet));
        break;
    }
    }

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.resolvers.parsercontext.ParserRuleCallableUnitBodyContextResolver.java

License:Open Source License

@Override
public ArrayList<CompletionItem> resolveItems(TextDocumentServiceContext completionContext) {
    int tokenIndex = completionContext.get(DocumentServiceKeys.TOKEN_INDEX_KEY);
    int endpointTokenIndex = -1;
    String tokenString;/*from   www  .  java  2s .co  m*/
    TokenStream tokenStream = completionContext.get(DocumentServiceKeys.TOKEN_STREAM_KEY);
    Position position = completionContext.get(DocumentServiceKeys.POSITION_KEY).getPosition();
    ArrayList<CompletionItem> completionItems = new ArrayList<>();

    while (true) {
        if (tokenIndex > tokenStream.size() - 1) {
            break;
        }
        tokenString = tokenStream.get(tokenIndex).getText();
        if (isCursorBeforeToken(position, tokenStream.get(tokenIndex))) {
            break;
        } else if (tokenString.equals(ENDPOINT_KEYWORD)) {
            endpointTokenIndex = tokenIndex;
        }
        tokenIndex++;
    }

    if (endpointTokenIndex > 0) {
        Token tokenBeforeCursor = CommonUtil.getPreviousDefaultToken(tokenStream, tokenIndex - 1);
        switch (tokenBeforeCursor.getText()) {
        case "create":
        case "<":
            this.populateCompletionItemList(getPackagesAndConnectors(completionContext), completionItems);
            break;
        default:
            break;
        }
    }

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.resolvers.parsercontext.ParserRuleServiceDefinitionContextResolver.java

License:Open Source License

@Override
public List<CompletionItem> resolveItems(LSServiceOperationContext ctx) {
    List<CompletionItem> completionItems = new ArrayList<>();
    TokenStream tokenStream = ctx.get(CompletionKeys.TOKEN_STREAM_KEY);
    Stack<Token> poppedTokens = ctx.get(CompletionKeys.FORCE_CONSUMED_TOKENS_KEY);
    int startIndex = poppedTokens.peek().getTokenIndex() + 1;
    String stopToken = "";

    // Backtrack the tokens from the head of the popped tokens in order determine the cursor position
    tokenScanner: while (true) {
        Token token = CommonUtil.getPreviousDefaultToken(tokenStream, startIndex);
        String tokenString = token.getText();
        switch (tokenString) {
        case ItemResolverConstants.SERVICE:
        case ItemResolverConstants.ON:
        case ItemResolverConstants.NEW:
        case UtilSymbolKeys.PKG_DELIMITER_KEYWORD:
            stopToken = tokenString;//from  ww  w . ja  v  a2s . co m
            break tokenScanner;
        default:
            break;
        }

        startIndex = token.getTokenIndex();
    }

    boolean isSnippet = ctx.get(CompletionKeys.CLIENT_CAPABILITIES_KEY).getCompletionItem().getSnippetSupport();

    switch (stopToken) {
    case ItemResolverConstants.ON: {
        // suggest all the visible, defined listeners
        List<SymbolInfo> filtered = this.filterListenerVariables(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY));
        completionItems.addAll(this.getCompletionItemList(filtered, ctx));
        completionItems.add(Snippet.KW_NEW.get().build(ctx, isSnippet));
        break;
    }
    case ItemResolverConstants.NEW: {
        List<SymbolInfo> filteredSymbols = this
                .filterListenerTypes(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY));
        completionItems.addAll(this.getCompletionItemList(filteredSymbols, ctx));
        completionItems.addAll(this.getPackagesCompletionItems(ctx));
        break;
    }
    case UtilSymbolKeys.PKG_DELIMITER_KEYWORD: {
        Either<List<CompletionItem>, List<SymbolInfo>> eitherList = SymbolFilters
                .get(DelimiterBasedContentFilter.class).filterItems(ctx);
        completionItems.addAll(this.getCompletionItemList(eitherList, ctx));
        break;
    }
    default: {
        // Fill the on keyword completion item
        completionItems.add(Snippet.KW_ON.get().build(ctx, isSnippet));
        break;
    }
    }

    return completionItems;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• »