public void popTemporaryModule(String moduleName) { synchronized (lockTemporaryModules) { if (temporaryModules == null) { return; } FastStack<IModule> stack = temporaryModules.get(moduleName); if (stack == null) { // try to make it null when possible temporaryModules = null; return; } try { stack.pop(); if (stack.size() == 0) { temporaryModules.remove(moduleName); } if (temporaryModules.size() == 0) { // try to make it null when possible (so that we don't have to sync later on) temporaryModules = null; } } catch (Exception e) { Log.log(e); } } }
/** * @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); }
/** * @see * org.python.pydev.parser.jython.ast.VisitorBase#visitClassDef(org.python.pydev.parser.jython.ast.ClassDef) */ public Object visitClassDef(ClassDef node) throws Exception { globalDeclarationsStack.push(new HashSet<String>()); defsStack.push(node); node.traverse(this); defsStack.pop(); globalDeclarationsStack.pop(); checkDeclaration(node, (NameTok) node.name); return null; }
/** * @see * org.python.pydev.parser.jython.ast.VisitorBase#visitFunctionDef(org.python.pydev.parser.jython.ast.FunctionDef) */ public Object visitFunctionDef(FunctionDef node) throws Exception { globalDeclarationsStack.push(new HashSet<String>()); defsStack.push(node); if (node.args != null && node.args.args != null) { for (exprType arg : node.args.args) { if (arg instanceof Name) { checkParam((Name) arg); } } } node.traverse(this); defsStack.pop(); globalDeclarationsStack.pop(); checkDeclaration(node, (NameTok) node.name); return null; }
protected void after() { stack.pop(); }