/** * Create a command line for launching. * * @param actualRun if true it'll make the variable substitution and start the listen connector in * the case of a debug session. * @return command line ready to be exec'd * @throws CoreException * @throws JDTNotAvailableException */ public String[] getCommandLine(boolean actualRun) throws CoreException, JDTNotAvailableException { List<String> cmdArgs = new ArrayList<String>(); if (isJython()) { // "java.exe" -classpath "C:\bin\jython21\jython.jar" org.python.util.jython script %ARGS% String javaLoc = JavaVmLocationFinder.findDefaultJavaExecutable().getAbsolutePath(); if (!InterpreterInfo.isJythonExecutable(interpreter.toOSString())) { throw new RuntimeException( "The jython jar must be specified as the interpreter to run. Found: " + interpreter); } cmdArgs.add(javaLoc); // some nice things on the classpath config: http://mindprod.com/jgloss/classpath.html cmdArgs.add("-classpath"); String cpath; // TODO: add some option in the project so that the user can choose to use the // classpath specified in the java project instead of the pythonpath itself // if (project.getNature(Constants.JAVA_NATURE) != null){ // cpath = getClasspath(JavaCore.create(project)); // } else { cpath = interpreter + SimpleRunner.getPythonPathSeparator() + pythonpathUsed; // } cmdArgs.add(cpath); cmdArgs.add( "-Dpython.path=" + pythonpathUsed); // will be added to the env variables in the run (check if this // works on all platforms...) addVmArgs(cmdArgs); if (isDebug) { // This was removed because it cannot be used. See: // http://bugs.jython.org/issue1438 // cmdArgs.add("-Dpython.security.respectJavaAccessibility=false"); cmdArgs.add("org.python.util.jython"); addDebugArgs(cmdArgs, "jython", actualRun); } else { cmdArgs.add("org.python.util.jython"); } } else { // python or iron python cmdArgs.add(interpreter.toOSString()); // Next option is for unbuffered stdout, otherwise Eclipse will not see any output until done cmdArgs.add("-u"); addVmArgs(cmdArgs); if (isDebug && isIronpython()) { addIronPythonDebugVmArgs(cmdArgs); } addDebugArgs(cmdArgs, "python", actualRun); } // Check if we should do code-coverage... boolean coverageRun = PyCoveragePreferences.getAllRunsDoCoverage(); if (coverageRun && isDebug) { if (actualRun) { RunInUiThread.async( new Runnable() { public void run() { PyDialogHelpers.openWarning( "Conflicting options: coverage with debug.", "Making a debug run with coverage enabled will not yield the expected results.\n\n" + "They'll conflict because both use the python tracing facility (i.e.: sys.settrace()).\n" + "\n" + "To debug a coverage run, do a regular run and use the remote debugger " + "(but note that the coverage will stop when it's enabled).\n" + "\n" + "Note: the run will be continued anyways."); } }); } } if (isUnittest()) { cmdArgs.add(getRunFilesScript()); } else { if (coverageRun) { // Separate support (unittest has the coverage support builtin). cmdArgs.add(getCoverageScript()); cmdArgs.add(PyCoverage.getCoverageFileLocation().getAbsolutePath()); cmdArgs.add("run"); cmdArgs.add("--source"); cmdArgs.add(PyCodeCoverageView.getChosenDir().getLocation().toOSString()); } } for (IPath p : resource) { cmdArgs.add(p.toOSString()); } if (!isUnittest()) { // The program arguments are not used when running a unittest (excluded from the tab group in // favor // of a way to overriding the default unittest arguments). String runArguments[] = null; if (actualRun && arguments != null) { String expanded = getStringSubstitution(PythonNature.getPythonNature(project)) .performStringSubstitution(arguments); runArguments = parseStringIntoList(expanded); } for (int i = 0; runArguments != null && i < runArguments.length; i++) { cmdArgs.add(runArguments[i]); } } else { // Last thing (first the files and last the special parameters the user passed -- i.e.: nose // parameters) addUnittestArgs(cmdArgs, actualRun, coverageRun); } String[] retVal = new String[cmdArgs.size()]; cmdArgs.toArray(retVal); if (actualRun) { CreatedCommandLineParams createdCommandLineParams = new CreatedCommandLineParams(retVal, coverageRun); // Provide a way for clients to alter the command line. List<Object> participants = ExtensionHelper.getParticipants(ExtensionHelper.PYDEV_COMMAND_LINE_PARTICIPANT); for (Object object : participants) { try { IPyCommandLineParticipant c = (IPyCommandLineParticipant) object; createdCommandLineParams = c.updateCommandLine(createdCommandLineParams); } catch (Exception e) { Log.log(e); } } retVal = createdCommandLineParams.cmdLine; PythonRunnerCallbacks.onCreatedCommandLine.call(createdCommandLineParams); } return retVal; }