/** * Adds the sub-ASTs corresponding to the children of a given Antlr tree to an AST, and sets the * AST property of the tree. */ private void computeDepth(ParseTree tree) { int depth = 1; for (int i = 0; i < tree.getChildCount(); i++) { depth = Math.max(depth, getDepth(tree.getChild(i)) + 1); } setDepth(tree, depth); }
public void setTree(ParseTree tree) { this.tree = tree; if (tree.getChildCount() > 3) { chooseAll = false; } else { chooseAll = true; } }
/** * Creates JavadocNodeImpl node on base of ParseTree node. * * @param parseTree ParseTree node * @param parent DetailNode that will be parent of new node * @param index child index that has new node * @return JavadocNodeImpl node on base of ParseTree node. */ private JavadocNodeImpl createJavadocNode(ParseTree parseTree, DetailNode parent, int index) { final JavadocNodeImpl node = new JavadocNodeImpl(); node.setText(parseTree.getText()); node.setColumnNumber(getColumn(parseTree)); node.setLineNumber(getLine(parseTree) + blockCommentLineNumber); node.setIndex(index); node.setType(getTokenType(parseTree)); node.setParent(parent); node.setChildren((DetailNode[]) new JavadocNodeImpl[parseTree.getChildCount()]); return node; }
/** * Creates children Javadoc nodes base on ParseTree node's children. * * @param parentJavadocNode node that will be parent for created children * @param parseTreeNode original ParseTree node * @return array of Javadoc nodes */ private JavadocNodeImpl[] createChildrenNodes( JavadocNodeImpl parentJavadocNode, ParseTree parseTreeNode) { final JavadocNodeImpl[] children = new JavadocNodeImpl[parseTreeNode.getChildCount()]; for (int j = 0; j < children.length; j++) { final JavadocNodeImpl child = createJavadocNode(parseTreeNode.getChild(j), parentJavadocNode, j); children[j] = child; } return children; }
/** * Gets token type of ParseTree node from JavadocTokenTypes class. * * @param node ParseTree node. * @return token type from JavadocTokenTypes */ private static int getTokenType(ParseTree node) { final int tokenType; if (node.getChildCount() == 0) { tokenType = ((TerminalNode) node).getSymbol().getType(); } else { final String className = getNodeClassNameWithoutContext(node); final String typeName = CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, className); tokenType = JavadocUtils.getTokenId(typeName); } return tokenType; }
/** * Creates root JavadocNodeImpl node base on ParseTree root node. * * @param parseTreeNode ParseTree root node * @return root Javadoc node */ private JavadocNodeImpl createRootJavadocNode(ParseTree parseTreeNode) { final JavadocNodeImpl rootJavadocNode = createJavadocNode(parseTreeNode, null, -1); final int childCount = parseTreeNode.getChildCount(); final JavadocNodeImpl[] children = new JavadocNodeImpl[childCount]; for (int i = 0; i < childCount; i++) { final JavadocNodeImpl child = createJavadocNode(parseTreeNode.getChild(i), rootJavadocNode, i); children[i] = child; } rootJavadocNode.setChildren((DetailNode[]) children); return rootJavadocNode; }
@CheckForNull public static TerminalNode findTerminalNode(@NonNull ParseTree node, Token symbol) { if (symbol == null) { return null; } if (node instanceof TerminalNode) { TerminalNode terminalNode = (TerminalNode) node; if (Utils.equals(terminalNode.getSymbol(), symbol)) { return terminalNode; } return null; } for (int i = 0; i < node.getChildCount(); i++) { ParseTree child = node.getChild(i); TerminalNode stopNode = ParseTrees.getStopNode(child); if (stopNode == null) { continue; } Token stopSymbol = stopNode.getSymbol(); if (stopSymbol.getStopIndex() < symbol.getStartIndex()) { continue; } TerminalNode startNode = ParseTrees.getStartNode(child); assert startNode != null; stopSymbol = startNode.getSymbol(); if (stopSymbol == null || stopSymbol.getStartIndex() > symbol.getStopIndex()) { break; } if (stopSymbol.equals(symbol)) { return startNode; } TerminalNode terminalNode = findTerminalNode(child, symbol); if (terminalNode != null) { return terminalNode; } } return null; }
public static TerminalNode getStopNode(ParseTree context) { if (context == null) { return null; } if (context instanceof TerminalNode) { return (TerminalNode) context; } for (int i = context.getChildCount() - 1; i >= 0; i--) { TerminalNode stopNode = getStopNode(context.getChild(i)); if (stopNode != null) { return stopNode; } } return null; }
/** * Gets next sibling of ParseTree node. * * @param node ParseTree node * @return next sibling of ParseTree node. */ private static ParseTree getNextSibling(ParseTree node) { ParseTree nextSibling = null; if (node.getParent() != null) { final ParseTree parent = node.getParent(); final int childCount = parent.getChildCount(); int index = 0; while (true) { final ParseTree currentNode = parent.getChild(index); if (currentNode.equals(node)) { if (index != childCount - 1) { nextSibling = parent.getChild(index + 1); } break; } index++; } } return nextSibling; }
/** * Return a list of all nodes starting at {@code t} as root that satisfy the path. The root {@code * /} is relative to the node passed to {@link #evaluate}. */ public Collection<ParseTree> evaluate(final ParseTree t) { ParserRuleContext dummyRoot = new ParserRuleContext(); dummyRoot.children = Collections.singletonList(t); // don't set t's parent. Collection<ParseTree> work = Collections.<ParseTree>singleton(dummyRoot); int i = 0; while (i < elements.length) { Collection<ParseTree> next = new LinkedHashSet<ParseTree>(); for (ParseTree node : work) { if (node.getChildCount() > 0) { // only try to match next element if it has children // e.g., //func/*/stat might have a token node for which // we can't go looking for stat nodes. Collection<? extends ParseTree> matching = elements[i].evaluate(node); next.addAll(matching); } } i++; work = next; } return work; }
/** Resolve include statements */ private static boolean resolveIncludes( ParseTree tree, boolean debug, Set<String> alreadyIncluded) { boolean changed = false; if (tree instanceof IncludeFileContext) { // Parent file: The one that is including the other file File parentFile = new File(((IncludeFileContext) tree).getStart().getInputStream().getSourceName()); // Included file name String includedFilename = StatementInclude.includeFileName(tree.getChild(1).getText()); // Find file (look into all include paths) File includedFile = StatementInclude.includeFile(includedFilename, parentFile); if (includedFile == null) { CompilerMessages.get() .add( tree, parentFile, "\n\tIncluded file not found: '" + includedFilename + "'\n\tSearch path: " + Config.get().getIncludePath(), MessageType.ERROR); return false; } // Already included? don't bother String canonicalFileName = Gpr.getCanonicalFileName(includedFile); if (alreadyIncluded.contains(canonicalFileName)) { if (debug) Gpr.debug( "File already included: '" + includedFilename + "'\tCanonical path: '" + canonicalFileName + "'"); return false; } if (!includedFile.canRead()) { CompilerMessages.get() .add( tree, parentFile, "\n\tCannot read included file: '" + includedFilename + "'", MessageType.ERROR); return false; } // Parse ParseTree treeinc = createAst(includedFile, debug, alreadyIncluded); if (treeinc == null) { CompilerMessages.get() .add( tree, parentFile, "\n\tFatal error including file '" + includedFilename + "'", MessageType.ERROR); return false; } // Is a child always a RuleContext? for (int i = 0; i < treeinc.getChildCount(); i++) { ((IncludeFileContext) tree).addChild((RuleContext) treeinc.getChild(i)); } } else { for (int i = 0; i < tree.getChildCount(); i++) changed |= resolveIncludes(tree.getChild(i), debug, alreadyIncluded); } return changed; }
/** * Create an AST from a program (using ANTLR lexer & parser) Returns null if error Use * 'alreadyIncluded' to keep track of from 'include' statements */ public static ParseTree createAst(File file, boolean debug, Set<String> alreadyIncluded) { alreadyIncluded.add(Gpr.getCanonicalFileName(file)); String fileName = file.toString(); String filePath = fileName; BigDataScriptLexer lexer = null; BigDataScriptParser parser = null; try { filePath = file.getCanonicalPath(); // Input stream if (!Gpr.canRead(filePath)) { CompilerMessages.get().addError("Can't read file '" + filePath + "'"); return null; } // Create a CharStream that reads from standard input ANTLRFileStream input = new ANTLRFileStream(fileName); // --- // Lexer: Create a lexer that feeds off of input CharStream // --- lexer = new BigDataScriptLexer(input) { @Override public void recover(LexerNoViableAltException e) { throw new RuntimeException(e); // Bail out } }; // --- // Parser // --- CommonTokenStream tokens = new CommonTokenStream(lexer); parser = new BigDataScriptParser(tokens); // Parser error handling parser.setErrorHandler( new CompileErrorStrategy()); // Bail out with exception if errors in parser parser.addErrorListener(new CompilerErrorListener()); // Catch some other error messages that // 'CompileErrorStrategy' fails to catch // Begin parsing at main rule ParseTree tree = parser.programUnit(); // Error loading file? if (tree == null) { System.err.println("Can't parse file '" + filePath + "'"); return null; } // Show main nodes if (debug) { Timer.showStdErr("AST:"); for (int childNum = 0; childNum < tree.getChildCount(); childNum++) { Tree child = tree.getChild(childNum); System.err.println( "\t\tChild " + childNum + ":\t" + child + "\tTree:'" + child.toStringTree() + "'"); } } // Included files boolean resolveIncludePending = true; while (resolveIncludePending) resolveIncludePending = resolveIncludes(tree, debug, alreadyIncluded); return tree; } catch (Exception e) { String msg = e.getMessage(); CompilerMessages.get() .addError( "Could not compile " + filePath // + (msg != null ? " :" + e.getMessage() : "") // ); return null; } }