/**
* This method returns the module that corresponds to the path passed as a parameter.
*
* @param name the name of the module we're looking for (e.g.: mod1.mod2)
* @param dontSearchInit is used in a negative form because initially it was isLookingForRelative,
* but it actually defines if we should look in __init__ modules too, so, the name matches the
* old signature.
* <p>NOTE: isLookingForRelative description was: when looking for relative imports, we don't
* check for __init__
* @return the module represented by this name
*/
protected IModule getModule(
boolean acceptCompiledModule, String name, IPythonNature nature, boolean dontSearchInit) {
if (temporaryModules != null) {
synchronized (lockTemporaryModules) {
if (temporaryModules != null) {
// who knows, maybe it became null at that point.
FastStack<IModule> stack = temporaryModules.get(name);
if (stack != null && stack.size() > 0) {
if (DEBUG_TEMPORARY_MODULES) {
System.out.println("Returning temporary module: " + name);
}
return stack.peek();
}
}
}
}
AbstractModule n = null;
ModulesKey keyForCacheAccess = new ModulesKey(null, null);
if (!dontSearchInit) {
if (n == null) {
keyForCacheAccess.name = new StringBuffer(name).append(".__init__").toString();
n = cache.getObj(keyForCacheAccess, this);
if (n != null) {
name += ".__init__";
}
}
}
if (n == null) {
keyForCacheAccess.name = name;
n = cache.getObj(keyForCacheAccess, this);
}
if (n instanceof SourceModule) {
// ok, module exists, let's check if it is synched with the filesystem version...
SourceModule s = (SourceModule) n;
if (!s.isSynched()) {
// change it for an empty and proceed as usual.
n = (AbstractModule) addModule(createModulesKey(s.getName(), s.getFile()));
}
}
if (n instanceof EmptyModule) {
EmptyModule e = (EmptyModule) n;
boolean found = false;
if (!found && e.f != null) {
if (!e.f.exists()) {
// if the file does not exist anymore, just remove it.
keyForCacheAccess.name = name;
keyForCacheAccess.file = e.f;
doRemoveSingleModule(keyForCacheAccess);
n = null;
} else {
// file exists
n = checkOverride(name, nature, n);
if (n instanceof EmptyModule) {
// ok, handle case where the file is actually from a zip file...
if (e instanceof EmptyModuleForZip) {
EmptyModuleForZip emptyModuleForZip = (EmptyModuleForZip) e;
if (emptyModuleForZip.pathInZip.endsWith(".class") || !emptyModuleForZip.isFile) {
// handle java class... (if it's a class or a folder in a jar)
n = JythonModulesManagerUtils.createModuleFromJar(emptyModuleForZip);
n = decorateModule(n, nature);
} else if (FileTypesPreferencesPage.isValidDll(emptyModuleForZip.pathInZip)) {
// .pyd
n = new CompiledModule(name, IToken.TYPE_BUILTIN, nature.getAstManager());
n = decorateModule(n, nature);
} else if (PythonPathHelper.isValidSourceFile(emptyModuleForZip.pathInZip)) {
// handle python file from zip... we have to create it getting the contents from the
// zip file
try {
IDocument doc =
REF.getDocFromZip(emptyModuleForZip.f, emptyModuleForZip.pathInZip);
// NOTE: The nature (and so the grammar to be used) must be defined by this
// modules
// manager (and not by the initial caller)!!
n =
AbstractModule.createModuleFromDoc(
name, emptyModuleForZip.f, doc, this.getNature(), -1, false);
SourceModule zipModule = (SourceModule) n;
zipModule.zipFilePath = emptyModuleForZip.pathInZip;
n = decorateModule(n, nature);
} catch (Exception exc1) {
PydevPlugin.log(exc1);
n = null;
}
}
} else {
// regular case... just go on and create it.
try {
// NOTE: The nature (and so the grammar to be used) must be defined by this modules
// manager (and not by the initial caller)!!
n = AbstractModule.createModule(name, e.f, this.getNature(), -1);
n = decorateModule(n, nature);
} catch (IOException exc) {
keyForCacheAccess.name = name;
keyForCacheAccess.file = e.f;
doRemoveSingleModule(keyForCacheAccess);
n = null;
} catch (MisconfigurationException exc) {
PydevPlugin.log(exc);
n = null;
}
}
}
}
} else { // ok, it does not have a file associated, so, we treat it as a builtin (this can
// happen in java jars)
n = checkOverride(name, nature, n);
if (n instanceof EmptyModule) {
if (acceptCompiledModule) {
n = new CompiledModule(name, IToken.TYPE_BUILTIN, nature.getAstManager());
n = decorateModule(n, nature);
} else {
return null;
}
}
}
if (n != null) {
doAddSingleModule(createModulesKey(name, e.f), n);
} else {
System.err.println("The module " + name + " could not be found nor created!");
}
}
if (n instanceof EmptyModule) {
throw new RuntimeException("Should not be an empty module anymore!");
}
if (n instanceof SourceModule) {
SourceModule sourceModule = (SourceModule) n;
// now, here's a catch... it may be a bootstrap module...
if (sourceModule.isBootstrapModule()) {
// if it's a bootstrap module, we must replace it for the related compiled module.
n = new CompiledModule(name, IToken.TYPE_BUILTIN, nature.getAstManager());
n = decorateModule(n, nature);
}
}
return n;
}
