Java Code Examples for org.antlr.v4.runtime.tree.TerminalNode#getText()

final @NonNull String stringFromStringContext(final ArgumentContext context, final StatementSourceReference ref) {
    // Get first child, which we fully expect to exist and be a lexer token
    final ParseTree firstChild = context.getChild(0);
    verify(firstChild instanceof TerminalNode, "Unexpected shape of %s", context);
    final TerminalNode firstNode = (TerminalNode) firstChild;
    final int firstType = firstNode.getSymbol().getType();
    switch (firstType) {
        case YangStatementParser.IDENTIFIER:
            // Simple case, there is a simple string, which cannot contain anything that we would need to process.
            return firstNode.getText();
        case YangStatementParser.STRING:
            // Complex case, defer to a separate method
            return concatStrings(context, ref);
        default:
            throw new VerifyException("Unexpected first symbol in " + context);
    }
}
 

private SpecialType specialType(TerminalNode rou, SpecialType defaultType) {
    if (rou == null) {
        return defaultType;
    }
    String rouType = rou.getText();
    if ("#".equals(rouType)) {
        return SpecialType.Special_A;
    }
    if ("$".equals(rouType)) {
        return SpecialType.Special_B;
    }
    if ("@".equals(rouType)) {
        return SpecialType.Special_C;
    }
    throw newParseException(rou.getSymbol(), "rouType '" + rouType + "' is not supported");
}
 

@Override
public BaseExpression visitSimpleJoin(SimpleJoinContext ctx) {
	List<BaseExpression> expressions=new ArrayList<BaseExpression>();
	List<Operator> operators=new ArrayList<Operator>();
	List<UnitContext> unitContexts=ctx.unit();
	List<TerminalNode> operatorNodes=ctx.Operator();
	for(int i=0;i<unitContexts.size();i++){
		UnitContext unitContext=unitContexts.get(i);
		BaseExpression expr=buildExpression(unitContext);
		expressions.add(expr);
		if(i>0){
			TerminalNode operatorNode=operatorNodes.get(i-1);
			String op=operatorNode.getText();
			operators.add(Operator.parse(op));
		}
	}
	if(operators.size()==0 && expressions.size()==1){
		return expressions.get(0);
	}
	JoinExpression expression=new JoinExpression(operators,expressions);
	expression.setExpr(ctx.getText());
	return expression;
}
 

private SingleExpression parseLiteral(LiteralContext literalContext) {
  if (literalContext.StringLiteral()!=null) {
    return parseStringLiteral(literalContext);
  }

  TerminalNode nullLiteral = literalContext.NullLiteral();
  if (nullLiteral!=null) {
    return new Literal(createNextScriptElementId(), createLocation(literalContext));
  }

  NumericLiteralContext numericLiteralContext = literalContext.numericLiteral();
  if (numericLiteralContext!=null) {
    if (numericLiteralContext.DecimalLiteral()!=null) {
      return parseDecimalNumberLiteral(numericLiteralContext);
    }
    addErrorUnsupportedElement(numericLiteralContext, "number");
    return null;
  }

  TerminalNode regularExpressionLiteral = literalContext.RegularExpressionLiteral();
  if (regularExpressionLiteral!=null) {
    String regexText = regularExpressionLiteral.getText();
    addErrorUnsupportedElement(regularExpressionLiteral, "regex");
    return null;
  }

  TerminalNode booleanLiteral = literalContext.BooleanLiteral();
  if (booleanLiteral != null) {
    if ("true".equals(booleanLiteral.getText())) {
      return parseBooleanLiteral(literalContext, true);
    } else if ("false".equals(booleanLiteral.getText())) {
      return parseBooleanLiteral(literalContext, false);
    }
  }
  return null;
}
 

private String unquote(TerminalNode node) {
    if (node == null) return null;

    String text = node.getText();
    int tokenType = node.getSymbol().getType();
    if (cqlLexer.STRING == tokenType || cqlLexer.VALUESET == tokenType) {
        // chop off leading and trailing ' or "
        text = text.substring(1, text.length() - 1);
    }

    return text;
}
 

@Override
public void visitTerminal(TerminalNode node) {
  if (_enablePathRecording) {
    String text = node.getText();
    int line = node.getSymbol().getLine();
    if (node.getSymbol().getType() == FlatJuniperLexer.WILDCARD) {
      _currentPath.addWildcardNode(text, line);
    } else {
      _currentPath.addNode(text, line);
    }
  }
}
 

public void enterClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx) {
    if (ctx.getChildCount() == 2) {
        ParseTree first = ctx.getChild(0);

        if (first instanceof TerminalNode) {
            TerminalNode f = (TerminalNode)first;

            if (f.getSymbol().getType() == JavaParser.STATIC) {
                String name = f.getText();
                int position = f.getSymbol().getStartIndex();
                declarations.put(currentInternalTypeName + "-<clinit>-()V", new TypePage.DeclarationData(position, 6, currentInternalTypeName, name, "()V"));
            }
        }
    }
}
 

@Override
public Void visitChildrenNode(JsonPathParser.ChildrenNodeContext ctx) {
    int i = 0;
    String[] strings = new String[ctx.QUOTED_STRING().size()];
    for (TerminalNode node : ctx.QUOTED_STRING()) {
        String quotedString = node.getText();
        strings[i++] = removeQuote(quotedString);
    }
    currentPathBuilder().children(strings);
    return super.visitChildren(ctx);
}
 

public void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx) {
    TerminalNode identifier = ctx.Identifier();

    if (identifier != null) {
        String name = identifier.getText();
        methodDeclarationSet.add(name);
    }
}
 

private boolean getBoolean(TerminalNode bool) {
    Graql.Token.Literal literal = Graql.Token.Literal.of(bool.getText());

    if (literal != null && literal.equals(Graql.Token.Literal.TRUE)) {
        return true;

    } else if (literal != null && literal.equals(Graql.Token.Literal.FALSE)) {
        return false;

    } else {
        throw new IllegalArgumentException("Unrecognised Boolean token: " + bool.getText());
    }
}
 

private String parsePropertyName(PropertyNameContext propertyNameContext) {
  IdentifierNameContext identifierNameContext = propertyNameContext.identifierName();
  if (identifierNameContext!=null) {
    return identifierNameContext.getText();
  }
  TerminalNode stringLiteralNode = propertyNameContext.StringLiteral();
  if (stringLiteralNode!=null) {
    String propertyNameWithQuotes = stringLiteralNode.getText();
    String propertyNameWithoutQuotes = removeQuotesFromString(stringLiteralNode, propertyNameWithQuotes);
    return propertyNameWithoutQuotes;
  }
  addErrorUnsupportedElement(propertyNameContext, "propertyName");
  return null;
}
 

@Override
public void visitTerminal(TerminalNode node) {
  if (_enablePathRecording) {
    String text = node.getText();
    int line = node.getSymbol().getLine();
    if (node.getSymbol().getType() == FlatJuniperLexer.WILDCARD_ARTIFACT) {
      _currentPath.addWildcardNode(text, line);
    } else {
      _currentPath.addNode(text, line);
    }
  }
}
 

public void enterInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx) {
    TerminalNode identifier = ctx.Identifier();

    if (identifier != null) {
        String name = identifier.getText();
        methodDeclarationSet.add(name);
    }
}
 

private YangExpr parseTerminal(final TerminalNode term) {
    final String text = term.getText();
    switch (term.getSymbol().getType()) {
        case xpathParser.Literal:
            // We have to strip quotes
            haveLiteral = true;
            return YangLiteralExpr.of(text.substring(1, text.length() - 1));
        case xpathParser.Number:
            return mathSupport.createNumber(text);
        default:
            throw illegalShape(term);
    }
}
 

/**
 *
 * @param terminalNode terminal node
 * @return stirng
 */
@Override
public final String apply(final TerminalNode terminalNode) {

    String text = terminalNode.getText();

    boolean trim = Stream.of("\"", "'")
            .anyMatch(c -> text.startsWith(c) && text.endsWith(c));
    if (trim) {
        return text.substring(1, text.length() - 1);
    }

    return text;
}
 

@Override
public Object visitTerminal(@NotNull TerminalNode node) {
    String text = node.getText();
    int tokenType = node.getSymbol().getType();
    if (cqlLexer.STRING == tokenType || cqlLexer.QUOTEDIDENTIFIER == tokenType) {
        // chop off leading and trailing ' or "
        text = text.substring(1, text.length() - 1);
    }

    return text;
}
 

public ValueNode(TerminalNode context) {
    super(context.getSymbol(), context.getSymbol());

    this.value = context.getText();
}
 

@Override
public String visitTerminal(TerminalNode node) {
    return node.getText();
}
 

private String getInfixText(TerminalNode node) {
  String name = node.getText();
  return name.substring(1, name.length() - 1);
}
 

private CypherString visitOC_EscapedSymbolicName(TerminalNode escapedSymbolicName) {
    String text = escapedSymbolicName.getText();
    text = text.substring(1, text.length() - 1);
    return new CypherString(text);
}