public static int getStartIndex(ParserRuleContext ctx) { return ctx.getStop().getStartIndex(); } }
public static int getStartIndex(ParserRuleContext ctx) { return ctx.getStop().getStartIndex(); } }
/** * Returns the last token of the construct represented by node. * * @param node A node * @return Stop token */ public static Token getStopTokenForNode(ParseTree node) { if (node instanceof TerminalNodeImpl) { return ((TerminalNodeImpl) node).getSymbol(); } else { return ((ParserRuleContext) node).getStop(); } } }
@Override public Optional<IndexSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> indexNameNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.INDEX_NAME); return indexNameNode.isPresent() ? Optional.of(new IndexSegment(new IndexToken(indexNameNode.get().getStop().getStartIndex(), indexNameNode.get().getStop().getStopIndex()))) : Optional.<IndexSegment>absent(); } }
@Override public Optional<GroupBySegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> groupByNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.GROUP_BY_CLAUSE); if (!groupByNode.isPresent()) { return Optional.absent(); } GroupBySegment result = new GroupBySegment(groupByNode.get().getStop().getStopIndex()); result.getGroupByItems().addAll(orderByItemExtractor.extract(groupByNode.get())); return Optional.of(result); } }
private ExpressionSegment extractPropertyExpressionSegment(final ParserRuleContext expressionNode) { ParserRuleContext columnNode = (ParserRuleContext) expressionNode.getChild(0); Optional<ColumnSegment> columnSegment = new ColumnSegmentExtractor().extract(columnNode); Preconditions.checkState(columnSegment.isPresent()); return new PropertyExpressionSegment(columnSegment.get().getName(), columnSegment.get().getOwner().orNull(), columnNode.getStart().getStartIndex(), columnNode.getStop().getStopIndex()); }
@Override public Optional<ExpressionSelectItemSegment> extract(final ParserRuleContext expressionNode) { // TODO parse table inside expression ExpressionSelectItemSegment result = new ExpressionSelectItemSegment(expressionNode.getText(), expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex()); Optional<ParserRuleContext> aliasNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.ALIAS); if (aliasNode.isPresent()) { result.setAlias(aliasNode.get().getText()); } return Optional.of(result); } }
/** * Extract SQL segment from SQL AST. * * @param ancestorNode ancestor node of AST * @param rootNode root node of AST * @return SQL segment */ public Optional<FromWhereSegment> extract(final ParserRuleContext ancestorNode, final ParserRuleContext rootNode) { FromWhereSegment result = createSegment(); Map<ParserRuleContext, Integer> placeholderIndexes = getPlaceholderIndexes(result, rootNode); Optional<ParserRuleContext> whereNode = extractTable(result, ancestorNode, placeholderIndexes); if (whereNode.isPresent()) { result.setWhereStartIndex(whereNode.get().getStart().getStartIndex()); result.setWhereStopIndex(whereNode.get().getStop().getStopIndex()); if (!placeholderIndexes.isEmpty()) { Collection<ParserRuleContext> questionNodes = ExtractorUtils.getAllDescendantNodes(whereNode.get(), RuleName.QUESTION); if (!questionNodes.isEmpty()) { int index = placeholderIndexes.get(questionNodes.iterator().next()); result.setWhereParameterStartIndex(index); result.setWhereParameterEndIndex(index + questionNodes.size() - 1); } } extractAndFillWhere(result, placeholderIndexes, whereNode.get()); } return Optional.of(result); }
private void extractSetColumn(final Map<ParserRuleContext, Integer> placeholderIndexes, final ParserRuleContext ancestorNode, final InsertSegment insertSegment) { Optional<ParserRuleContext> setClauseNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.SET_CLAUSE); if (!setClauseNode.isPresent()) { return; } Optional<ParserRuleContext> assignmentListNode = ExtractorUtils.findFirstChildNode(setClauseNode.get(), RuleName.ASSIGNMENT_LIST); if (!assignmentListNode.isPresent()) { return; } insertSegment.setInsertValueStartIndex(assignmentListNode.get().getStart().getStartIndex()); Collection<ParserRuleContext> questionNodes = ExtractorUtils.getAllDescendantNodes(assignmentListNode.get(), RuleName.QUESTION); InsertValuesSegment insertValuesSegment = new InsertValuesSegment(DefaultKeyword.SET, assignmentListNode.get().getStart().getStartIndex(), assignmentListNode.get().getStop().getStopIndex(), questionNodes.size()); insertSegment.getValuesList().add(insertValuesSegment); Collection<ParserRuleContext> assignments = ExtractorUtils.getAllDescendantNodes(assignmentListNode.get(), RuleName.ASSIGNMENT); insertSegment.setInsertValuesListLastIndex(assignmentListNode.get().getStop().getStopIndex()); for (ParserRuleContext each : assignments) { ParserRuleContext columnNode = (ParserRuleContext) each.getChild(0); insertSegment.getColumns().add(columnSegmentExtractor.extract(columnNode).get()); insertValuesSegment.getValues().add(expressionExtractor.extractCommonExpressionSegment(placeholderIndexes, (ParserRuleContext) each.getChild(2))); } }
@Override public Optional<InsertSegment> extract(final ParserRuleContext ancestorNode) { InsertSegment result = new InsertSegment(); Map<ParserRuleContext, Integer> placeholderIndexes = getPlaceholderIndexes(ancestorNode); extractValuesColumn(placeholderIndexes, ancestorNode, result); if (result.getValuesList().isEmpty()) { extractSetColumn(placeholderIndexes, ancestorNode, result); } extractDuplicateKeys(ancestorNode, result); result.setInsertValuesListLastIndex(ancestorNode.getStop().getStopIndex()); return Optional.of(result); }
private SelectItemSegment extractFunctionSelectItemSegment(final ParserRuleContext expressionNode, final ParserRuleContext functionNode) { String functionName = functionNode.getChild(0).getText(); Optional<AggregationType> aggregationType = findAggregationType(functionName); AliasAvailable result = aggregationType.isPresent() ? extractAggregationSelectItemSegment(aggregationType.get(), functionNode) : new ExpressionSelectItemSegment(functionNode.getText(), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex()); Optional<ParserRuleContext> aliasNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.ALIAS); if (aliasNode.isPresent()) { result.setAlias(aliasNode.get().getText()); } return (SelectItemSegment) result; }
private AggregationSelectItemSegment extractAggregationSelectItemSegment(final AggregationType type, final ParserRuleContext functionNode) { return ExtractorUtils.findFirstChildNode(functionNode, RuleName.DISTINCT).isPresent() ? new AggregationDistinctSelectItemSegment( type, getInnerExpression(functionNode), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex(), getDistinctExpression(functionNode)) : new AggregationSelectItemSegment(type, getInnerExpression(functionNode), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex()); }
/** * Extract common expression segment. * * @param placeholderIndexes place holder index * @param expressionNode expression node * @return common expression segment */ public CommonExpressionSegment extractCommonExpressionSegment(final Map<ParserRuleContext, Integer> placeholderIndexes, final ParserRuleContext expressionNode) { CommonExpressionSegment result = new CommonExpressionSegment(expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex()); Optional<ParserRuleContext> questionNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.QUESTION); if (questionNode.isPresent()) { Integer index = placeholderIndexes.get(questionNode.get()); result.setPlaceholderIndex(index); } else { Optional<ParserRuleContext> bitExprNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.BIT_EXPR); Optional<ParserRuleContext> numberNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.NUMBER); if (numberNode.isPresent() && (!bitExprNode.isPresent() || 1 == bitExprNode.get().getChildCount())) { result.setValue(NumberUtil.getExactlyNumber(numberNode.get().getText(), 10)); } Optional<ParserRuleContext> stringNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.STRING); if (stringNode.isPresent() && (!bitExprNode.isPresent() || 1 == bitExprNode.get().getChildCount())) { result.setText(true); } } return result; } }
@Override public Optional<SelectClauseSegment> extract(final ParserRuleContext ancestorNode) { ParserRuleContext selectClauseNode = ExtractorUtils.getFirstChildNode(ancestorNode, RuleName.SELECT_CLAUSE); ParserRuleContext selectExpressionsNode = ExtractorUtils.getFirstChildNode(selectClauseNode, RuleName.SELECT_EXPRS); SelectClauseSegment result = new SelectClauseSegment(selectExpressionsNode.getStart().getStartIndex(), selectExpressionsNode.getStop().getStopIndex(), hasDistinct(selectClauseNode)); for (int i = 0; i < selectExpressionsNode.getChildCount(); i++) { ParseTree selectExpressionNode = selectExpressionsNode.getChild(i); if (selectExpressionNode instanceof TerminalNodeImpl) { continue; } Optional<? extends SelectItemSegment> selectItemSegment = selectItemExtractor.extract((ParserRuleContext) selectExpressionNode); if (selectItemSegment.isPresent()) { result.getSelectItems().add(selectItemSegment.get()); } } return Optional.of(result); }
private void verifyBodyOpenBraceStyle(ParserRuleContext ctx, String constructName) { ParserRuleContext leftSibling = (ParserRuleContext) ParseTreeUtil.getLeftSibling(ctx); Location constructLocation = ListenerUtil.getContextStopLocation(leftSibling); verifyCodeBlockOpenBraceIsInline(ctx, constructLocation, constructName); verifySingleSpaceBeforeOpenBrace(ctx, leftSibling.getStop()); }
@Before public void setUp() throws NoSuchMethodException, IOException { Method method = this.getClass().getMethod(testName.getMethodName()); inputFile = folder.newFile(method.getName() + "-" + INPUT_FILE); writer = new PrintWriter(inputFile, Charset.defaultCharset().name()); when(context.getStart()).thenReturn(startToken); when(context.getStop()).thenReturn(stopToken); }
protected void verifyConstructLength(Rules rule, String constructType, int length, ParserRuleContext ctx) { if (SourceFileUtil.constructTooLong(ctx, length)) { int constructLength = ctx.getStop().getLine() - ctx.getStart().getLine(); createErrorMessage(rule, constructLength, ctx, constructType, length, Messages.EXCEEDS_LINE_LIMIT); } }
@Override public void enterTypeInheritanceClause(SwiftParser.TypeInheritanceClauseContext ctx) { Token colon = ((TerminalNodeImpl) ctx.getChild(0)).getSymbol(); Token right = ((ParserRuleContext) ctx.getChild(1)).getStart(); Token left = ((ParserRuleContext) ParseTreeUtil.getLeftSibling(ctx)).getStop(); verifyColonLeftAssociation(left, right, colon); }
private ExpressionSegment extractFunctionExpressionSegment(final ParserRuleContext functionNode) { return new FunctionExpressionSegment(functionNode.getChild(0).getText(), functionNode.getStart().getStartIndex(), ((TerminalNode) functionNode.getChild(1)).getSymbol().getStartIndex(), functionNode.getStop().getStopIndex(), -1); }
private void addIgnoredChars(ParserRuleContext ctx, NodeBuilder nodeBuilder) { Token start = ctx.getStart(); int tokenStartIndex = start.getTokenIndex(); List<Token> leftChannel = tokens.getHiddenTokensToLeft(tokenStartIndex, CHANNEL_IGNORED_CHARS); List<IgnoredChar> ignoredCharsLeft = mapTokenToIgnoredChar(leftChannel); Token stop = ctx.getStop(); int tokenStopIndex = stop.getTokenIndex(); List<Token> rightChannel = tokens.getHiddenTokensToRight(tokenStopIndex, CHANNEL_IGNORED_CHARS); List<IgnoredChar> ignoredCharsRight = mapTokenToIgnoredChar(rightChannel); nodeBuilder.ignoredChars(new IgnoredChars(ignoredCharsLeft, ignoredCharsRight)); }