interpreterinfo.java

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

	                                    return PydevPlugin.getImageCache().get(UIConstants.LIB_SYSTEM);
	                                }
	
	                                public String getText(Object element) {
	                                    return element.toString();
	                                }
	
	                                public void addListener(ILabelProviderListener listener) {
	                                }
	
	                                public void dispose() {
	                                }
	
	                                public boolean isLabelProperty(Object element, String property) {
	                                    return true;
	                                }
	
	                                public void removeListener(ILabelProviderListener listener) {
	                                }}, 
	                                
	                            "Select the folders to be added to the SYSTEM pythonpath!\n" +
	                            "\n" +
	                            "IMPORTANT: The folders for your PROJECTS should NOT be added here, but in your project configuration.\n\n" +
	                            "Check:http://fabioz.com/pydev/manual_101_interpreter.html for more details.");
	                    dialog.setInitialSelections(l.toArray(new String[0]));
	                    int i = dialog.open();
                        if(i == Window.OK){
                            result[0] = true;
    	                    Object[] result = dialog.getResult();
    	                    l.clear();
    	                    for (Object string : result) {
    	                        l.add((String) string);
    	                    }
                        }else{
                            result[0] = false;
                            
                        }
	                    
	                }
	                
	            };
	            try{
	                RunInUiThread.sync(runnable);
	            }catch(NoClassDefFoundError e){
	            }catch(UnsatisfiedLinkError e){
	                //this means that we're running unit-tests, so, we don't have to do anything about it
	                //as 'l' is already ok.
	            }
	        }
        }

        if(result[0] == false){
            //cancelled by the user
            return null;
        }
        
        ArrayList<String> l1 = new ArrayList<String>();
        if(libsSplit.length > 1){
	        String dllLibs = libsSplit[1];
	        String[] dllLibs1 = dllLibs.split("\\|");
	        for (int i = 0; i < dllLibs1.length; i++) {
	            String trimmed = dllLibs1[i].trim();
	            if(trimmed.length() > 0){
	                l1.add(trimmed);
	            }
	        }
        }
	        
        ArrayList<String> l2 = new ArrayList<String>();
        if(forcedSplit.length > 1){
	        String forcedLibs = forcedSplit[1];
	        String[] forcedLibs1 = forcedLibs.split("\\|");
	        for (int i = 0; i < forcedLibs1.length; i++) {
	            String trimmed = forcedLibs1[i].trim();
	            if(trimmed.length() > 0){
	                l2.add(trimmed);
	            }
	        }
        }	            
        return new InterpreterInfo(version, executable, l, l1, l2);
	        
    }
    
    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("Version");
        buffer.append(version);
        buffer.append("Executable:");
        buffer.append(executableOrJar);
        for (Iterator<String> iter = libs.iterator(); iter.hasNext();) {
            buffer.append("|");
            buffer.append(iter.next().toString());
        }
        buffer.append("@");
        if(dllLibs.size() > 0){
	        for (Iterator<String> iter = dllLibs.iterator(); iter.hasNext();) {
	            buffer.append("|");
	            buffer.append(iter.next().toString());
	        }
        }
        
        buffer.append("$");
        if(forcedLibs.size() > 0){
	        for (Iterator<String> iter = forcedLibs.iterator(); iter.hasNext();) {
	            buffer.append("|");
	            buffer.append(iter.next().toString());
	        }
        }
        
        return buffer.toString();
    }

    /**
     * Adds the compiled libs (dlls)
     */
    public void restoreCompiledLibs(IProgressMonitor monitor) {
        FileFilter filter = new FileFilter() {
            
	        public boolean accept(File pathname) {
	            if(pathname.isFile()){
	                return PythonPathHelper.isValidDll(REF.getFileAbsolutePath(pathname));
	            }else{
	                return false;
	            }
	        }
	
	    };

	    List<File> dlls = new ArrayList<File>();
	    for (Iterator<String> iter = libs.iterator(); iter.hasNext();) {
            String folder = iter.next();
            
            List<File>[] below = PydevPlugin.getPyFilesBelow(new File(folder), filter, monitor, false);
            dlls.addAll(below[0]);
        }
	    
	    dllLibs.clear();
	    for (Iterator<File> iter = dlls.iterator(); iter.hasNext();) {
            File f = iter.next();
            
            this.dllLibs.add(REF.getFileAbsolutePath(f));
        }
	    
	    //the compiled with the interpreter should be already gotten.
	    forcedLibs.add("os"); //we have it in source, but want to interpret it, source info (ast) does not give us much
        
        //as it is a set, there is no problem to add it twice
	    forcedLibs.add("__builtin__"); //jython bug: __builtin__ is not added
	    forcedLibs.add("sys"); //jython bug: sys is not added
        

        if(isJythonInfo()){
            //by default, we don't want to force anything to python.
            forcedLibs.add("StringIO"); //jython bug: StringIO is not added
        }else{
            //those are sources, but we want to get runtime info on them.
            forcedLibs.add("OpenGL");
            forcedLibs.add("wxPython");
            forcedLibs.add("wx");
        }
        this.builtinsCache = null; //force cache recreation
    }

    /**
     * Restores the path given non-standard libraries
     * @param path
     */
    public void restorePythonpath(String path, IProgressMonitor monitor) {
        //no managers involved here...
        getModulesManager().changePythonPath(path, null, monitor, null);
    }
    
    /**
     * Restores the path with the discovered libs
     * @param path
     */
    public void restorePythonpath(IProgressMonitor monitor) {
        StringBuffer buffer = new StringBuffer();
        for (Iterator<String> iter = libs.iterator(); iter.hasNext();) {
            String folder = (String) iter.next();
            buffer.append(folder);
            buffer.append("|");
        }
        restorePythonpath(buffer.toString(), monitor);
    }
    
    /**
     * @return whether this info belongs to jython 
     */
    public boolean isJythonInfo() {
        return isJythonExecutable(executableOrJar);
    }

    /**
     * @param executable the executable we want to know about
     * @return if the executable is the jython jar.
     */
    public static boolean isJythonExecutable(String executable) {
        if (executable.endsWith("\"")) {
            return executable.endsWith(".jar\"");
        }
        return executable.endsWith(".jar");
    }

    public String getExeAsFileSystemValidPath() {
        //   /\:*?"<>|
        char[] invalidChars = new char[]{
                '/',
                '\\',
                ':',
                '*',
                '?',
                '"',
                '<',
                '>',
                '|'};
        String systemValid = new String(REF.encodeBase64(executableOrJar.getBytes()));
        for (char c : invalidChars) {
            systemValid = systemValid.replace(c, '_');
        }
        return systemValid;
    }

    public String getVersion() {
        return version;
    }
 
    public int getGrammarVersion() {
        int grammarVersion = IPythonNature.GRAMMAR_PYTHON_VERSION_2_4;
        if(getVersion().equals("2.5")){
            grammarVersion = IPythonNature.GRAMMAR_PYTHON_VERSION_2_5;
        }
        return grammarVersion;
    }
    
    

    //START: Things related to the builtins (forcedLibs) ---------------------------------------------------------------
    public String[] getBuiltins() {
        if(this.builtinsCache == null){
            this.builtinsCache = forcedLibs.toArray(new String[0]);
        }
        return this.builtinsCache;
    }

    public void addForcedLib(String forcedLib) {
        this.forcedLibs.add(forcedLib);
        this.builtinsCache = null;
    }

    public void removeForcedLib(String forcedLib) {
        this.forcedLibs.remove(forcedLib);
        this.builtinsCache = null;
    }

    public Iterator<String> forcedLibsIterator() {
        return forcedLibs.iterator();
    }
    //END: Things related to the builtins (forcedLibs) -----------------------------------------------------------------
    
}