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

List of usage examples for org.antlr.v4.runtime Token getText

  1. HOME
  2. Java
  3. org.antlr
  4. org.antlr.v4.runtime.*
  5. Token
  6. 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.tvl.goworks.editor.go.parser.GoParser.java

License:Open Source License

@Override
protected boolean isBuiltInMethodWithType(Token token) {
    return token != null && PREDEFINED_FUNCTIONS_WITH_TYPE.contains(token.getText());
}

From source file:org.tvl.goworks.editor.go.semantics.SemanticAnalyzerListener.java

License:Open Source License

private boolean resolveIdentifier(TerminalNode node, PackageModel packageModel) {
    Token token = node.getSymbol();
    Collection<? extends CodeElementModel> members = packageModel.getMembers(token.getText());
    for (CodeElementModel model : members) {
        NodeType nodeType = NodeType.UNDEFINED;
        VarKind varType = VarKind.UNDEFINED;
        TypeKind typeKind = TypeKind.UNDEFINED;
        boolean global = true;
        boolean resolved = true;
        if (model instanceof ConstModel) {
            nodeType = NodeType.CONST_REF;
        } else if (model instanceof VarModel) {
            nodeType = NodeType.VAR_REF;
            varType = VarKind.GLOBAL;//  w w  w. j ava  2 s  .  c o m
        } else if (model instanceof TypeModel) {
            nodeType = NodeType.TYPE_REF;
            typeKind = ((TypeModel) model).getKind();
        } else if (model instanceof FunctionModel) {
            nodeType = NodeType.FUNC_REF;
        } else {
            resolved = false;
        }

        if (nodeType != NodeType.UNDEFINED) {
            treeDecorator.putProperty(node, GoAnnotations.NODE_TYPE, nodeType);
        }

        if (resolved) {
            treeDecorator.putProperty(node, GoAnnotations.RESOLVED, true);
        }

        if (varType != VarKind.UNDEFINED) {
            treeDecorator.putProperty(node, GoAnnotations.VAR_TYPE, varType);
        }

        if (typeKind != TypeKind.UNDEFINED) {
            treeDecorator.putProperty(node, GoAnnotations.TYPE_KIND, typeKind);
        }

        treeDecorator.putProperty(node, GoAnnotations.GLOBAL, true);
        treeDecorator.putProperty(node, GoAnnotations.MODELS, members);
        return true;
    }

    return false;
}

From source file:org.tvl.goworks.editor.go.semantics.SemanticAnalyzerListener.java

License:Open Source License

@RuleDependency(recognizer = GoParser.class, rule = GoParser.RULE_packageName, version = 0)
private boolean resolveQualifiedIdentifier(TerminalNode node, PackageModel currentPackage,
        Map<String, Collection<PackageModel>> resolvedPackages) {
    Token token = node.getSymbol();
    if (treeDecorator.getProperty(node, GoAnnotations.NODE_TYPE) != NodeType.UNDEFINED) {
        // already resolved
        return false;
    }/* w ww.ja v  a2s. c o m*/

    ParserRuleContext qualifier = treeDecorator.getProperty(node, GoAnnotations.QUALIFIER);
    if (qualifier == null) {
        // don't have the information necessary to resolve
        return false;
    }

    Collection<? extends CodeElementModel> resolvedQualifier = treeDecorator.getProperty(qualifier,
            GoAnnotations.MODELS);
    if (resolvedQualifier == null) {
        CodeElementReference qualifierCodeClass = treeDecorator.getProperty(qualifier,
                GoAnnotations.CODE_CLASS);
        assert qualifierCodeClass != null;
        if (qualifierCodeClass != CodeElementReference.MISSING) {
            resolvedQualifier = qualifierCodeClass.resolve(annotatedParseTree, currentPackage,
                    resolvedPackages);
        }
    }

    if (resolvedQualifier == null) {
        CodeElementReference qualifierExprType = treeDecorator.getProperty(qualifier, GoAnnotations.EXPR_TYPE);
        assert qualifierExprType != null;
        if (qualifierExprType != CodeElementReference.MISSING) {
            resolvedQualifier = qualifierExprType.resolve(annotatedParseTree, currentPackage, resolvedPackages);
        }
    }

    if (resolvedQualifier == null) {
        NodeType qualifierNodeType = treeDecorator.getProperty(qualifier, GoAnnotations.NODE_TYPE);
        if (qualifierNodeType == NodeType.UNDEFINED) {
            if (treeDecorator.getProperty(qualifier, GoAnnotations.QUALIFIED_EXPR)) {
                // haven't resolved the qualifier, which is itself a qualified expression
                return false;
            }

            TerminalNode unqualifiedLink = treeDecorator.getProperty(qualifier, GoAnnotations.UNQUALIFIED_LINK);
            if (unqualifiedLink != null) {
                Map<? extends ObjectProperty<?>, ?> properties = treeDecorator.getProperties(unqualifiedLink);
                treeDecorator.putProperties(qualifier, properties);
                qualifierNodeType = treeDecorator.getProperty(qualifier, GoAnnotations.NODE_TYPE);
                if (qualifierNodeType == NodeType.UNDEFINED) {
                    treeDecorator.putProperty(qualifier, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
                    qualifierNodeType = NodeType.UNKNOWN;
                }
            } else {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve unqualified link from qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                qualifierNodeType = NodeType.UNKNOWN;
            }
        }

        assert qualifierNodeType != NodeType.UNDEFINED;

        if (qualifierNodeType == NodeType.UNKNOWN) {
            // can't resolve a dereference if the qualifier couldn't be resolved
            treeDecorator.putProperty(node, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
            return true;
        }

        if (qualifierNodeType == NodeType.TYPE_LITERAL) {
            return resolveQualifierType(qualifier, currentPackage, resolvedPackages);
        } else if (qualifierNodeType == NodeType.PACKAGE_REF) {
            assert qualifier instanceof PackageNameContext;
            String packageName = ((PackageNameContext) qualifier).IDENTIFIER().getSymbol().getText();
            resolvedQualifier = resolvedPackages.get(packageName);
            if (resolvedQualifier == null) {
                resolvedQualifier = Collections.emptyList();
            }
        } else if (qualifierNodeType == NodeType.VAR_REF) {
            // must be referring to something within the current file since it's resolved internally
            TerminalNode target = treeDecorator.getProperty(qualifier, GoAnnotations.LOCAL_TARGET);
            assert target != null
                    && treeDecorator.getProperty(target, GoAnnotations.NODE_TYPE) == NodeType.VAR_DECL;
            ParserRuleContext explicitType = treeDecorator.getProperty(qualifier, GoAnnotations.EXPLICIT_TYPE);
            if (explicitType == null && target != null) {
                explicitType = treeDecorator.getProperty(target, GoAnnotations.EXPLICIT_TYPE);
            }

            if (explicitType != null) {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve explicit type for qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                resolvedQualifier = Collections.emptyList();
            } else {
                ParserRuleContext implicitType = target != null
                        ? treeDecorator.getProperty(target, GoAnnotations.IMPLICIT_TYPE)
                        : null;
                int implicitIndex = target != null
                        ? treeDecorator.getProperty(target, GoAnnotations.IMPLICIT_INDEX)
                        : -1;
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve implicit type for qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                resolvedQualifier = Collections.emptyList();
            }
        } else {
            if (LOGGER.isLoggable(Level.WARNING)) {
                LOGGER.log(Level.WARNING, "Unable to resolve qualifier: {0}",
                        qualifier.toString(Arrays.asList(GoParser.ruleNames)));
            }

            resolvedQualifier = Collections.emptyList();
        }
    }

    assert resolvedQualifier != null;
    if (resolvedQualifier == null) {
        LOGGER.log(Level.WARNING, "Should not have a null resolved qualifier at this point.");
        resolvedQualifier = Collections.emptyList();
    }

    String nameText = token.getText();
    List<CodeElementModel> qualifiedModels = new ArrayList<>();
    for (CodeElementModel model : resolvedQualifier) {
        qualifiedModels.addAll(SemanticAnalyzer.getSelectableMembers(model, nameText));
    }

    if (qualifiedModels.isEmpty()) {
        treeDecorator.putProperty(node, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
        return true;
    }

    setNodeType(node, qualifiedModels.get(0));
    treeDecorator.putProperty(node, GoAnnotations.RESOLVED, true);
    treeDecorator.putProperty(node, GoAnnotations.MODELS, qualifiedModels);
    return true;
}

From source file:org.tvl.goworks.editor.go.semantics.SemanticAnalyzerListener.java

License:Open Source License

@Override
@RuleDependency(recognizer = GoParser.class, rule = GoParser.RULE_identifierList, version = 0)
public void enterIdentifierList(IdentifierListContext ctx) {
    NodeType nodeType = treeDecorator.getProperty(ctx, GoAnnotations.NODE_TYPE);
    VarKind varType = treeDecorator.getProperty(ctx, GoAnnotations.VAR_TYPE);
    boolean variadic = treeDecorator.getProperty(ctx, GoAnnotations.VARIADIC);
    ParserRuleContext explicitType = treeDecorator.getProperty(ctx, GoAnnotations.EXPLICIT_TYPE);
    boolean global = (varType != VarKind.LOCAL && varType != VarKind.RECEIVER && varType != VarKind.PARAMETER
            && varType != VarKind.RETURN) || treeDecorator.getProperty(ctx, GoAnnotations.GLOBAL);

    if (nodeType == NodeType.VAR_DECL) {
        if (varType == VarKind.UNDEFINED) {
            return;
        }//from  www .  j  ava 2 s .c o  m
    } else if (nodeType == NodeType.CONST_DECL) {
        // nothing special to do here
    } else {
        return;
    }

    for (TerminalNode terminalNode : ctx.IDENTIFIER()) {
        Token token = terminalNode.getSymbol();
        if (nodeType == NodeType.VAR_DECL) {
            if (varType != VarKind.FIELD) {
                pendingVisibleLocals.peek().put(token.getText(), terminalNode);
            }
        } else {
            assert nodeType == NodeType.CONST_DECL;
            pendingVisibleConstants.peek().put(token.getText(), terminalNode);
        }

        treeDecorator.putProperty(terminalNode, GoAnnotations.NODE_TYPE, nodeType);

        if (varType != null) {
            treeDecorator.putProperty(terminalNode, GoAnnotations.VAR_TYPE, varType);
        }

        if (variadic) {
            treeDecorator.putProperty(terminalNode, GoAnnotations.VARIADIC, variadic);
        }

        if (explicitType != null) {
            treeDecorator.putProperty(terminalNode, GoAnnotations.EXPLICIT_TYPE, explicitType);
        }

        if (global) {
            treeDecorator.putProperty(terminalNode, GoAnnotations.GLOBAL, global);
        }
    }
}

From source file:org.tvl.goworks.editor.go.semantics.SemanticAnalyzerListener.java

License:Open Source License

@Override
@RuleDependencies({ @RuleDependency(recognizer = GoParser.class, rule = GoParser.RULE_rangeClause, version = 0),
        @RuleDependency(recognizer = GoParser.class, rule = GoParser.RULE_expression, version = 1), })
public void enterRangeClause(RangeClauseContext ctx) {
    if (ctx.defeq != null) {
        if (ctx.e1 != null && ctx.e1.start == ParseTrees.getStopSymbol(ctx.e1)) {
            Token token = ctx.e1.start;
            TerminalNode startNode = ParseTrees.getStartNode(ctx.e1);
            pendingVisibleLocals.peek().put(token.getText(), startNode);
            treeDecorator.putProperty(startNode, GoAnnotations.NODE_TYPE, NodeType.VAR_DECL);
            treeDecorator.putProperty(startNode, GoAnnotations.VAR_TYPE, VarKind.LOCAL);
            treeDecorator.putProperty(startNode, GoAnnotations.IMPLICIT_TYPE, ctx);
            treeDecorator.putProperty(startNode, GoAnnotations.IMPLICIT_INDEX, 0);
        }//  w  ww  . j  av  a  2s .com

        if (ctx.e2 != null && ctx.e2.start == ParseTrees.getStopSymbol(ctx.e2)) {
            Token token = ctx.e2.start;
            TerminalNode startNode = ParseTrees.getStartNode(ctx.e2);
            pendingVisibleLocals.peek().put(token.getText(), startNode);
            treeDecorator.putProperty(startNode, GoAnnotations.NODE_TYPE, NodeType.VAR_DECL);
            treeDecorator.putProperty(startNode, GoAnnotations.VAR_TYPE, VarKind.LOCAL);
            treeDecorator.putProperty(startNode, GoAnnotations.IMPLICIT_TYPE, ctx);
            treeDecorator.putProperty(startNode, GoAnnotations.IMPLICIT_INDEX, 1);
        }
    }
}

From source file:org.wso2.ballerinalang.compiler.parser.BLangWSPreservingParserListener.java

License:Open Source License

private void addWSFromRange(Stack<Whitespace> ws, TokenRange range) {
    int rangeStart = range.from;
    int rangeEnd = range.to;
    boolean lastTokenWasHidden = true;

    Token previousNonWS = null;//from  w  w w . j  a va2s  .  c  o m
    for (int j = rangeEnd - 1; j >= -1; j--) {
        if (j == -1) {
            if (!lastTokenWasHidden) {
                // capturing (non-exiting) WS at the start of range, if the range starts at 0.
                // this happens if the file starts with a non-ws token.
                pushWS(ws, previousNonWS, "");
            }
            break;
        }

        Token token = this.tokenStream.get(j);
        if (previousNonWS == null && token.getChannel() == Token.HIDDEN_CHANNEL) {
            continue;
        }
        if (token.getChannel() == Token.DEFAULT_CHANNEL) {
            // we need to capture WS before the start of a range,
            // therefor only break after previous range's first non-WS.
            if (j < rangeStart) {
                if (!lastTokenWasHidden) {
                    pushWS(ws, previousNonWS, "");
                    // capturing (non-exiting) WS at the start of range (when there is no space between ranges).
                }
                break;
            }
            // capturing (non-exiting) WS between two default tokens.
            if (!lastTokenWasHidden) {
                pushWS(ws, previousNonWS, "");
            }
            lastTokenWasHidden = false;
            previousNonWS = token;
        } else {
            if (lastTokenWasHidden) {
                // merging adjacent WS tokens.
                ws.peek().prependWS(token.getText());
            } else {
                // capturing (non-zero-len) WS.
                pushWS(ws, previousNonWS, token.getText());
            }
            lastTokenWasHidden = true;
        }
    }
}

From source file:org.wso2.ballerinalang.compiler.parser.BLangWSPreservingParserListener.java

License:Open Source License

private void pushWS(Stack<Whitespace> whitespaceStack, Token previousNonWS, String wsString) {
    boolean isStatic = isAllUpper(BallerinaLexer.VOCABULARY.getSymbolicName(previousNonWS.getType()));
    Whitespace wsToken = new Whitespace(previousNonWS.getTokenIndex(), wsString, previousNonWS.getText(),
            isStatic);/*from  w  ww. j a  va 2 s .  c o m*/
    whitespaceStack.push(wsToken);
}

From source file:plugins.quorum.Libraries.Language.Compile.JavaToQuorumListener.java

@Override
public void exitFullClassDeclaration(@NotNull QuorumParser.FullClassDeclarationContext ctx) {
    FullClassDeclarationContext context = new FullClassDeclarationContext();
    context.className = ctx.ID().getText();
    setLocation(ctx, context);//from   w  w w . j a v  a  2s  .co  m

    QualifiedName name = new QualifiedName();
    QuorumParser.Generic_declarationContext generic = ctx.generic_declaration();

    context.name = name;
    name.Add(ctx.ID().getText());

    if (generic != null) {
        List<Token> tokenList = generic.ids;
        Iterator<Token> tokens = tokenList.iterator();
        while (tokens.hasNext()) {
            Token token = tokens.next();
            String value = token.getText();
            context.name.AddGeneric(value);
        }
    }
    listener.ExitFullClassDeclaration(context);
}

From source file:plugins.quorum.Libraries.Language.Compile.JavaToQuorumListener.java

@Override
public void exitInherit_stmt(QuorumParser.Inherit_stmtContext ctx) {
    quorum.Libraries.Language.Compile.Context.InheritStatementContext context = new quorum.Libraries.Language.Compile.Context.InheritStatementContext();
    QuorumParser.Qualified_nameContext name = ctx.qualified_name();
    QuorumParser.Generic_declarationContext generic = ctx.generic_declaration();

    context.name = Convert(name);/*from www  . ja  v a 2 s .  c o m*/

    if (generic != null) {
        List<Token> tokenList = generic.ids;
        Iterator<Token> tokens = tokenList.iterator();
        while (tokens.hasNext()) {
            Token token = tokens.next();
            String value = token.getText();
            context.name.AddGeneric(value);
        }
    }

    setLocation(ctx, context);
    listener.ExitInheritStatement(context);
}

From source file:plugins.quorum.Libraries.Language.Compile.JavaToQuorumListener.java

public QualifiedName Convert(QuorumParser.Qualified_nameContext next) {
    QualifiedName name = new QualifiedName();
    List<Token> ids = next.ids;
    Iterator<Token> tokens = ids.iterator();
    while (tokens.hasNext()) {
        Token token = tokens.next();
        String value = token.getText();
        name.Add(value);//from   w ww .  ja  v  a2 s.co m
    }
    return name;
}