import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * Gets the work dir.
 * 
 * @param config
 * @return
 * @throws CoreException
 */
protected File getWorkingDir( VMRunnerConfiguration config )
		throws CoreException
{
	String path = config.getWorkingDirectory( );
	if ( path == null )
	{
		return null;
	}
	File dir = new File( path );
	if ( !dir.isDirectory( ) )
	{
		throw new Error( "Workking directory is null" );//$NON-NLS-1$
	}
	return dir;
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * Returns the working directory to use for the launched VM, or
 * <code>null</code> if the working directory is to be inherited from the
 * current process.
 * 
 * @return the working directory to use
 * @exception CoreException
 *                if the working directory specified by the configuration
 *                does not exist or is not a directory
 */
protected File getWorkingDir(VMRunnerConfiguration config)
		throws CoreException {
	String path = config.getWorkingDirectory();
	if (path == null) {
		return null;
	}
	File dir = new File(path);
	if (!dir.isDirectory()) {
		abort(
				MessageFormat
						.format(
								HyLauncherMessages
										.getString("javaVMRunner.Specified_working_directory_does_not_exist_or_is_not_a_directory__{0}_1"), new String[] { path }), null, IJavaLaunchConfigurationConstants.ERR_WORKING_DIRECTORY_DOES_NOT_EXIST); //$NON-NLS-1$
	}
	return dir;
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
protected String constructProgramString(String location, VMRunnerConfiguration config) {
	String command= null;
	Map map= config.getVMSpecificAttributesMap();
	if (map != null) {
		command= (String)map.get(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND);
	}
	
	StringBuffer program= new StringBuffer();
	program.append(location).append(File.separator).append("bin").append(File.separator); //$NON-NLS-1$
	int directoryLength= program.length();
	if (command == null) {
		program.append("javaw.exe"); //$NON-NLS-1$
		File javaw= new File(program.toString());
		if (!javaw.exists()) {
			program.replace(directoryLength, program.length(), "java"); //$NON-NLS-1$
		}
	} else {
		program.append(command);
	}
	
	return program.toString();
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * @param label
 * @param classToLaunch
 * @param classpath
 * @param bootClasspath
 * @param vmArgs
 * @param prgArgs
 * @param workDir
 * @param sourceLocator
 * @param debug
 * @param showInDebugger
 * @throws CoreException
 */
public void runVM(final String label, final String classToLaunch, final String[] classpath, final String[] bootClasspath, final String[] vmArgs,
        final String[] prgArgs, final String workDir, final ISourceLocator sourceLocator, final boolean debug, final boolean showInDebugger)
        throws CoreException {
    final IVMInstall vmInstall = this.getVMInstall();
    String mode = ILaunchManager.DEBUG_MODE;
    if (debug && classToLaunch.equals(WEBLOGIC_MAIN_CLASS)) {
        mode = ILaunchManager.DEBUG_MODE;
    } else {
        mode = ILaunchManager.RUN_MODE;
    }
    final IVMRunner vmRunner = vmInstall.getVMRunner(mode);

    final ILaunchConfigurationType launchType = DebugPlugin.getDefault().getLaunchManager()
            .getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
    final ILaunchConfigurationWorkingCopy config = launchType.newInstance(null, label);
    config.setAttribute(IDebugUIConstants.ATTR_PRIVATE, true);
    config.setAttribute(ILaunchConfiguration.ATTR_SOURCE_LOCATOR_ID, "org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector");
    DebugUITools.setLaunchPerspective(launchType, mode, IDebugUIConstants.PERSPECTIVE_DEFAULT);
    final Launch launch = new Launch(config, mode, sourceLocator);

    config.doSave();
    if (vmRunner != null) {
        final VMRunnerConfiguration vmConfig = new VMRunnerConfiguration(classToLaunch, classpath);
        vmConfig.setVMArguments(vmArgs);
        vmConfig.setProgramArguments(prgArgs);
        if (workDir != null) {
            vmConfig.setWorkingDirectory(workDir);
        }
        if (bootClasspath.length == 0) {
            vmConfig.setBootClassPath(null);
        } else {
            vmConfig.setBootClassPath(bootClasspath);
        }
        vmRunner.run(vmConfig, launch, null);
    }
    if (showInDebugger) {
        DebugPlugin.getDefault().getLaunchManager().addLaunch(launch);
    }
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
@Override
protected IDebugTarget createDebugTarget(final VMRunnerConfiguration config,
    final ILaunch launch, final int port, final IProcess process, final VirtualMachine vm)
{
  if (vm != null && vm.version() != null && "1.6".compareTo(vm.version()) > 0)
  {
    System.err.format(JiveLaunchPlugin.VERSION_WARNING, vm.version());
  }
  final IJiveLaunchFactory factory = LaunchFactory.createFactory(launch.getLaunchConfiguration());
  final IJiveProject project = factory.createJiveProject(launch);
  return JiveDebugPlugin.createDebugTarget(launch, vm,
      renderDebugTarget(config.getClassToLaunch(), port), process, true, false,
      config.isResumeOnStartup(), project);
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * @param config
 * @return
 * @throws CoreException
 */
protected String constructProgramString( VMRunnerConfiguration config )
		throws CoreException
{
	File exe = ScriptDebugUtil.findJavaExecutable( fVMInstance.getInstallLocation( ) );
	if ( exe == null )
	{
		throw new Error( "not java exe file" );//$NON-NLS-1$
	}
	return exe.getAbsolutePath( );
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
public void run( VMRunnerConfiguration configuration, ILaunch launch,
		IProgressMonitor monitor ) throws CoreException
{
	delegate.run( configuration, launch, monitor );

	IProcess[] ps = launch.getProcesses( );

	if ( ps != null && ps.length > 0 )
	{
		if ( runScript )
		{
			if ( monitor == null )
			{
				monitor = new NullProgressMonitor( );
			}

			IProgressMonitor subMonitor = new SubProgressMonitor( monitor,
					1 );
			subMonitor.beginTask( "Launching VM...", 1 ); //$NON-NLS-1$

			ReportVMClient vm = new ReportVMClient( );
			ScriptDebugTarget target = new ScriptDebugTarget( launch,
					vm,
					null,
					ps[0],
					config.helper.listenPort,
					config.helper.tempFolder );
			target.setFileName( config.helper.fileName );

			subMonitor.worked( 1 );
			subMonitor.done( );
		}

		ReportLaunchHelper.handleProcessTermination( launch,
				ps[0],
				config.helper.fileName,
				config.helper.tempFolder );
	}
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
protected void addBootClassPathArguments(List arguments,
		VMRunnerConfiguration config) {
	Map map = config.getVMSpecificAttributesMap();
	if (map == null) {
		return;
	}
	String[] prependBootCP = (String[]) map
			.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_PREPEND);
	String[] bootCP = (String[]) map
			.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH);
	String[] appendBootCP = (String[]) map
			.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_APPEND);
	if (prependBootCP == null && bootCP == null && appendBootCP == null) {
		// use old single attribute instead of new attributes if not
		// specified
		bootCP = config.getBootClassPath();
	}
	if (prependBootCP != null) {
		arguments
				.add("-Xbootclasspath/p:" + convertClassPath(prependBootCP)); //$NON-NLS-1$
	}
	if (bootCP != null) {
		if (bootCP.length > 0) {
			arguments.add("-Xbootclasspath:" + convertClassPath(bootCP)); //$NON-NLS-1$
		} else {
			// empty
			arguments.add("-Xbootclasspath:"); //$NON-NLS-1$	
		}
	}
	if (appendBootCP != null) {
		arguments
				.add("-Xbootclasspath/a:" + convertClassPath(appendBootCP)); //$NON-NLS-1$
	}
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
public void run( VMRunnerConfiguration configuration, ILaunch launch,
		IProgressMonitor monitor ) throws CoreException
{
	// donothing now see delegate
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * @see org.eclipse.jdt.launching.IVMRunner#run(VMRunnerConfiguration, ILaunch, IProgressMonitor)
 */
public void run(VMRunnerConfiguration config, ILaunch launch, IProgressMonitor monitor) throws CoreException {
	
	if (monitor == null) {
		monitor = new NullProgressMonitor();
	}
	
	// check for cancellation
	if (monitor.isCanceled()) {
		return;
	}
	
	IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1);
	subMonitor.beginTask(HyLauncherMessages.getString("HyVMRunner.Launching_virtual_machine..._1"), 2); //$NON-NLS-1$
	subMonitor.subTask(HyLauncherMessages.getString("HyVMRunner.Constructing_command_line..._2"));	 //$NON-NLS-1$
	
	File workingDir = getWorkingDir(config);
	String location= getJDKLocation();
	String program = constructProgramString(location, config);
	List arguments= new ArrayList();

	arguments.add(program);
	
	addBootClassPathArguments(arguments, config);

	String[] cp= config.getClassPath();
	if (cp.length > 0) {
		arguments.add("-classpath"); //$NON-NLS-1$
		arguments.add(convertClassPath(cp));
	}
	String[] vmArgs= config.getVMArguments();
	addArguments(vmArgs, arguments);
	
	arguments.add(config.getClassToLaunch());
	
	String[] programArgs= config.getProgramArguments();
	addArguments(programArgs, arguments);
			
	String[] cmdLine= new String[arguments.size()];
	arguments.toArray(cmdLine);
	
	String[] envp= config.getEnvironment();
	
	// check for cancellation
	if (monitor.isCanceled()) {
		return;
	}
	
	subMonitor.worked(1);
	subMonitor.subTask(HyLauncherMessages.getString("HyVMRunner.Starting_virtual_machine..._3")); //$NON-NLS-1$
	
	Process p= exec(cmdLine, workingDir, envp);
	if (p != null) {
		// Log the current launch command to the platform log
		logLaunchCmd(cmdLine, false);
		if (HyLaunchingPlugin.getDefault().isDebugging()
				&& (Platform
						.getDebugOption(HyLaunchingPlugin.DEBUG_LAUNCHING)
						.equalsIgnoreCase("true"))) { //$NON-NLS-1$
			traceLaunchCmd(cmdLine, envp, false);
		}
		
		IProcess process= newProcess(launch, p, renderProcessLabel(cmdLine), getDefaultProcessMap());
		process.setAttribute(IProcess.ATTR_CMDLINE, renderCommandLine(cmdLine));
	}
	subMonitor.worked(1);
	subMonitor.done();
}
 

import org.eclipse.jdt.launching.VMRunnerConfiguration; //导入依赖的package包/类
/**
 * Creates a new debug target for the given virtual machine and system
 * process that is connected on the specified port for the given launch.
 * 
 * @param config
 *            run configuration used to launch the VM
 * @param launch
 *            launch to add the target to
 * @param port
 *            port the VM is connected to
 * @param process
 *            associated system process
 * @param vm
 *            JDI virtual machine
 */
private IDebugTarget createDebugTarget( VMRunnerConfiguration config,
		ILaunch launch, int port, IProcess process, VirtualMachine vm )
{
	String debugName = "Report Running at localhost:" //$NON-NLS-1$
			+ port;

	return JDIDebugModel.newDebugTarget( launch,
			vm,
			debugName,
			process,
			true,
			false,
			config.isResumeOnStartup( ) );
}