public void run(IAction action) { IPythonNature pythonNature; try { pythonNature = getPyEdit().getPythonNature(); } catch (MisconfigurationException e1) { handle(e1); return; } PySelection ps = new PySelection(this.getPyEdit()); String selectedText = ps.getSelectedText(); if (selectedText == null || selectedText.length() == 0) { try { selectedText = ps.getCurrToken().o1; } catch (BadLocationException e) { // ignore } } if (pythonNature != null) { IInterpreterManager manager = pythonNature.getRelatedInterpreterManager(); getFromManagerAndRelatedNatures(selectedText, manager); } else { getFromSystemManager(selectedText); } }
/** @return a tuple with the process created and a string representation of the cmdarray. */ public Tuple<Process, String> run( String[] cmdarray, File workingDir, IPythonNature nature, IProgressMonitor monitor) { if (monitor == null) { monitor = new NullProgressMonitor(); } String executionString = getArgumentsAsStr(cmdarray); monitor.setTaskName("Executing: " + executionString); monitor.worked(5); Process process = null; try { monitor.setTaskName("Making pythonpath environment..." + executionString); String[] envp = null; if (nature != null) { envp = getEnvironment( nature, nature.getProjectInterpreter(), nature.getRelatedInterpreterManager()); // Don't remove as it *should* be updated // based on the nature) } // Otherwise, use default (used when configuring the interpreter for instance). monitor.setTaskName("Making exec..." + executionString); if (workingDir != null) { if (!workingDir.isDirectory()) { throw new RuntimeException( org.python.pydev.shared_core.string.StringUtils.format( "Working dir must be an existing directory (received: %s)", workingDir)); } } process = createProcess(cmdarray, envp, workingDir); } catch (Exception e) { throw new RuntimeException(e); } return new Tuple<Process, String>(process, executionString); }
public void run(IAction action) { FastStringBuffer buf = new FastStringBuffer(); try { PyEdit pyEdit = getPyEdit(); PySelection pySelection = new PySelection(pyEdit); IPythonNature nature = pyEdit.getPythonNature(); File editorFile = pyEdit.getEditorFile(); if (editorFile != null) { if (nature != null) { String mod = nature.resolveModule(editorFile); if (mod != null) { buf.append(mod); } else { // Support for external files (not in PYTHONPATH). buf.append(FullRepIterable.getFirstPart(editorFile.getName())); } } else { buf.append(FullRepIterable.getFirstPart(editorFile.getName())); } } List<stmtType> path = FastParser.parseToKnowGloballyAccessiblePath( pySelection.getDoc(), pySelection.getStartLineIndex()); for (stmtType stmtType : path) { if (buf.length() > 0) { buf.append('.'); } buf.append(NodeUtils.getRepresentationString(stmtType)); } } catch (MisconfigurationException e1) { Log.log(e1); return; } Transfer[] dataTypes = new Transfer[] {TextTransfer.getInstance()}; Object[] data = new Object[] {buf.toString()}; Clipboard clipboard = new Clipboard(EditorUtils.getShell().getDisplay()); try { clipboard.setContents(data, dataTypes); } catch (SWTError e) { if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) { throw e; } MessageDialog.openError( EditorUtils.getShell(), "Error copying to clipboard.", e.getMessage()); } finally { clipboard.dispose(); } }
/** * Returns the location of the selected interpreter in the launch configuration * * @param conf * @return the string location of the selected interpreter in the launch configuration * @throws CoreException if unable to retrieve the launch configuration attribute or if unable to * resolve the default interpreter. * @throws MisconfigurationException */ public static IInterpreterInfo getInterpreterLocation( ILaunchConfiguration conf, IPythonNature nature, IInterpreterManager interpreterManager) throws InvalidRunException, CoreException, MisconfigurationException { String location = conf.getAttribute(Constants.ATTR_INTERPRETER, Constants.ATTR_INTERPRETER_DEFAULT); if (location != null && location.equals(Constants.ATTR_INTERPRETER_DEFAULT)) { if (nature != null && nature.getInterpreterType() == interpreterManager.getInterpreterType()) { // When both, the interpreter for the launch and the nature have the same type, let's get // the // launch location from the project try { return nature.getProjectInterpreter(); } catch (PythonNatureWithoutProjectException e) { throw new RuntimeException(e); } } else { // When it doesn't have the same type it means that we're trying to run as jython a python // project (or vice-versa), so, we must get the interpreter from the interpreter manager! return interpreterManager.getDefaultInterpreterInfo(true); } } else { IInterpreterInfo interpreterInfo = interpreterManager.getInterpreterInfo(location, null); if (interpreterInfo != null) { return interpreterInfo; } else { File file = new File(location); if (!file.exists()) { throw new InvalidRunException("Error. The interprer: " + location + " does not exist"); } else { // it does not have information on the given interpreter!! if (nature == null) { throw new InvalidRunException( "Error. The interpreter: >>" + location + "<< is not configured in the pydev preferences as a valid interpreter (null nature)."); } else { throw new InvalidRunException( "Error. The interpreter: >>" + location + "<< is not configured in the pydev preferences as a valid '" + nature.getVersion() + "' interpreter."); } } } } }
/** * Generates the cached tokens in the needed structure for a 'fast' search given a token * representation (creates a map with the name of the token --> token). */ private Map<String, IToken> internalGenerateCachedTokens( IPythonNature nature, ICompletionCache completionCache, String activationToken, boolean searchSameLevelMods) throws CompletionRecursionException { Map<String, IToken> cachedTokens = new HashMap<String, IToken>(); // if still not found, we have to get all the tokens, including regular and wild imports ICompletionState state = CompletionStateFactory.getEmptyCompletionState(nature, completionCache); ICodeCompletionASTManager astManager = nature.getAstManager(); state.setActivationToken(activationToken); // we don't want to gather builtins in this case. state.setBuiltinsGotten(true); IToken[] globalTokens = astManager.getCompletionsForModule(this, state, searchSameLevelMods); for (IToken token : globalTokens) { String rep = token.getRepresentation(); IToken t = cachedTokens.get(rep); if (t != null) { // only override tokens if it's a getattr that's not defined in the builtin module if (rep.equals("__getattribute__") || rep.equals("__getattr__")) { if (!isTokenFromBuiltins(token)) { cachedTokens.put(rep, token); } } } else { cachedTokens.put(rep, token); } } return cachedTokens; }
/** @return the module name or null if it is not possible to determine the module name */ public String resolveModule() { if (moduleName == null) { if (file != null && nature != null) { try { moduleName = nature.resolveModule(file); } catch (MisconfigurationException e) { throw new RuntimeException(e); } } } return moduleName; }
/** * This function creates a module and resolves the module name (use this function if only the file * is available). * * @throws MisconfigurationException */ public static IModule createModuleFromDoc(File file, IDocument doc, IPythonNature pythonNature) throws MisconfigurationException { IModulesManager projModulesManager = pythonNature.getAstManager().getModulesManager(); String moduleName = null; if (file != null) { moduleName = projModulesManager.resolveModule(FileUtils.getFileAbsolutePath(file)); } if (moduleName == null) { moduleName = MODULE_NAME_WHEN_FILE_IS_UNDEFINED; } IModule module = createModuleFromDoc(moduleName, file, doc, pythonNature, false); return module; }
/** * @param pythonNatures the natures from were we can get info * @param additionalInfo the additional informations * @param selectedText the text that should be initially set as a filter */ public static void doSelect( List<IPythonNature> pythonNatures, List<AbstractAdditionalTokensInfo> additionalInfo, String selectedText) { SelectionDialog dialog = GlobalsDialogFactory.create(getShell(), additionalInfo, selectedText, pythonNatures); dialog.open(); Object[] result = dialog.getResult(); if (result != null && result.length > 0) { for (Object obj : result) { IInfo entry; if (obj instanceof AdditionalInfoAndIInfo) { entry = ((AdditionalInfoAndIInfo) obj).info; } else { entry = (IInfo) obj; } List<ItemPointer> pointers = new ArrayList<ItemPointer>(); CompletionCache completionCache = new CompletionCache(); for (IPythonNature pythonNature : pythonNatures) { // try to find in one of the natures... ICodeCompletionASTManager astManager = pythonNature.getAstManager(); if (astManager == null) { continue; } AnalysisPlugin.getDefinitionFromIInfo( pointers, astManager, pythonNature, entry, completionCache); if (pointers.size() > 0) { new PyOpenAction().run(pointers.get(0)); break; // don't check the other natures } } } } }
/** * Creates a string that can be passed as the PYTHONPATH * * @param project the project we want to get the settings from. If it is null, the system * pythonpath is returned * @param interpreter this is the interpreter to be used to create the env. * @return a string that can be used as the PYTHONPATH env variable */ public static String makePythonPathEnvString( IPythonNature pythonNature, IInterpreterInfo interpreter, IInterpreterManager manager) { if (pythonNature == null) { if (interpreter == null) { return makePythonPathEnvFromPaths( new ArrayList< String>()); // no pythonpath can be gotten (set to empty, so that the default is // gotten) } else { List<String> pythonPath = interpreter.getPythonPath(); return makePythonPathEnvFromPaths(pythonPath); } } List<String> paths; // if we have a project, get its complete pythonpath IPythonPathNature pythonPathNature = pythonNature.getPythonPathNature(); if (pythonPathNature == null) { IProject project = pythonNature.getProject(); String projectName; if (project == null) { projectName = "null?"; } else { projectName = project.getName(); } throw new RuntimeException( "The project " + projectName + " does not have the pythonpath configured, \n" + "please configure it correcly (please check the pydev getting started guide at \n" + "http://pydev.org/manual_101_root.html for better information on how to do it)."); } paths = pythonPathNature.getCompleteProjectPythonPath(interpreter, manager); return makePythonPathEnvFromPaths(paths); }
/** * This method creates a source module from a file. * * @return * @throws IOException * @throws MisconfigurationException */ public static AbstractModule createModule( String name, File f, IPythonNature nature, boolean checkForPath) throws IOException, MisconfigurationException { if (PythonPathHelper.isValidFileMod(f.getName())) { if (PythonPathHelper.isValidSourceFile(f.getName())) { return createModuleFromDoc( name, f, FileUtilsFileBuffer.getDocFromFile(f), nature, checkForPath); } else { // this should be a compiled extension... we have to get completions from the python // shell. return new CompiledModule(name, nature.getAstManager().getModulesManager(), nature); } } // if we are here, return null... return null; }
@Override public boolean isInGlobalTokens( String tok, IPythonNature nature, ICompletionCache completionCache) { // we have to override because there is no way to check if it is in some import from some other // place if it has dots on the tok... if (tok.indexOf('.') == -1) { return isInDirectGlobalTokens(tok, completionCache); } else { ICompletionState state = CompletionStateFactory.getEmptyCompletionState(nature, completionCache); String[] headAndTail = FullRepIterable.headAndTail(tok); state.setActivationToken(headAndTail[0]); String head = headAndTail[1]; IToken[] globalTokens = getGlobalTokens(state, nature.getAstManager()); for (IToken token : globalTokens) { if (token.getRepresentation().equals(head)) { return true; } } } return false; }
/** * Expands and returns the working directory attribute of the given launch configuration. Returns * <code>null</code> if a working directory is not specified. If specified, the working is * verified to point to an existing directory in the local file system. * * @param configuration launch configuration * @return an absolute path to a directory in the local file system, or <code>null</code> if * unspecified * @throws CoreException if unable to retrieve the associated launch configuration attribute, if * unable to resolve any variables, or if the resolved location does not point to an existing * directory in the local file system */ public static IPath getWorkingDirectory(ILaunchConfiguration configuration, IPythonNature nature) throws CoreException { IProject project = nature.getProject(); String location = configuration.getAttribute( Constants.ATTR_WORKING_DIRECTORY, "${project_loc:/" + project.getName() + "}"); if (location != null) { String expandedLocation = getStringSubstitution(nature).performStringSubstitution(location); if (expandedLocation.length() > 0) { File path = new File(expandedLocation); if (path.isDirectory()) { return new Path(expandedLocation); } throw new CoreException( PydevDebugPlugin.makeStatus( IStatus.ERROR, "Unable to get working location for the run \n(the location: '" + expandedLocation + "' is not a valid directory).", null)); } } return null; }
/* (non-Javadoc) * @see org.python.pydev.editor.codecompletion.IPyCodeCompletion#getCodeCompletionProposals(org.eclipse.jface.text.ITextViewer, org.python.pydev.editor.codecompletion.CompletionRequest) */ @SuppressWarnings("unchecked") public List getCodeCompletionProposals(ITextViewer viewer, CompletionRequest request) throws CoreException, BadLocationException, IOException, MisconfigurationException, PythonNatureWithoutProjectException { if (request.getPySelection().getCursorLineContents().trim().startsWith("#")) { // this may happen if the context is still not correctly computed in python return new PyStringCodeCompletion().getCodeCompletionProposals(viewer, request); } if (DebugSettings.DEBUG_CODE_COMPLETION) { Log.toLogFile(this, "Starting getCodeCompletionProposals"); Log.addLogLevel(); Log.toLogFile(this, "Request:" + request); } ArrayList<ICompletionProposal> ret = new ArrayList<ICompletionProposal>(); // let's see if we should do a code-completion in the current scope... if (!isValidCompletionContext(request)) { request.showTemplates = false; return ret; } try { IPythonNature pythonNature = request.nature; checkPythonNature(pythonNature); ICodeCompletionASTManager astManager = pythonNature.getAstManager(); if (astManager == null) { // we're probably still loading it. return ret; } // list of Object[], IToken or ICompletionProposal List<Object> tokensList = new ArrayList<Object>(); lazyStartShell(request); String trimmed = request.activationToken.replace('.', ' ').trim(); ImportInfo importsTipper = getImportsTipperStr(request); int line = request.doc.getLineOfOffset(request.documentOffset); IRegion region = request.doc.getLineInformation(line); ICompletionState state = new CompletionState( line, request.documentOffset - region.getOffset(), null, request.nature, request.qualifier); state.setIsInCalltip(request.isInCalltip); boolean importsTip = false; if (importsTipper.importsTipperStr.length() != 0) { // code completion in imports request.isInCalltip = false; // if found after (, but in an import, it is not a calltip! importsTip = doImportCompletion(request, astManager, tokensList, importsTipper); } else if (trimmed.length() > 0 && request.activationToken.indexOf('.') != -1) { // code completion for a token doTokenCompletion(request, astManager, tokensList, trimmed, state); } else { // go to globals doGlobalsCompletion(request, astManager, tokensList, state); } Map<String, IToken> alreadyChecked = new HashMap<String, IToken>(); String lowerCaseQual = request.qualifier.toLowerCase(); if (lowerCaseQual.length() >= PyCodeCompletionPreferencesPage.getArgumentsDeepAnalysisNChars()) { // this can take some time on the analysis, so, let's let the user choose on how many chars // does he // want to do the analysis... state.pushFindResolveImportMemoryCtx(); try { for (Iterator<Object> it = tokensList.listIterator(); it.hasNext(); ) { Object o = it.next(); if (o instanceof IToken) { it .remove(); // always remove the tokens from the list (they'll be re-added later // once they are filtered) IToken initialToken = (IToken) o; IToken token = initialToken; String strRep = token.getRepresentation(); IToken prev = alreadyChecked.get(strRep); if (prev != null) { if (prev.getArgs().length() != 0) { continue; // we already have a version with args... just keep going } } if (!strRep.toLowerCase().startsWith(lowerCaseQual)) { // just re-add it if we're going to actually use it (depending on the qualifier) continue; } while (token.isImportFrom()) { // we'll only add it here if it is an import from (so, set the flag to false for the // outer add) if (token.getArgs().length() > 0) { // if we already have the args, there's also no reason to do it (that's what we'll // do here) break; } ICompletionState s = state.getCopyForResolveImportWithActTok(token.getRepresentation()); s.checkFindResolveImportMemory(token); IToken token2 = astManager.resolveImport(s, token); if (token2 != null && initialToken != token2) { String args = token2.getArgs(); if (args.length() > 0) { // put it into the map (may override previous if it didn't have args) initialToken.setArgs(args); initialToken.setDocStr(token2.getDocStr()); if (initialToken instanceof SourceToken && token2 instanceof SourceToken) { SourceToken initialSourceToken = (SourceToken) initialToken; SourceToken token2SourceToken = (SourceToken) token2; initialSourceToken.setAst(token2SourceToken.getAst()); } break; } if (token2 == null || (token2.equals(token) && token2.getArgs().equals(token.getArgs()) && token2.getParentPackage().equals(token.getParentPackage()))) { break; } token = token2; } else { break; } } alreadyChecked.put(strRep, initialToken); } } } finally { state.popFindResolveImportMemoryCtx(); } } tokensList.addAll(alreadyChecked.values()); changeItokenToCompletionPropostal(viewer, request, ret, tokensList, importsTip, state); } catch (CompletionRecursionException e) { if (onCompletionRecursionException != null) { onCompletionRecursionException.call(e); } if (DebugSettings.DEBUG_CODE_COMPLETION) { Log.toLogFile(e); } // PydevPlugin.log(e); // ret.add(new CompletionProposal("",request.documentOffset,0,0,null,e.getMessage(), // null,null)); } if (DebugSettings.DEBUG_CODE_COMPLETION) { Log.remLogLevel(); Log.toLogFile(this, "Finished completion. Returned:" + ret.size() + " completions.\r\n"); } return ret; }
private void fillNatureCompletionsForConsole( IScriptConsoleViewer viewer, int requestOffset, List<ICompletionProposal> completions, String qual, boolean addAutoImport, int qlen, String lowerQual, IPythonNature nature, boolean getSystem) { AbstractAdditionalInterpreterInfo additionalInfoForProject; if (getSystem) { try { additionalInfoForProject = AdditionalSystemInterpreterInfo.getAdditionalSystemInfo( PydevPlugin.getInterpreterManager(nature), nature.getProjectInterpreter().getExecutableOrJar()); } catch (Exception e) { PydevPlugin.log(e); return; } } else { try { additionalInfoForProject = AdditionalProjectInterpreterInfo.getAdditionalInfoForProject(nature); } catch (Exception e) { PydevPlugin.log(e); return; } } List<IInfo> tokensStartingWith = additionalInfoForProject.getTokensStartingWith( qual, AbstractAdditionalInterpreterInfo.TOP_LEVEL); FastStringBuffer realImportRep = new FastStringBuffer(); FastStringBuffer displayString = new FastStringBuffer(); FastStringBuffer tempBuf = new FastStringBuffer(); for (IInfo info : tokensStartingWith) { // there always must be a declaringModuleName String declaringModuleName = info.getDeclaringModuleName(); boolean hasInit = false; if (declaringModuleName.endsWith(".__init__")) { declaringModuleName = declaringModuleName.substring( 0, declaringModuleName.length() - 9); // remove the .__init__ hasInit = true; } String rep = info.getName(); String lowerRep = rep.toLowerCase(); if (!lowerRep.startsWith(lowerQual)) { continue; } if (addAutoImport) { realImportRep.clear(); realImportRep.append("from "); realImportRep.append( AutoImportsPreferencesPage.removeImportsStartingWithUnderIfNeeded( declaringModuleName, tempBuf)); realImportRep.append(" import "); realImportRep.append(rep); } displayString.clear(); displayString.append(rep); displayString.append(" - "); displayString.append(declaringModuleName); if (hasInit) { displayString.append(".__init__"); } PyConsoleCompletion proposal = new PyConsoleCompletion( rep, requestOffset - qlen, qlen, realImportRep.length(), AnalysisPlugin.getImageForAutoImportTypeInfo(info), displayString.toString(), (IContextInformation) null, "", lowerRep.equals(lowerQual) ? IPyCompletionProposal.PRIORITY_LOCALS_1 : IPyCompletionProposal.PRIORITY_GLOBALS, realImportRep.toString(), viewer); completions.add(proposal); } }
/** * Sets defaults. * * @throws InvalidRunException * @throws MisconfigurationException */ @SuppressWarnings("unchecked") public PythonRunnerConfig( ILaunchConfiguration conf, String mode, String run, boolean makeArgumentsVariableSubstitution) throws CoreException, InvalidRunException, MisconfigurationException { // 1st thing, see if this is a valid run. project = getProjectFromConfiguration(conf); if (project == null) { // Ok, we could not find it out throw Log.log("Could not get project for configuration: " + conf); } // We need the project to find out the default interpreter from the InterpreterManager. IPythonNature pythonNature = PythonNature.getPythonNature(project); if (pythonNature == null) { CoreException e = Log.log("No python nature for project: " + project.getName()); throw e; } // now, go on configuring other things this.configuration = conf; this.run = run; isDebug = mode.equals(ILaunchManager.DEBUG_MODE); isInteractive = mode.equals("interactive"); resource = getLocation(conf, pythonNature); arguments = getArguments(conf, makeArgumentsVariableSubstitution); IPath workingPath = getWorkingDirectory(conf, pythonNature); workingDirectory = workingPath == null ? null : workingPath.toFile(); acceptTimeout = PydevPrefs.getPreferences().getInt(PydevEditorPrefs.CONNECT_TIMEOUT); interpreterLocation = getInterpreterLocation(conf, pythonNature, this.getRelatedInterpreterManager()); interpreter = getInterpreter(interpreterLocation, conf, pythonNature); // make the environment ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager(); envp = launchManager.getEnvironment(conf); IInterpreterManager manager; if (isJython()) { manager = PydevPlugin.getJythonInterpreterManager(); } else if (isIronpython()) { manager = PydevPlugin.getIronpythonInterpreterManager(); } else { manager = PydevPlugin.getPythonInterpreterManager(); } boolean win32 = PlatformUtils.isWindowsPlatform(); if (envp == null) { // ok, the user has done nothing to the environment, just get all the default environment // which has the pythonpath in it envp = SimpleRunner.getEnvironment(pythonNature, interpreterLocation, manager); } else { // ok, the user has done something to configure it, so, just add the pythonpath to the // current env (if he still didn't do so) Map envMap = conf.getAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, (Map) null); String pythonpath = SimpleRunner.makePythonPathEnvString(pythonNature, interpreterLocation, manager); updateVar(pythonNature, manager, win32, envMap, "PYTHONPATH", pythonpath); if (isJython()) { // Also update the classpath env variable. updateVar(pythonNature, manager, win32, envMap, "CLASSPATH", pythonpath); // And the jythonpath env variable updateVar(pythonNature, manager, win32, envMap, "JYTHONPATH", pythonpath); } else if (isIronpython()) { // Also update the ironpythonpath env variable. updateVar(pythonNature, manager, win32, envMap, "IRONPYTHONPATH", pythonpath); } // And we also must get the environment variables specified in the interpreter manager. envp = interpreterLocation.updateEnv(envp, envMap.keySet()); } boolean hasDjangoNature = project.hasNature(PythonNature.DJANGO_NATURE_ID); String settingsModule = null; Map<String, String> variableSubstitution = null; final String djangoSettingsKey = "DJANGO_SETTINGS_MODULE"; String djangoSettingsEnvEntry = null; try { variableSubstitution = pythonNature.getPythonPathNature().getVariableSubstitution(); settingsModule = variableSubstitution.get(djangoSettingsKey); if (settingsModule != null) { if (settingsModule.trim().length() > 0) { djangoSettingsEnvEntry = djangoSettingsKey + "=" + settingsModule.trim(); } } } catch (Exception e1) { Log.log(e1); } if (djangoSettingsEnvEntry == null && hasDjangoNature) { // Default if not specified (only add it if the nature is there). djangoSettingsEnvEntry = djangoSettingsKey + "=" + project.getName() + ".settings"; } // Note: set flag even if not debugging as the user may use remote-debugging later on. boolean geventSupport = DebugPrefsPage.getGeventDebugging() && pythonNature.getInterpreterType() == IPythonNature.INTERPRETER_TYPE_PYTHON; // Now, set the pythonpathUsed according to what's in the environment. String p = ""; for (int i = 0; i < envp.length; i++) { String s = envp[i]; Tuple<String, String> tup = StringUtils.splitOnFirst(s, '='); String var = tup.o1; if (win32) { // On windows it doesn't matter, always consider uppercase. var = var.toUpperCase(); } if (var.equals("PYTHONPATH")) { p = tup.o2; } else if (var.equals(djangoSettingsKey)) { // Update it. if (djangoSettingsEnvEntry != null) { envp[i] = djangoSettingsEnvEntry; djangoSettingsEnvEntry = null; } } if (geventSupport) { if (var.equals("GEVENT_SUPPORT")) { // Flag already set in the environment geventSupport = false; } } } // Still not added, let's do that now. if (djangoSettingsEnvEntry != null) { envp = StringUtils.addString(envp, djangoSettingsEnvEntry); } if (geventSupport) { envp = StringUtils.addString(envp, "GEVENT_SUPPORT=True"); } this.pythonpathUsed = p; }
/** * @param findInfo * @see * org.python.pydev.editor.codecompletion.revisited.modules.AbstractModule#findDefinition(java.lang.String, * int, int) */ public Definition[] findDefinition( ICompletionState state, int line, int col, IPythonNature nature) throws Exception { String token = state.getActivationToken(); if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition:" + token); } Definition[] found = this.definitionsFoundCache.getObj(token); if (found != null) { if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition: found in cache."); } return found; } AbstractShell shell = AbstractShell.getServerShell(nature, AbstractShell.COMPLETION_SHELL); synchronized (shell) { Tuple<String[], int[]> def = shell.getLineCol( this.name, token, nature .getAstManager() .getModulesManager() .getCompletePythonPath( nature.getProjectInterpreter(), nature.getRelatedInterpreterManager())); // default if (def == null) { if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition:" + token + " = empty"); } this.definitionsFoundCache.add(token, EMPTY_DEFINITION); return EMPTY_DEFINITION; } String fPath = def.o1[0]; if (fPath.equals("None")) { if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition:" + token + " = None"); } Definition[] definition = new Definition[] {new Definition(def.o2[0], def.o2[1], token, null, null, this)}; this.definitionsFoundCache.add(token, definition); return definition; } File f = new File(fPath); String foundModName = nature.resolveModule(f); String foundAs = def.o1[1]; IModule mod; if (foundModName == null) { // this can happen in a case where we have a definition that's found from a compiled file // which actually // maps to a file that's outside of the pythonpath known by Pydev. String n = FullRepIterable.getFirstPart(f.getName()); mod = AbstractModule.createModule(n, f, nature, true); } else { mod = nature.getAstManager().getModule(foundModName, nature, true); } if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition: found at:" + mod.getName()); } int foundLine = def.o2[0]; if (foundLine == 0 && foundAs != null && foundAs.length() > 0 && mod != null && state.canStillCheckFindSourceFromCompiled(mod, foundAs)) { // TODO: The nature (and so the grammar to be used) must be defined by the file we'll parse // (so, we need to know the system modules manager that actually created it to know the // actual nature) IModule sourceMod = AbstractModule.createModuleFromDoc( mod.getName(), f, new Document(REF.getFileContents(f)), nature, true); if (sourceMod instanceof SourceModule) { Definition[] definitions = (Definition[]) sourceMod.findDefinition(state.getCopyWithActTok(foundAs), -1, -1, nature); if (definitions.length > 0) { this.definitionsFoundCache.add(token, definitions); return definitions; } } } if (mod == null) { mod = this; } int foundCol = def.o2[1]; if (foundCol < 0) { foundCol = 0; } if (TRACE_COMPILED_MODULES) { System.out.println("CompiledModule.findDefinition: found compiled at:" + mod.getName()); } Definition[] definitions = new Definition[] {new Definition(foundLine + 1, foundCol + 1, token, null, null, mod)}; this.definitionsFoundCache.add(token, definitions); return definitions; } }
/** * @param name determines the name of the method to visit (added removed or changed) * @param resource the resource to visit * @param document the document from the resource * @param monitor */ private void visitWith( int visitType, final IResource resource, ICallback0<IDocument> document, IProgressMonitor monitor) { if (monitor.isCanceled()) { return; // it's already cancelled } IPythonNature nature = PythonNature.getPythonNature(resource); if (nature == null) { return; } if (!nature.startRequests()) { return; } try { try { // we visit external because we must index them if (!isResourceInPythonpathProjectSources(resource, nature, true)) { return; // we only analyze resources that are in the pythonpath } } catch (Exception e1) { Log.log(e1); return; // we only analyze resources that are in the pythonpath } VisitorMemo copyMemo = new VisitorMemo(this.memo); FastStringBuffer bufferToCommunicateProgress = new FastStringBuffer(); for (PyDevBuilderVisitor visitor : visitors) { // some visitors cannot visit too many elements because they do a lot of processing if (visitor.maxResourcesToVisit() == PyDevBuilderVisitor.MAX_TO_VISIT_INFINITE || visitor.maxResourcesToVisit() >= totalResources) { visitor.memo = copyMemo; // setting the memo must be the first thing. try { // communicate progress for each visitor PyDevBuilder.communicateProgress( monitor, totalResources, currentResourcesVisited, resource, visitor, bufferToCommunicateProgress); switch (visitType) { case VISIT_ADD: visitor.visitAddedResource(resource, document, monitor); break; case VISIT_CHANGE: visitor.visitChangedResource(resource, document, monitor); break; case VISIT_REMOVE: visitor.visitRemovedResource(resource, document, monitor); break; default: throw new RuntimeException("Error: visit type not properly given!"); // $NON-NLS-1$ } } catch (Exception e) { Log.log(e); } } } } finally { nature.endRequests(); } }
@Override public void addProps( MarkerAnnotationAndPosition markerAnnotation, IAnalysisPreferences analysisPreferences, String line, PySelection ps, int offset, IPythonNature nature, PyEdit edit, List<ICompletionProposal> props) throws BadLocationException, CoreException { if (nature == null) { return; } ICodeCompletionASTManager astManager = nature.getAstManager(); if (astManager == null) { return; } if (markerAnnotation.position == null) { return; } IMarker marker = markerAnnotation.markerAnnotation.getMarker(); Integer id = (Integer) marker.getAttribute(AnalysisRunner.PYDEV_ANALYSIS_TYPE); int start = markerAnnotation.position.offset; int end = start + markerAnnotation.position.length; ps.setSelection(start, end); String markerContents; try { markerContents = ps.getSelectedText(); } catch (Exception e1) { return; // Selection may be wrong. } IDocument doc = ps.getDoc(); List<String> parametersAfterCall = ps.getParametersAfterCall(end); switch (id) { case IAnalysisPreferences.TYPE_UNDEFINED_VARIABLE: addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall); addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall); break; case IAnalysisPreferences.TYPE_UNDEFINED_IMPORT_VARIABLE: // Say we had something as: // import sys // sys.Bar // in which case 'Bar' is undefined // in this situation, the activationTokenAndQual would be "sys." and "Bar" // and we want to get the definition for "sys" String[] activationTokenAndQual = ps.getActivationTokenAndQual(true); if (activationTokenAndQual[0].endsWith(".")) { ArrayList<IDefinition> selected = findDefinitions(nature, edit, start - 2, doc); for (IDefinition iDefinition : selected) { IModule module = iDefinition.getModule(); if (module.getFile() != null) { Definition definition = (Definition) iDefinition; File file = module.getFile(); if (definition.ast == null) { // if we have no ast in the definition, it means the module itself was found (global // scope) // Add option to create class at the given module! addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall, file); addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall, file); } else if (definition.ast instanceof ClassDef) { ClassDef classDef = (ClassDef) definition.ast; // Ok, we should create a field or method in this case (accessing a classmethod or // staticmethod) PyCreateMethodOrField pyCreateMethod = new PyCreateMethodOrField(); String className = NodeUtils.getNameFromNameTok(classDef.name); pyCreateMethod.setCreateInClass(className); pyCreateMethod.setCreateAs(PyCreateMethodOrField.CLASSMETHOD); addCreateClassmethodOption( ps, edit, props, markerContents, parametersAfterCall, pyCreateMethod, file, className); } } } } break; case IAnalysisPreferences.TYPE_UNRESOLVED_IMPORT: // This case is the following: from other_module4 import Foo // with 'Foo' being undefined. // So, we have to suggest creating a Foo class/method in other_module4 PyImportsHandling importsHandling = new PyImportsHandling(ps.getDoc(), false); int offsetLine = ps.getLineOfOffset(start); String selectedText = ps.getSelectedText(); Tuple<IModule, String> found = null; String foundFromImportStr = null; boolean isImportFrom = false; OUT: for (ImportHandle handle : importsHandling) { if (handle.startFoundLine == offsetLine || handle.endFoundLine == offsetLine || (handle.startFoundLine < offsetLine && handle.endFoundLine > offsetLine)) { List<ImportHandleInfo> importInfo = handle.getImportInfo(); for (ImportHandleInfo importHandleInfo : importInfo) { String fromImportStr = importHandleInfo.getFromImportStr(); List<String> importedStr = importHandleInfo.getImportedStr(); for (String imported : importedStr) { if (selectedText.equals(imported)) { if (fromImportStr != null) { foundFromImportStr = fromImportStr + "." + imported; isImportFrom = true; } else { // if fromImportStr == null, it's not a from xxx import yyy (i.e.: simple // import) foundFromImportStr = imported; } try { String currentModule = nature.resolveModule(edit.getEditorFile()); ICompletionState state = CompletionStateFactory.getEmptyCompletionState( nature, new CompletionCache()); found = nature .getAstManager() .findModule( foundFromImportStr, currentModule, state, new SourceModule( currentModule, edit.getEditorFile(), edit.getAST(), null)); } catch (Exception e) { Log.log(e); } break OUT; } } } break OUT; } } boolean addOptionToCreateClassOrMethod = isImportFrom; if (found != null && found.o1 != null) { // Ok, we found a module, now, it may be that we still have to create some intermediary // modules // or just create a class or method at the end. if (found.o1 instanceof SourceModule) { // if all was found, there's nothing left to create. if (found.o2 != null && found.o2.length() > 0) { SourceModule sourceModule = (SourceModule) found.o1; File file = sourceModule.getFile(); if (found.o2.indexOf('.') != -1) { // We have to create some intermediary structure. if (!addOptionToCreateClassOrMethod) { // Cannot create class or method from the info (only the module structure). if (sourceModule.getName().endsWith(".__init__")) { File f = getFileStructure(file.getParentFile(), found.o2); addCreateModuleOption(ps, edit, props, markerContents, f); } } else { // Ok, the leaf may be a class or method. if (sourceModule.getName().endsWith(".__init__")) { String moduleName = FullRepIterable.getWithoutLastPart(sourceModule.getName()); String withoutLastPart = FullRepIterable.getWithoutLastPart(found.o2); moduleName += "." + withoutLastPart; String classOrMethodName = FullRepIterable.getLastPart(found.o2); File f = getFileStructure(file.getParentFile(), withoutLastPart); addCreateClassInNewModuleOption( ps, edit, props, classOrMethodName, moduleName, parametersAfterCall, f); addCreateMethodInNewModuleOption( ps, edit, props, classOrMethodName, moduleName, parametersAfterCall, f); } } } else { // Ok, it's all there, we just have to create the leaf. if (!addOptionToCreateClassOrMethod || sourceModule.getName().endsWith(".__init__")) { // Cannot create class or method from the info (only the module structure). if (sourceModule.getName().endsWith(".__init__")) { File f = new File( file.getParent(), found.o2 + FileTypesPreferencesPage.getDefaultDottedPythonExtension()); addCreateModuleOption(ps, edit, props, markerContents, f); } } else { // Ok, the leaf may be a class or method. addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall, file); addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall, file); } } } } } else if (foundFromImportStr != null) { // We couldn't find anything there, so, we have to create the modules structure as needed // and // maybe create a class or module at the end (but only if it's an import from). // Ok, it's all there, we just have to create the leaf. // Discover the source folder where we should create the structure. File editorFile = edit.getEditorFile(); String onlyProjectPythonPathStr = nature.getPythonPathNature().getOnlyProjectPythonPathStr(false); List<String> split = StringUtils.splitAndRemoveEmptyTrimmed(onlyProjectPythonPathStr, '|'); for (int i = 0; i < split.size(); i++) { String fullPath = FileUtils.getFileAbsolutePath(split.get(i)); fullPath = PythonPathHelper.getDefaultPathStr(fullPath); split.set(i, fullPath); } HashSet<String> projectSourcePath = new HashSet<String>(split); if (projectSourcePath.size() == 0) { return; // No source folder for editor... this shouldn't happen (code analysis wouldn't // even run on it). } String fullPath = FileUtils.getFileAbsolutePath(editorFile); fullPath = PythonPathHelper.getDefaultPathStr(fullPath); String foundSourceFolderFullPath = null; if (projectSourcePath.size() == 1) { foundSourceFolderFullPath = projectSourcePath.iterator().next(); } else { for (String string : projectSourcePath) { if (fullPath.startsWith(string)) { // Use this as the source folder foundSourceFolderFullPath = string; break; } } } if (foundSourceFolderFullPath != null) { if (!addOptionToCreateClassOrMethod) { // Cannot create class or method from the info (only the module structure). File f = getFileStructure(new File(foundSourceFolderFullPath), foundFromImportStr); addCreateModuleOption(ps, edit, props, foundFromImportStr, f); } else { // Ok, the leaf may be a class or method. String moduleName = FullRepIterable.getWithoutLastPart(foundFromImportStr); File file = getFileStructure(new File(foundSourceFolderFullPath), moduleName); String lastPart = FullRepIterable.getLastPart(foundFromImportStr); addCreateClassInNewModuleOption( ps, edit, props, lastPart, moduleName, parametersAfterCall, file); addCreateMethodInNewModuleOption( ps, edit, props, lastPart, moduleName, parametersAfterCall, file); } } } break; } }
/** * @see * org.python.pydev.editor.codecompletion.revisited.modules.AbstractModule#getGlobalTokens(java.lang.String) */ public IToken[] getGlobalTokens(ICompletionState state, ICodeCompletionASTManager manager) { String activationToken = state.getActivationToken(); if (activationToken.length() == 0) { return getGlobalTokens(); } Map<String, IToken> v = cache.get(activationToken); if (v != null) { Collection<IToken> values = v.values(); return values.toArray(new IToken[values.size()]); } IToken[] toks = new IToken[0]; if (COMPILED_MODULES_ENABLED) { try { final IPythonNature nature = manager.getNature(); final AbstractShell shell; try { shell = AbstractShell.getServerShell(nature, AbstractShell.COMPLETION_SHELL); } catch (Exception e) { throw new RuntimeException("Unable to create shell for CompiledModule: " + this.name, e); } synchronized (shell) { String act = name + '.' + activationToken; String tokenToCompletion = act; if (isPythonBuiltin) { String replacement = BUILTIN_REPLACEMENTS.get(activationToken); if (replacement != null) { tokenToCompletion = name + '.' + replacement; } } List<String[]> completions = shell.getImportCompletions( tokenToCompletion, manager .getModulesManager() .getCompletePythonPath( nature.getProjectInterpreter(), nature.getRelatedInterpreterManager())) .o2; ArrayList<IToken> array = new ArrayList<IToken>(); for (Iterator<String[]> iter = completions.iterator(); iter.hasNext(); ) { String[] element = iter.next(); if (element.length >= 4) { // it might be a server error IToken t = new CompiledToken( element[0], element[1], element[2], act, Integer.parseInt(element[3])); array.add(t); } } toks = (CompiledToken[]) array.toArray(new CompiledToken[0]); HashMap<String, IToken> map = new HashMap<String, IToken>(); for (IToken token : toks) { map.put(token.getRepresentation(), token); } cache.put(activationToken, map); } } catch (Exception e) { Log.log( "Error while getting info for module:" + this.name + ". Project: " + manager.getNature().getProject(), e); } } return toks; }
/** * @return the module name where the completion request took place (may be null if there is no * editor file associated) */ public String resolveModule() { if (initialModule == null && editorFile != null) { initialModule = nature.resolveModule(editorFile); } return initialModule; }
/** * @return the function name for this breakpoint. * <p>A return of "None" signals that we couldn't discover the function name (so, we should * try to match things in the whole file, and not only in the given context, as we don't know * which context it is) */ public String getFunctionName() { String fileStr = getFile(); File file = fileStr != null ? new File(fileStr) : null; if (file == null || !file.exists()) { return "None"; } if (file.lastModified() == lastModifiedTimeCached) { return functionName; } try { IPythonNature nature = getPythonNature(); if (nature == null) { lastModifiedTimeCached = 0; return "None"; } ICodeCompletionASTManager astManager = nature.getAstManager(); if (astManager == null) { lastModifiedTimeCached = 0; return "None"; } // Only mark it as found if we were able to get the python nature (otherwise, this could // change later // if requesting during a setup) if (nature.startRequests()) { // start requests, as we'll ask for resolve and get module. SourceModule sourceModule = null; try { String modName = nature.resolveModule(fileStr); if (modName != null) { // when all is set up, this is the most likely path we're going to use // so, we shouldn't have delays when the module is changed, as it's already // ok for use. IModule module = astManager.getModule(modName, nature, true); if (module instanceof SourceModule) { sourceModule = (SourceModule) module; } } } finally { nature.endRequests(); } lastModifiedTimeCached = file.lastModified(); if (sourceModule == null) { // the text for the breakpoint requires the function name, and it may be requested before // the ast manager is actually restored (so, modName is None, and we have little // alternative // but making a parse to get the function name) IDocument doc = getDocument(); sourceModule = AbstractModule.createModuleFromDoc("", null, doc, nature, true); } int lineToUse = getLineNumber() - 1; if (sourceModule == null || sourceModule.getAst() == null || lineToUse < 0) { functionName = "None"; return functionName; } SimpleNode ast = sourceModule.getAst(); functionName = NodeUtils.getContextName(lineToUse, ast); if (functionName == null) { functionName = ""; // global context } return functionName; } // If it was found, it would've already returned. So, match anything as we couldn't determine // it. functionName = "None"; } catch (Exception e) { // Some error happened determining it. Match anything. Log.log( "Error determining breakpoint context. Breakpoint at: " + file + " will match any context.", e); functionName = "None"; } return functionName; }
/** * 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; }
/** * This method creates the python server process and starts the sockets, so that we can talk with * the server. * * @throws IOException * @throws CoreException * @throws MisconfigurationException * @throws PythonNatureWithoutProjectException */ /*package*/ void startIt(IPythonNature nature) throws IOException, JDTNotAvailableException, CoreException, MisconfigurationException, PythonNatureWithoutProjectException { this.startIt(nature.getProjectInterpreter()); }
private void setTokens(String name, IModulesManager manager) throws IOException, Exception, CoreException { if (TRACE_COMPILED_MODULES) { Log.log(IStatus.INFO, ("Compiled modules: getting info for:" + name), null); } final IPythonNature nature = manager.getNature(); AbstractShell shell = AbstractShell.getServerShell(nature, AbstractShell.COMPLETION_SHELL); synchronized (shell) { Tuple<String, List<String[]>> completions = shell.getImportCompletions( name, manager.getCompletePythonPath( nature.getProjectInterpreter(), nature.getRelatedInterpreterManager())); // default if (TRACE_COMPILED_MODULES) { Log.log( IStatus.INFO, ("Compiled modules: " + name + " file: " + completions.o1 + " found: " + completions.o2.size() + " completions."), null); } String fPath = completions.o1; if (fPath != null) { if (!fPath.equals("None")) { this.file = new File(fPath); } String f = fPath; if (f.toLowerCase().endsWith(".pyc")) { f = f.substring(0, f.length() - 1); // remove the c from pyc File f2 = new File(f); if (f2.exists()) { this.file = f2; } } } ArrayList<IToken> array = new ArrayList<IToken>(); for (String[] element : completions.o2) { // let's make this less error-prone. try { String o1 = element[0]; // this one is really, really needed String o2 = ""; String o3 = ""; if (element.length > 0) { o2 = element[1]; } if (element.length > 0) { o3 = element[2]; } IToken t; if (element.length > 0) { t = new CompiledToken(o1, o2, o3, name, Integer.parseInt(element[3])); } else { t = new CompiledToken(o1, o2, o3, name, IToken.TYPE_BUILTIN); } array.add(t); } catch (Exception e) { String received = ""; for (int i = 0; i < element.length; i++) { received += element[i]; received += " "; } Log.log( IStatus.ERROR, ("Error getting completions for compiled module " + name + " received = '" + received + "'"), e); } } // as we will use it for code completion on sources that map to modules, the __file__ should // also // be added... if (array.size() > 0 && (name.equals("__builtin__") || name.equals("builtins"))) { array.add(new CompiledToken("__file__", "", "", name, IToken.TYPE_BUILTIN)); array.add(new CompiledToken("__name__", "", "", name, IToken.TYPE_BUILTIN)); array.add(new CompiledToken("__builtins__", "", "", name, IToken.TYPE_BUILTIN)); array.add(new CompiledToken("__dict__", "", "", name, IToken.TYPE_BUILTIN)); } addTokens(array); } }