/** * @param lastMayBeMethod if true, it gets the path and accepts a method (if it is the last in the * stack) if false, null is returned if a method is found. * @param tempStack is a temporary stack object (which may be cleared) * @return a tuple, where the first element is the path where the entry is located (may return * null). and the second element is a boolen that indicates if the last was actually a method * or not. */ private Tuple<String, Boolean> getPathToRoot( ASTEntry entry, boolean lastMayBeMethod, boolean acceptAny, FastStack<SimpleNode> tempStack) { if (entry.parent == null) { return null; } // just to be sure that it's empty tempStack.clear(); boolean lastIsMethod = false; // if the last 'may be a method', in this case, we have to remember that it will actually be the // first one // to be analyzed. // let's get the stack while (entry.parent != null) { if (entry.parent.node instanceof ClassDef) { tempStack.push(entry.parent.node); } else if (entry.parent.node instanceof FunctionDef) { if (!acceptAny) { if (lastIsMethod) { // already found a method return null; } if (!lastMayBeMethod) { return null; } // ok, the last one may be a method... (in this search, it MUST be the first one...) if (tempStack.size() != 0) { return null; } } // ok, there was a class, so, let's go and set it tempStack.push(entry.parent.node); lastIsMethod = true; } else { return null; } entry = entry.parent; } // now that we have the stack, let's make it into a path... FastStringBuffer buf = new FastStringBuffer(); while (tempStack.size() > 0) { if (buf.length() > 0) { buf.append("."); } buf.append(NodeUtils.getRepresentationString(tempStack.pop())); } return new Tuple<String, Boolean>(buf.toString(), lastIsMethod); }