Attachment #17091 for bug #82518

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





/* Eclipse Program Launcher
 *
 * This program performs the launching of the eclipse program.
 * with the splash window. If the splash window is to be displayed,
 * the java application will receive two extra arguments:
 *     -showsplash  <splashCommand>
 *
 * When the Java program starts, it should determine if a different
 * version of the splash bitmaps are to be used (uses the feature mechanism).
 * If feature specific bitmaps are to be used, the root directory where
 * those bitmaps reside (e.g., <rootDir>/splash/<bitmapFile>) should be
 * appended (in double quotes) to the splash command. If a directory is
 * not appended, the Eclipse install directory is used. 
 * 
 * The Java program initiates the displaying of the splash window
 * by executing the splash command as follows:
 *
 *     String command = splashCommand;
 *     String directory = getFeatureRootDirectory();
 *     if (directory != null)
 *         command += " \"" + directory + "\"";
 *     Process splashProcess = Runtime.getRuntime().exec( command );
 *
 * When the Java program initialization is complete, the splash window
 * is brought down by destroying the splash process as follows:
 *
 *     splashProcess.destroy();
 *
 * Therefore, when the splash window is visible, there are actually three
 * processes running: 
 * 1) the main launcher process 
 * 2) the Java VM process (Eclipse) 
 * 3) the splash window process.
 *
 * The Java application does not need to know the format of the
 * <splashCommand> argument but the command format is:
 *   <fullPathOfLauncherProgram> -showsplash <timeout>
 *
 * In other words, another eclipse launcher program is run with
 * the arguments "-showsplash" and a timeout value for bringing
 * the splash window down.
 *
 * Similarly, the Java application will receive two other arguments:
 *    -exitdata <exitDataCommand>
 *
 * The <exitDataCommand> argument can be used by the Java application
 * to provide specific exit data to the main launcher process. It accomplishes
 * this by executing the exit data command with an extra argument, which is
 * the exit data.
 *
 *     String command = exitDataCommand;
 *     String data = "Some data";
 *     if (data != null)
 *         command += " \"" + data + "\"";
 *     Process exitDataProcess = Runtime.getRuntime().exec( command );
 *     exitDataProcess.waitFor();
 *
 * The exit data size must not exceed MAX_SHARED_LENGTH which is
 * 16Kb. The exit data process will exit with an exit code
 * different than 0 if that happens.
 *
 * The Java application does not need to know the format of the
 * <exitDataCommand> argument either, but the command format is:
 *   <fullPathOfLauncherProgram> -exitdata <id>
 *
 *   where id is a process independent identifier for the shared
 * memory segment that stores the exit data.
 *
 * The main launcher recognizes the following exit codes from the
 * Java application:
 *
 *    0
 *       - Exit normally.
 *    RESTART_LAST_EC = 23
 *       - restart the java VM again with the same arguments as the previous one.
 *    RESTART_NEW_EC  = 24
 *       - restart the java VM again with the arguments taken from the exit data.
 *       The exit data format is a list of arguments separated by '\n'. The Java
 *       application should build this list using the arguments passed to it on
 *       startup. See below.
 *
 * Additionally, if the Java application exits with an exit code other than the
 * ones above, the main launcher will display an error message with the contents
 * of the exit data. If the exit data is empty, a generic error message is
 * displayed. The generic error message shows the exit code and the arguments
 * passed to the Java application.
 *
 * The options that can be specified by the user to the launcher are:
 *  -vm <javaVM>               the Java VM to be used
 *  -os <opSys>                the operating system being run on
 *  -arch <osArch>             the hardware architecture of the OS: x86, sparc, hp9000
 *  -ws <gui>                  the window system to be used: win32, motif, gtk, ...
 *  -name <name>               application name displayed in error message dialogs.
 *                             Default value is computed from the name of
 *                             the executable - with the first letter capitalized
 *                             name of the executable - with the first letter capitalized
 *                             if possible. e.g. eclipse.exe defaults to the name Eclipse.
 *  <userArgs>                 arguments that are passed along to the Java application
 *                             (i.e, -data <path>, -debug, -console, -consoleLog, etc) 

 *     -os <user or default OS value>
 *     -ws <user or default WS value>
 *     -arch <user or default ARCH value>
 *     [-showsplash <splashCommand>]
 *     [-exitdata <exitDataCommand>]
 *     <userArgs>
 *     -vm <javaVM>
 *     -vmargs <all VM args>

 *     -cp
 *     <startup jar full path>
 *     org.eclipse.core.launcher.Main
 * 
 * If the -nosplash option is given to the launcher, the java
 * application will not receive the "-showsplash" option or its
 * associated command.
 *
 * See "Main.java" for a simple implementation of the Java
 * application.

static _TCHAR*  program     = NULL;       /* full pathname of the program */
static _TCHAR*  homeDir     = NULL;       /* directory where program resides */
static _TCHAR*  javaVM      = NULL;       /* full pathname of the Java VM to run */
static _TCHAR*  sharedID    = NULL;       /* ID for the shared memory */

/* Define the special exit codes returned from Eclipse. */
#define RESTART_LAST_EC    23
#define RESTART_NEW_EC     24

/* Define the maximum time (in seconds) for the splash window to remain visible. */
static _TCHAR*  splashTimeout = _T("600");   /* 10 minutes */

/* Define the required VM arguments (all platforms). */
static _TCHAR*  startupJarName = _T("startup.jar");
static _TCHAR*  startupClassName = _T("org/eclipse/core/launcher/Main");

/* Define error messages. (non-NLS) */
static _TCHAR* exitMsg = _T("JVM terminated. Exit code=%d\n%s");
static _TCHAR* goVMMsg = _T("Start VM: %s\n");
static _TCHAR* pathMsg = _T("%s\n'%s' in your current PATH");
static _TCHAR* showMsg = _T("Could not load splash bitmap:\n%s");
static _TCHAR* shareMsg = _T("No shared data available.");
static _TCHAR* noVMMsg =
_T("A Java Runtime Environment (JRE) or Java Development Kit (JDK)\n\
must be available in order to run %s. No Java virtual machine\n\


static _TCHAR* homeMsg =
_T("The %s executable launcher was unable to locate its \n\
companion %s file (in the same directory as the executable).");

/* Define constants for the options recognized by the launcher. */
#define CONSOLE      _T("-console")

#define DEBUG        _T("-debug")
#define OS           _T("-os")
#define OSARCH       _T("-arch")
#define NOSPLASH     _T("-nosplash")
#define SHOWSPLASH   _T("-showsplash")
#define EXITDATA     _T("-exitdata")
#define VM           _T("-vm")
#define WS           _T("-ws")
#define NAME         _T("-name")

/* Define the variables to receive the option values. */
static int     needConsole   = 0;				/* True: user wants a console	*/
static int     debug         = 0;				/* True: output debugging info	*/
static int     noSplash      = 0;				/* True: do not show splash win	*/
static _TCHAR*  osArg         = _T(DEFAULT_OS);
static _TCHAR*  osArchArg     = _T(DEFAULT_OS_ARCH);
static _TCHAR*  showSplashArg = NULL;			/* showsplash data (main launcher window) */
static _TCHAR*  exitDataArg   = NULL;
static _TCHAR*  vmName        = NULL;     		/* Java VM that the user wants to run */
static _TCHAR*  wsArg         = _T(DEFAULT_WS);	/* the SWT supported GUI to be used */
static _TCHAR*  name          = NULL;			/* program name */		

    { CONSOLE,		NULL,			&needConsole,	0 },
    { CONSOLELOG,	NULL,			&needConsole,	0 },
    { DEBUG,		NULL,			&debug,			0 },
    { NOSPLASH,     NULL,           &noSplash,		1 },
    { OS,			&osArg,			NULL,			2 },
    { OSARCH,		&osArchArg,		NULL,			2 },
    { SHOWSPLASH,   &showSplashArg,	NULL,			2 },
    { EXITDATA,		&exitDataArg,	NULL,			2 },
    { VM,           &vmName,		NULL,			2 },
    { NAME,         &name,			NULL,			2 },
    { WS,			&wsArg,			NULL,			2 } };

static _TCHAR** configArgv = NULL;

/* Local methods */
static int      createUserArgs(int configArgc, _TCHAR **configArgv, int *argc, _TCHAR ***argv);
static void     parseArgs( int* argc, _TCHAR* argv[] );
static _TCHAR** getVMArguments( int argc, _TCHAR* argv[], int *dstArgc );
static void   freeArgList( _TCHAR** data );
static _TCHAR** getVMCommand( int argc, _TCHAR* argv[] );
       _TCHAR*  findCommand( _TCHAR* command );
static _TCHAR*  formatVmCommandMsg( int argc, _TCHAR* argv[] );
static _TCHAR*  getInstallDir( void );
static _TCHAR*  getDefaultOfficialName( void );
static _TCHAR*  getJarFile( void );
static _TCHAR*  getJavaVM( void );

#ifdef _WIN32
#ifdef UNICODE


int main( int argc, _TCHAR* argv[] )
{
	_TCHAR*   splashBitmap;
    _TCHAR*   ch;
    _TCHAR**  vmCommandArgv = NULL;
    _TCHAR*   shippedVM    = NULL;
    _TCHAR*   vmSearchPath = NULL;
    _TCHAR**  vmCommand = NULL;
    _TCHAR**  vmCommandList = NULL;
    _TCHAR**  vmCommandArgs = NULL;
    _TCHAR*   vmCommandMsg = NULL;
    int       vmCommandArgc = 0;
    _TCHAR*   jarFile = NULL;
    _TCHAR*   errorMsg;
    int       exitCode;
    

    }
	
	/* Parse configuration file arguments */
	if (readConfigFile(program, argv[0], &configArgc, &configArgv) == 0)
	{
		parseArgs (&configArgc, configArgv);
	}

	/* Initialize official program name */
	officialName = name != NULL ? _tcsdup( name ) : getDefaultOfficialName();

    /* Initialize the window system. */
    initWindowSystem( &argc, argv, (showSplashArg != NULL) );

    /* Find the home directory where the Eclipse is installed. */
    homeDir = getInstallDir();
    
    /* Initialize the window system. */
    initWindowSystem( &argc, argv, homeDir );

	/* Error if home dir could not be determined */
    if (homeDir == NULL)
    {
        errorMsg = malloc( (_tcslen(homeMsg) + _tcslen(officialName) + _tcslen(startupJarName) + 10) * sizeof(_TCHAR) );
        _stprintf( errorMsg, homeMsg, officialName, startupJarName );
        displayMessage( errorMsg );
        free( errorMsg );
    	exit( 1 );
    }
    
	/* Determine the location of the startup jar file */
	jarFile = getJarFile();

    /* Determine the Java VM to be used */
   	javaVM = getJavaVM();
    {
       	/* If an extra argument was given, use it as the exit data, otherwise clear exit data */
       	data = argc > 1 ? argv[1] : NULL;
       	if (data != NULL && _tcslen( data ) > MAX_SHARED_LENGTH - 1)
       	{
       		exitCode = EINVAL;       		
       	}
       	else {
	        exitCode = setSharedData( exitDataArg, data );
    	}
   	    if (exitCode != 0 && debug) displayMessage( shareMsg );
		exit( exitCode );
    }

    /* If the showsplash option was given */
    if (showSplashArg != NULL)
    {
    	/* If an extra argument was given, pass it as the image to display. */
    	splashBitmap = (argc > 1 ? argv[1] : NULL);
    	exitCode = showSplash( showSplashArg, homeDir, splashBitmap );
    	if (exitCode && debug)
    	{
    		if (splashBitmap == NULL)
    			splashBitmap = homeDir;
        	errorMsg = malloc( (_tcslen(showMsg) + _tcslen(splashBitmap) + 10) * sizeof(_TCHAR) );
        	_stprintf( errorMsg, showMsg, splashBitmap );
        	displayMessage( errorMsg );
        	free( errorMsg );
     	}
    	exit( exitCode );
    }

    /* If the user did not specify a VM to be used */
    if (vmName == NULL)
    {
    	/* Determine which type of VM should be used. */
    	vmName = ((debug || needConsole) ? consoleVM : defaultVM);

        /* Try to find the VM shipped with eclipse. */
        shippedVM = malloc( (_tcslen( homeDir ) + _tcslen( shippedVMDir ) + _tcslen( vmName ) + 10) * sizeof(_TCHAR) );
        _stprintf( shippedVM, _T("%s%s%s"), homeDir, shippedVMDir, vmName );
        javaVM = findCommand( shippedVM );

        /* Format a message to indicate the default VM search path. */
        vmSearchPath = malloc( (_tcslen( pathMsg ) + _tcslen( shippedVM ) + _tcslen( vmName ) + 10) * sizeof(_TCHAR) );
        _stprintf( vmSearchPath, pathMsg, shippedVM, vmName );
        free( shippedVM );
        shippedVM = NULL;
	}

	/* If a Java VM has not been found yet */
	if (javaVM == NULL)
	{
		/* Either verify the VM specified by the user or
		   attempt to find the VM in the user's PATH. */
		javaVM = findCommand( vmName );

		/* If the VM was not found, display a message and exit. */
		if (javaVM == NULL)
		{
			if (vmSearchPath != NULL) vmName = vmSearchPath; /* used default VM searching */
        	errorMsg = malloc( (_tcslen(noVMMsg) + _tcslen(officialName) + _tcslen(vmName) + 10) * sizeof(_TCHAR) );
        	_stprintf( errorMsg, noVMMsg, officialName, vmName );
        	displayMessage( errorMsg );
        	free( errorMsg );
        	exit(1);
		}
	}

    if (createSharedData( &sharedID, MAX_SHARED_LENGTH )) {
        if (debug) {
   			if (debug) displayMessage( shareMsg );
        }
    }

    /* Get the command to start the Java VM. */
    vmCommandArgs = getVMCommand( argc, argv );

    /* Get the arguments to pass to the Java VM. */
    vmCommandArgv = getVMArguments( argc, argv, &vmCommandArgc );
   	vmCommandMsg = formatVmCommandMsg( vmCommandArgc, vmCommandArgv );
   	if (debug) _tprintf( goVMMsg, vmCommandMsg );
  	
    /* Let 'er rip */
   	exitCode = startJavaVM( javaVM, jarFile, startupClassName, vmCommandArgc, vmCommandArgv );
   	if (exitCode != 0)
   	{
   		errorMsg = malloc( (_tcslen(exitMsg) + _tcslen(vmCommandMsg) + 10) * sizeof(_TCHAR) );
	    _stprintf( errorMsg, exitMsg, exitCode, vmCommandMsg );
        displayMessage( errorMsg );
        free( errorMsg );
   	}
                if (getSharedData( sharedID, &data ) == 0) {
			    	if (vmCommandList != NULL) freeArgList( vmCommandList );
                    vmCommand = vmCommandList = parseArgList( data );
                } else {
                	vmCommand = NULL;
                    if (debug) displayMessage( shareMsg );
                }
                break;
			default:
                vmCommand = NULL;
                errorMsg = NULL;
                if (getSharedData( sharedID, &errorMsg ) == 0) {
                    if (_tcslen( errorMsg ) == 0) {
                	    free( errorMsg );
                	    errorMsg = NULL;
                    }
                } else {
                    if (debug) displayMessage( shareMsg );
                }
                if (errorMsg == NULL) {
	                errorMsg = malloc( (_tcslen(exitMsg) + _tcslen(vmCommandMsg) + 10) * sizeof(_TCHAR) );
	                _stprintf( errorMsg, exitMsg, exitCode, vmCommandMsg );
                }
	            displayMessage( errorMsg );
	            free( errorMsg );
                break;
        }
        free( vmCommandMsg );
    }

    /* Cleanup time. */
    free( homeDir );
    free( program );
    if ( jarFile != NULL ) free( jarFile );
    if ( vmCommandMsg != NULL ) free( vmCommandMsg );
    if ( configArgv != NULL ) freeConfig( configArgv );
    if (configArgc > 1) free( argv );
    free( officialName );
    if ( sharedID != NULL ) {
        if (destroySharedData( sharedID ) != 0) {
           if (debug) displayMessage( shareMsg );
        }
        free( sharedID );
    }

    return 0;
}

/* Return 1 if the current Eclipse is the process that starts the java IDE
 * Return 0 if it is an Eclipse used to display a splash screen or to write
 * data to a shared memory segment.
 * The main Eclipse is the only one that reads the eclipse.ini file.
 */
static int isMainEclipse( int argc, _TCHAR **argv )
{
	/* It is the main eclipse if the argument 1 is neither SHOWSPLASH nor EXITDATA */
	if (argc < 2) return 1;
	return (_tcsicmp( argv[1], SHOWSPLASH ) != 0 && _tcsicmp( argv[1], EXITDATA ) != 0);
}

/*
 * Parse arguments of the command.
 */

}

/*
 * Free the memory allocated by parseArgList().
 */
static void freeArgList( _TCHAR** data ) {
	if (data == NULL) return;
	free( data [0] );
	free( data );
}

/*
 * Parse the data into a list of arguments separarted by \n.
 *
 * The list of strings returned by this function must be freed with
 * freeArgList().
 */
static _TCHAR** parseArgList( _TCHAR* data ) {
    int totalArgs = 0, dst = 0, length;
    _TCHAR *ch1, *ch2, **execArg;
    length = _tcslen( data );
    ch1 = ch2 = data;
    while ((ch2 = _tcschr( ch1, _T('\n') )) != NULL) {
    	totalArgs++;
    	ch1 = ch2 + 1;
    }
    if (ch1 != data + length) totalArgs++;
    execArg = malloc( (totalArgs + 1) * sizeof( _TCHAR* ) );
    ch1 = ch2 = data;
    while ((ch2 = _tcschr( ch1, _T('\n') )) != NULL) {
    	execArg[ dst++ ] = ch1;
    	ch2[ 0 ] = _T('\0');
    	ch1 = ch2 + 1;
    }
    if (ch1 != data + length) execArg[ dst++ ] = ch1;
    execArg[ dst++ ] = NULL;
    return execArg;
}

/*
 * Find the absolute pathname to where a command resides.
 *
 * The string returned by the function must be freed.

}

/*
 * Get the arguments to pass to the Java VM.
 *
 * Memory allocated by this function is assumed to be
 * deallocated when the program terminates.

 * passed directly from the main( argv ) array so they
 * should not be deallocated.
 */
static _TCHAR** getVMArguments( int argc, _TCHAR* argv[], int *dstArgc )
{
	_TCHAR** defVMarg;
    int     nDefVMarg = 0;
    int     nReqVMarg = 0;
    int     nUserVMarg = 0;
    int     totalArgs;
    _TCHAR** execArg;
    _TCHAR*  jarFile = NULL;
    _TCHAR*  splashExec;
	_TCHAR*  exitDataExec;
    int     src;
    int     dst;


 			nUserVMarg++;
 	}

    /* Allocate the arg list for the JVM
     *  (userVMargs + defaultVMargs + OS <os> + WS <ws> + ARCH <arch>
     *      + argv[] + NULL)
 		nDefVMarg++;

 	/* Calculate the number of required VM arguments. */
 	while (reqVMarg[ nReqVMarg ] != NULL)
 		nReqVMarg++;

    /* Allocate the arg list for the exec call.
     *  (VM + userVMargs + defaultVMargs + requiredVMargs + OS <os> + WS <ws> + ARCH <arch>
     *      + SHOWSPLASH <cmd> + EXITDATA <cmd> + argv[] + VM + <vm> + VMARGS + userVMargs + defaultVMargs + requiredVMargs
     *      + NULL)
     */
    totalArgs  = nUserVMarg + 2 + 2 + 2 + 2 + 2 + argc + 2 + 1;
	execArg = malloc( totalArgs * sizeof( _TCHAR* ) );
    dst = 0;
    execArg[ dst++ ] = javaVM;

    /* For each user VM arg */
   	for (src = 0; src < nUserVMarg; src++)
    	execArg[ dst++ ] = userVMarg[ src ];
    	for (src = 0; src < nUserVMarg; src++)
	    	execArg[ dst++ ] = userVMarg[ src ];
	}
	else
	{
    	for (src = 0; src < nDefVMarg; src++)
	    	execArg[ dst++ ] = defVMarg[ src ];
	}

    /* For each required VM arg */
	jarFile = malloc( (_tcslen( homeDir ) + _tcslen( startupJarName ) + 1) * sizeof( _TCHAR ) );
    jarFile = _tcscpy( jarFile, homeDir );
  	jarFile = _tcscat( jarFile, startupJarName );
	for (src = 0; src < nReqVMarg; src++)
    {
    	/* If the argument is not the startup jar, use it as is. */
     	if (_tcscmp( reqVMarg[ src ], startupJarName ) != 0)
     	{
	        execArg[ dst++ ] = reqVMarg[ src ];
	    }

	    /* else use the absolute path of the jar file. */
	    else
	    {
	        execArg[ dst++ ] = jarFile;
	    }
    }

	/* Append the required options. */
    execArg[ dst++ ] = OS;

    execArg[ dst++ ] = OSARCH;
    execArg[ dst++ ] = osArchArg;

	/* Append the show splash window command, if defined. */
    if (!noSplash)
    {
        execArg[ dst++ ] = SHOWSPLASH;
		splashExec = malloc( (_tcslen( program ) + _tcslen(SHOWSPLASH) + _tcslen( splashTimeout ) + 3) * sizeof(_TCHAR) );
		_stprintf( splashExec, _T("%s %s %s"), program, SHOWSPLASH, splashTimeout );
	    execArg[ dst++ ] = splashExec;
    }

	/* Append the exit data command. */
	if (sharedID) {
	    execArg[ dst++ ] = EXITDATA;
	    exitDataExec = malloc( (_tcslen( program ) + _tcslen( EXITDATA ) + _tcslen( sharedID ) + 3) * sizeof(_TCHAR) );
	    _stprintf( exitDataExec, _T("%s %s %s"), program, EXITDATA, sharedID );
	    execArg[ dst++ ] = exitDataExec;
	}

	/* Append the remaining user defined arguments. */
    for (src = 1; src < argc; src++)
    {
        execArg[ dst++ ] = argv[ src ];
    }

    /* Append VM and VMARGS to be able to relaunch using exit data. */
	execArg[ dst++ ] = VM;
	execArg[ dst++ ] = javaVM;
    execArg[ dst++ ] = VMARGS;
    /* If the user specified "-vmargs", add them instead of the default VM args. */
    if (userVMarg != NULL)
    {
    	for (src = 0; src < nUserVMarg; src++)
	    	execArg[ dst++ ] = userVMarg[ src ];
	}
	else
	{
    	for (src = 0; src < nDefVMarg; src++)
	    	execArg[ dst++ ] = defVMarg[ src ];
	}
    /* For each required VM arg */
    for (src = 0; src < nReqVMarg; src++)
    {
    	/* If the argument is not the startup jar, use it as is. */
     	if (_tcscmp( reqVMarg[ src ], startupJarName ) != 0)
     	{
	        execArg[ dst++ ] = reqVMarg[ src ];
	    }

	    /* else use the absolute path of the jar file. */
	    else
	    {
	        execArg[ dst++ ] = jarFile;
	    }
    }

    execArg[ dst++ ] = NULL;

	*dstArgc = dst;
	return execArg;
 }


  * that can be used in displaying error messages. The string returned from this
  * method is probably not NLS compliant and must be deallocated by the caller.
  */
static _TCHAR* formatVmCommandMsg( int argc, _TCHAR* argv[] )
{
	int   index;
    int   length;


	/* Determine the length of the message buffer. */
	length = 0;
	for (index = 0; index < argc; index++)
	{
		length += _tcslen(argv[index]) + 1;
	}
	message = malloc( (length + 5) * sizeof(_TCHAR) );
	

	   on a new line. Otherwise, the Motif MessageBox does not automatically wrap
	   the messages and the message window can extend beyond both sides of the display. */
	ch = message;
	for (index = 0; index < argc; index++)
	{
		if (argv[index][0] == _T('-') && *(ch-1) == _T(' '))
			*(ch-1) = _T('\n');
		_tcscpy( ch, argv[index] );
		ch += _tcslen( argv[index] );
		*ch++ = _T(' ');
	}
	*ch = _T('\0');

 * Determine the default official application name
 *
 * This function provides the default application name that appears in a variety of
 * places such as: title of message dialog that shows up in Windows task bar.
 * that shows up in Windows task bar.
 * It is computed from the name of the launcher executable and
 * by capitalizing the first letter. e.g. "c:/ide/eclipse.exe" provides
 * a default name of "Eclipse".
 */
static _TCHAR* getDefaultOfficialName( void )
{
	_TCHAR *ch = NULL;
	

 * contain the startup JAR file and the executable must be either in the
 * install directory or in a subdirectory.
 */
static _TCHAR* getInstallDir( void )
{
	_TCHAR*  ch;
	_TCHAR*  installDir;

    return NULL;
}

/* 
 * Determine the Jar file name. Caller must free pointer returned.
 */
static _TCHAR* getJarFile( void )
{
	_TCHAR* jarFile = malloc( (_tcslen( homeDir ) + _tcslen( startupJarName ) + 1) * sizeof( _TCHAR ) );
    jarFile = _tcscpy( jarFile, homeDir );
  	jarFile = _tcscat( jarFile, startupJarName );
  	return jarFile;
}

/*
 * Determine the Java VM
 */
static _TCHAR* getJavaVM( void )
{
	_TCHAR* shippedVM = NULL;
	_TCHAR* javaVM = NULL;
    _TCHAR* vmSearchPath = NULL;
    _TCHAR* errorMsg = NULL;
    	
    /* If the user did not specify a VM to be used */
    if (vmName == NULL)
    {
    	/* Determine which type of VM should be used. */
    	vmName = ((debug || needConsole) ? consoleVM : defaultVM);

        /* Try to find the VM shipped with eclipse. */
        shippedVM = malloc( (_tcslen( homeDir ) + _tcslen( shippedVMDir ) + _tcslen( vmName ) + 10) * sizeof(_TCHAR) );
        _stprintf( shippedVM, _T("%s%s%s"), homeDir, shippedVMDir, vmName );
        javaVM = findCommand( shippedVM );

        /* Format a message to indicate the default VM search path. */
        vmSearchPath = malloc( (_tcslen( pathMsg ) + _tcslen( shippedVM ) + _tcslen( vmName ) + 10) * sizeof(_TCHAR) );
        _stprintf( vmSearchPath, pathMsg, shippedVM, vmName );
        free( shippedVM );
        shippedVM = NULL;
	}

	/* If a Java VM has not been found yet */
	if (javaVM == NULL)
	{
		/* Either verify the VM specified by the user or
		   attempt to find the VM in the user's PATH. */
		javaVM = findCommand( vmName );

		/* If the VM was not found, display a message and exit. */
		if (javaVM == NULL)
		{
			if (vmSearchPath != NULL) vmName = vmSearchPath; /* used default VM searching */
        	errorMsg = malloc( (_tcslen(noVMMsg) + _tcslen(officialName) + _tcslen(vmName) + 10) * sizeof(_TCHAR) );
        	_stprintf( errorMsg, noVMMsg, officialName, vmName );
        	displayMessage( errorMsg );
        	free( errorMsg );
        	exit(1);
		}
	}
    if ( vmSearchPath != NULL ) free( vmSearchPath );
	return javaVM;
}




 *
 * This method is called after the command line arguments have been
 * parsed. Its purpose is to initialize the corresponding window system.
 *
 * The showSplash flag indicates the splash window will be displayed by
 * this process (e.g., value will be zero for the main launcher).
 */
extern void initWindowSystem( int* argc, _TCHAR* argv[], int showSplash );


/** Show the Splash Window
 *
 * This method is called to display the actual splash window. It will only
 * be called by the splash window process and not the main launcher process.
 * The splash ID passed corresponds to the string returned from initWindowSystem().
 * If possible, this ID should be used to communicate some piece of data back
 * to the main launcher program for two reasons:
 * 1) to detect when the splash window process terminates
 * 2) to terminate the splash window process should the JVM terminate before it
 *    completes its initialization.
 *
 * Two parameters are passed: the install home directory and a specific bitmap image
 * file for a feature. The feature's image file is tried first and if it cannot be
 * displayed, the images from the install directory are used.
 *
 * Return (exit code):
 * 0        - success
 * non-zero - could not find a splash image to display
 */
extern int showSplash( _TCHAR* splashId, _TCHAR* homeDir, _TCHAR* featureImage );


/** Get List of Java VM Arguments
 *
 * A given Java VM might require a special set of arguments in order to
 * optimize its performance. This method returns a NULL terminated array
 * of strings, where each string is a separate VM argument.
 */
extern void initWindowSystem( int* argc, _TCHAR* argv[], _TCHAR *homeDir );


/** Start the Java VM and Wait For It to Terminate
 *
 * This method is responsible for starting the Java VM and for
 * detecting its termination. The resulting JVM exit code should
 * be returned to the main launcher, which will display a message if
 * the termination was not normal.
 */
extern int startJavaVM( _TCHAR* javaVM, _TCHAR* jarFile, _TCHAR* className, int argc, _TCHAR* argv[] );

#endif /* ECLIPSE_OS_H */


Lines 8-20 Link Here

(-)win32/eclipse.rc (-2 / +4 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	#define ECLIPSE_ICON 401	12	#define ECLIPSE_ICON 401
		13	#define CREATEPROCESS_MANIFEST_RESOURCE_ID 1
		14	#define RT_MANIFEST 24
13		15
14	#include "windows.h"	16	#include "windows.h"
15	#include "winver.h"	17	#include "winver.h"
16		18
17
18	ECLIPSE_ICON ICON DISCARDABLE "eclipse.ico"	19	ECLIPSE_ICON ICON DISCARDABLE "eclipse.ico"
		20	CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "eclipse.exe.manifest"
19		21
20		22




/* Global Variables */
_TCHAR   dirSeparator  = _T('\\');
_TCHAR   pathSeparator = _T(';');
#include <jni.h>       /* java native interface */
_TCHAR*  consoleVM     = _T("jni.dll");
_TCHAR*  defaultVM     = _T("jni.dll");
_TCHAR*  shippedVMDir  = _T("jre\\bin\\client\\");
/* Define the window system arguments for the Java VM. */
static _TCHAR*  argVM[] = { NULL };

/* Define local variables for the main window. */
static HWND    topWindow  = 0;
static WNDPROC oldProc;

/* Define local variables for running the JVM and detecting its exit. */
static int     jvmProcess     = 0;
static int     jvmExitCode    = 0;
static int     jvmExitTimeout = 100;
static int     jvmExitTimerId = 99;

/* Define local variables for handling the splash window and its image. */
static _TCHAR*   loResSplash = _T("splash_basic.bmp");
static _TCHAR*   hiResSplash = _T("splash_full.bmp");
static int      splashTimerId = 88;
#define LO_RES_DEPTH 8

/* Local functions */
static void CALLBACK  detectJvmExit( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime );
static HBITMAP        loadSplashImage(_TCHAR *baseDir, _TCHAR *fileName);
static void CALLBACK  splashTimeout( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime );
static LRESULT WINAPI WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);


/* Display a Message */
void displayMessage( _TCHAR* message )
{
	MessageBox( NULL, message, officialName, MB_OK );
}

/* Initialize Window System

 * Return the window handle as the data for the splash command.
 *
 */
void initWindowSystem( int* argc, _TCHAR* argv[], _TCHAR *homeDir )
{
    /* Create a window that has no decorations. */
    topWindow = CreateWindowEx (0,
		_T("STATIC"),
		officialName,
		SS_BITMAP | WS_POPUP,
		0,
		0,
		0,
		0,
		NULL,
		NULL,
		GetModuleHandle (NULL),
		NULL);
    oldProc = (WNDPROC) GetWindowLong (topWindow, GWL_WNDPROC);
    SetWindowLong (topWindow, GWL_WNDPROC, (LONG) WndProc);
}


/* Show the Splash Window
 *
 * Open the bitmap, insert into the splash window and display it.
 *
 */
int showSplash( _TCHAR* timeoutString, _TCHAR* homeDir, _TCHAR* featureImage )
{
	int     timeout = 0;
    RECT    rect;
    HBITMAP hBitmap = 0;
    HDC     hDC;
    int     depth;
    int     x, y;
    int     width, height;
    MSG     msg;

	/* Determine the splash timeout value (in seconds). */
	if (timeoutString != NULL && _tcslen( timeoutString ) > 0)
	{
	    _stscanf( timeoutString, _T("%d"), &timeout );
	}

    /* Load the bitmap for the feature. */
    hDC = GetDC( NULL);
    depth = GetDeviceCaps( hDC, BITSPIXEL ) * GetDeviceCaps( hDC, PLANES);
    ReleaseDC(NULL, hDC);
    if (featureImage != NULL)
    	hBitmap = LoadImage(NULL, featureImage, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

    /* If the bitmap could not be found, try again using the install directory. */
    if (hBitmap == 0)
    	hBitmap = loadSplashImage( homeDir, depth <= LO_RES_DEPTH ? loResSplash : hiResSplash );

    /* If the bitmap could not be found, return an error. */
    if (hBitmap == 0)
    	return ERROR_FILE_NOT_FOUND;

	/* Load the bitmap into the splash popup window. */
    SendMessage( topWindow, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM) hBitmap );

    /* Centre the splash window and display it. */
    GetWindowRect (topWindow, &rect);
    width = GetSystemMetrics (SM_CXSCREEN);
    height = GetSystemMetrics (SM_CYSCREEN);
    x = (width - (rect.right - rect.left)) / 2;
    y = (height - (rect.bottom - rect.top)) / 2;
    SetWindowPos (topWindow, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
    ShowWindow( topWindow, SW_SHOW );
    BringWindowToTop( topWindow );

	/* If a timeout for the splash window was given */
	if (timeout != 0)
	{
		/* Add a timeout (in milliseconds) to bring down the splash screen. */
        SetTimer( topWindow, splashTimerId, (timeout * 1000), splashTimeout );
	}

    /* Process messages until the splash window is closed or process is terminated. */
   	while (GetMessage( &msg, NULL, 0, 0 ))
   	{
		TranslateMessage( &msg );
		DispatchMessage( &msg );
	}

	return 0;
}

static jstring newJavaString(JNIEnv *env, char *s)
{    
	int len;
	jclass cls;
	jmethodID mid;
	jbyteArray ary;
	jstring str = 0;
	
	if (s == NULL)
		return 0;
	len = strlen(s);
	ary = (*env)->NewByteArray(env, len);
	if (ary != 0)
	{
		(*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
		if (!(*env)->ExceptionOccurred(env)) {
			cls = (*env)->FindClass(env, "java/lang/String");
			mid = (*env)->GetMethodID(env, cls, "<init>",  "([B)V");
		    str = (*env)->NewObject(env, cls, mid, ary);
		}
		(*env)->DeleteLocalRef(env, ary);
	} 
	return str;
}

static jobjectArray newJavaStringArray(JNIEnv *env, char **argv, int argc)
{
    jarray cls;
    jarray ary;
    int i;

    cls = (*env)->FindClass(env, "java/lang/String");
    ary = (*env)->NewObjectArray(env, argc, cls, 0);
    for (i = 0; i < argc; i++) {
		jstring str = newJavaString(env, *argv++);
		(*env)->SetObjectArrayElement(env, ary, i, str);
		(*env)->DeleteLocalRef(env, str);
    }
    return ary;
}

/**
 * Convert a wide string to a narrow one suitable for use in JNI.
 * Caller must free the null terminated string returned.
 */
static char *toNarrow(_TCHAR* src)
{
#ifdef UNICODE
	int byteCount = WideCharToMultiByte (CP_ACP, 0, (wchar_t *)src, -1, NULL, 0, NULL, NULL);
	char *dest = malloc(byteCount+1);
	dest[byteCount] = 0;
	WideCharToMultiByte (CP_ACP, 0, (wchar_t *)src, -1, dest, byteCount, NULL, NULL);
	return dest;
#else
	return _tcsdup(src);
#endif
}


/* Start the Java VM
 *
 * This method is called to start the Java virtual machine and to wait until it
 * terminates. The function returns the exit code from the JVM.
 */
int startJavaVM( _TCHAR* javaVM, _TCHAR* jarFile, _TCHAR* className, int argc, _TCHAR* argv[] )
{
	HINSTANCE jvmLibrary; // Library handle
	
	//displayMessage(_T("jni invoke\n"));
	jvmLibrary = LoadLibrary(javaVM);
	/* If the child library (JVM) would not start */
	if (jvmLibrary == 0)
	* double quotes in the command line. 
	*/
	length = 0;
	for (index = 0; args[index] != NULL; index++)
	{
		/* String length plus space character */
		length += _tcslen( args[ index ] ) + 1;
		/* Quotes */
		if (_tcschr( args[ index ], _T(' ') ) != NULL) length += 2;
	}
	commandLine = ch = malloc ( (length + 1) * sizeof(_TCHAR) );
	for (index = 0; args[index] != NULL; index++)
	{
		space = _tcschr( args[ index ], _T(' '));
		if (space != NULL) *ch++ = _T('\"');
		_tcscpy( ch, args[index] );
		ch += _tcslen( args[index] );
		if (space != NULL) *ch++ = _T('\"');
		*ch++ = _T(' ');
	}
	*ch = _T('\0');

	/*
	* Start the Java virtual machine. Use CreateProcess() instead of spawnv()
	* otherwise the arguments cannot be freed since spawnv() segments fault.
	*/
	{
	STARTUPINFO    si;
    PROCESS_INFORMATION  pi;
    GetStartupInfo(&si);
    if (CreateProcess(NULL, commandLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
    	CloseHandle( pi.hThread );
    	jvmProcess = (int)pi.hProcess;
    }    
	}

	free( commandLine );

	/* If the child process (JVM) would not start */
	if (jvmProcess == -1)
	{
		/* Return the error number. */
		displayMessage(_T("child lib would not start\n"));
		jvmExitCode = errno;
		jvmProcess  = 0;
	}

	/* else */
	else
	{
		/* Get the function addresses */
		//displayMessage(_T("get function address\n"));
		jint (JNICALL *createJavaVM)(JavaVM **pvm, JNIEnv **env, void *args);
	    createJavaVM = (void *)GetProcAddress(jvmLibrary, "JNI_CreateJavaVM");
	    if (createJavaVM == 0)
		{
			/* Return the error number. */
			displayMessage(_T("createJavaVM or getDefaultJavaVMInitArgs address not found\n"));
			jvmExitCode = errno;
		}
		else
		{
			JavaVM *jvm;       /* denotes a Java VM */
			JNIEnv *env;       /* pointer to native method interface */
			int i;
			char *narrowJarFile = toNarrow(jarFile);
			//displayMessage(jarFile);
			char *narrowClassName = toNarrow(className);
			//displayMessage(className);
			
			// documented here: http://java.sun.com/j2se/1.4.2/docs/guide/jni/jni-12.html#JNI_CreateJavaVM
			//displayMessage(_T("pack arguments\n"));
			JavaVMInitArgs  vm_args = {0};
			JavaVMOption *options = malloc((1 + argc) * sizeof(JavaVMOption));
			memset(options, 0, (1 + argc) * sizeof(JavaVMOption));
			static char* classPath = "-Djava.class.path=";
			options[0].optionString = malloc(strlen(classPath) + strlen(narrowJarFile) + 1);
			strcpy(options[0].optionString, classPath);
			strcat(options[0].optionString, narrowJarFile);
			for (i = 0; i < argc; i++) {
			   options[i+1].optionString = toNarrow(argv[i]);
			}
			vm_args.version = JNI_VERSION_1_4;
			vm_args.options = options;
			vm_args.nOptions = 1 + argc;
			vm_args.ignoreUnrecognized = JNI_TRUE;
			
			/* load and initialize a Java VM, return a JNI interface pointer in env */
			//displayMessage(_T("about to create vm\n"));
			(*createJavaVM)(&jvm, &env, &vm_args);
			if (jvm == NULL)
			{
				displayMessage(_T("createJavaVM failed\n"));
				jvmExitCode = errno;
			}
			else
			{
				/* invoke the Main.test method using the JNI */
				//displayMessage(_T("about to FindClass\n"));
				jclass cls = (*env)->FindClass(env, narrowClassName);
				if (cls == NULL)
				{
					displayMessage(_T("FindClass failed\n"));
					jvmExitCode = errno;
				}
				else
				{
					//displayMessage(_T("about to GetStaticMethodID\n"));
					jmethodID mid = (*env)->GetStaticMethodID(env, cls, "main", "([Ljava/lang/String;)V");
					if (mid == NULL)
					{
						displayMessage(_T("GetStaticMethodID failed\n"));
						jvmExitCode = errno;
					}
					else
					{
						//displayMessage(_T("about to call main\n"));
						(*env)->CallStaticVoidMethod(env, cls, mid,
							newJavaStringArray(env, NULL, 0));
						// shouldn't get here, but just in case...
						//displayMessage(_T("main complete, destroying vm\n"));
						/* We are done. */
						(*jvm)->DestroyJavaVM(jvm);
					}
				}
			}
			for (i = 0; i < vm_args.nOptions; i++)
			   free(options[i].optionString);
			free(options);
			free(narrowJarFile);
			free(narrowClassName);
		}

		/* Kill the timer. */
        KillTimer( topWindow, jvmExitTimerId );
	}

	/* Return the exit code from the JVM. */
	return jvmExitCode;
}

/* Local functions */

/* Detect JVM Process Termination */
static void CALLBACK detectJvmExit( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime )
{
    DWORD   exitCode;

    /* If the JVM process has terminated */
    if (!GetExitCodeProcess( (HANDLE)jvmProcess, &exitCode ) ||
    		 exitCode != STILL_ACTIVE)
    {
    	/* Save the JVM exit code. This should cause the loop in startJavaVM() to exit. */
        jvmExitCode = exitCode;
        jvmProcess = 0;
    }
}

/* Splash Timeout */
static void CALLBACK splashTimeout( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime )
{
	/* Kill the timer. */
    KillTimer( topWindow, id );
	PostMessage( topWindow, WM_QUIT, 0, 0 );
}


/* Load the splash image depending on the current locale.
 *
 * This is the search sequence for an USA english locale:
 *
 *     1 - <homeDir>splash\en_US\<fileName>
 *     2 - <homeDir>splash\en\<fileName>
 *     3 - <homeDir>splash\<fileName>
 *
 * Returns an HBITMAP or NULL if the file can not be found.
 */
static HBITMAP loadSplashImage(_TCHAR* baseDir, _TCHAR* fileName)
{
	HBITMAP hBitmap = NULL;
	LCID locale;
	_TCHAR lang[4] = {0};
	_TCHAR country[4] = {0};
	_TCHAR *splashFile;

	locale = GetThreadLocale ();
	GetLocaleInfo(locale, LOCALE_SISO639LANGNAME, lang, 4);
	GetLocaleInfo(locale, LOCALE_SISO3166CTRYNAME, country, 4);

	splashFile = malloc ( (_tcslen( baseDir ) + 256) * sizeof(_TCHAR) );

    _stprintf( splashFile, _T("%s\\splash\\%s_%s\\%s"), baseDir, lang, country, fileName );
	hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

	if (hBitmap == NULL)
	{
		_stprintf( splashFile, _T("%s\\splash\\%s\\%s"), baseDir, lang, fileName );
		hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
	}

	if (hBitmap == NULL)
	{
		_stprintf( splashFile, _T("%s\\splash\\%s"), baseDir, fileName );
		hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
	}

	free (splashFile);
	return hBitmap;
}


/* Window Procedure for the Spash window.
 *
 * A special WndProc is needed to return the proper vlaue for WM_NCHITTEST.
 * It must also detect the message from the splash window process.
 */
static LRESULT WINAPI WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
		case WM_NCHITTEST: return HTCLIENT;
		case WM_CLOSE:
	    	PostQuitMessage(  0 );
	    	break;
	}
	return CallWindowProc (oldProc, hwnd, uMsg, wParam, lParam);
}


Lines 34-39 Link Here

(-)win32/make_mingw.mak (-1 / +4 lines)
34	RC = $(TDIR)/i586-pc-cygwin-windres	34	RC = $(TDIR)/i586-pc-cygwin-windres
35	SYSINC = -isystem $(TDIR)/../include/mingw	35	SYSINC = -isystem $(TDIR)/../include/mingw
36	endif	36	endif
		37	JDK_HOME="C:\Program Files\Java\jdk1.5.0_01"
		38	JNIINC = -I$(JDK_HOME)/include/ -I$(JDK_HOME)/include/win32
		39	#CDEBUG = -g
37		40
38	ifeq ($(CC),)	41	ifeq ($(CC),)
39	$(error Unable to find $(CCVER)-pc-cygwin-gcc)	42	$(error Unable to find $(CCVER)-pc-cygwin-gcc)
Lines 48-54 Link Here
48	EXEC = $(PROGRAM_OUTPUT)	51	EXEC = $(PROGRAM_OUTPUT)
49	DEBUG = $(CDEBUG)	52	DEBUG = $(CDEBUG)
50	CFLAGS = -O -s -Wall \	53	CFLAGS = -O -s -Wall \
51	-I. $(SYSINC) \	54	-I. $(JNIINC) $(SYSINC) \
52	-D_WIN32 \	55	-D_WIN32 \
53	-DWIN32_LEAN_AND_MEAN \	56	-DWIN32_LEAN_AND_MEAN \
54	-mno-cygwin	57	-mno-cygwin

Added Link Here

(-)win32/eclipse.exe.manifest (+10 lines)
1	<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
2	<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
3	<assemblyIdentity version="1.0.0.0" processorArchitecture="X86" name="IBM.Eclipse.eclipse" type="win32"/>
4	<description>Eclipse IDE</description>
5	<dependency>
6	<dependentAssembly>
7	<assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="X86" publicKeyToken="6595b64144ccf1df" language="*"/>
8	</dependentAssembly>
9	</dependency>
10	</assembly>

Return to bug 82518

Lines 60-111 Link Here

(-)eclipseOS.h (-38 / +3 lines)
60	*	60	*
61	* This method is called after the command line arguments have been	61	* This method is called after the command line arguments have been
62	* parsed. Its purpose is to initialize the corresponding window system.	62	* parsed. Its purpose is to initialize the corresponding window system.
63	*
64	* The showSplash flag indicates the splash window will be displayed by
65	* this process (e.g., value will be zero for the main launcher).
66	*/
67	extern void initWindowSystem( int* argc, _TCHAR* argv[], int showSplash );
68
69
70	/** Show the Splash Window
71	*
72	* This method is called to display the actual splash window. It will only
73	* be called by the splash window process and not the main launcher process.
74	* The splash ID passed corresponds to the string returned from initWindowSystem().
75	* If possible, this ID should be used to communicate some piece of data back
76	* to the main launcher program for two reasons:
77	* 1) to detect when the splash window process terminates
78	* 2) to terminate the splash window process should the JVM terminate before it
79	* completes its initialization.
80	*
81	* Two parameters are passed: the install home directory and a specific bitmap image
82	* file for a feature. The feature's image file is tried first and if it cannot be
83	* displayed, the images from the install directory are used.
84	*
85	* Return (exit code):
86	* 0 - success
87	* non-zero - could not find a splash image to display
88	*/
89	extern int showSplash( _TCHAR* splashId, _TCHAR* homeDir, _TCHAR* featureImage );
90
91
92	/** Get List of Java VM Arguments
93	*
94	* A given Java VM might require a special set of arguments in order to
95	* optimize its performance. This method returns a NULL terminated array
96	* of strings, where each string is a separate VM argument.
97	*/	63	*/
98	extern _TCHAR** getArgVM( _TCHAR *vm );	64	extern void initWindowSystem( int* argc, _TCHAR* argv[], _TCHAR *homeDir );
99
100		65
101	/* Start the Java VM and Wait For It to Terminate	66	/** Start the Java VM and Wait For It to Terminate
102	*	67	*
103	* This method is responsible for starting the Java VM and for	68	* This method is responsible for starting the Java VM and for
104	* detecting its termination. The resulting JVM exit code should	69	* detecting its termination. The resulting JVM exit code should
105	* be returned to the main launcher, which will display a message if	70	* be returned to the main launcher, which will display a message if
106	* the termination was not normal.	71	* the termination was not normal.
107	*/	72	*/
108	extern int startJavaVM( _TCHAR* args[] );	73	extern int startJavaVM( _TCHAR* javaVM, _TCHAR* jarFile, _TCHAR* className, int argc, _TCHAR* argv[] );
109		74
110	#endif /* ECLIPSE_OS_H */	75	#endif /* ECLIPSE_OS_H */
111		76

Lines 25-64 Link Here

(-)win32/eclipseWin.c (-268 / +149 lines)
25	/* Global Variables */	25	/* Global Variables */
26	_TCHAR dirSeparator = _T('\\');	26	_TCHAR dirSeparator = _T('\\');
27	_TCHAR pathSeparator = _T(';');	27	_TCHAR pathSeparator = _T(';');
28	_TCHAR* consoleVM = _T("java.exe");	28	#include <jni.h> /* java native interface */
29	_TCHAR* defaultVM = _T("javaw.exe");	29	_TCHAR* consoleVM = _T("jni.dll");
30	_TCHAR* shippedVMDir = _T("jre\\bin\\");	30	_TCHAR* defaultVM = _T("jni.dll");
31		31	_TCHAR* shippedVMDir = _T("jre\\bin\\client\\");
32	/* Define the window system arguments for the Java VM. */
33	static _TCHAR* argVM[] = { NULL };
34
35	/* Define local variables for the main window. */
36	static HWND topWindow = 0;
37	static WNDPROC oldProc;
38		32
39	/* Define local variables for running the JVM and detecting its exit. */	33	/* Define local variables for running the JVM and detecting its exit. */
40	static int jvmProcess = 0;
41	static int jvmExitCode = 0;	34	static int jvmExitCode = 0;
42	static int jvmExitTimeout = 100;
43	static int jvmExitTimerId = 99;
44
45	/* Define local variables for handling the splash window and its image. */
46	static _TCHAR* loResSplash = _T("splash_basic.bmp");
47	static _TCHAR* hiResSplash = _T("splash_full.bmp");
48	static int splashTimerId = 88;
49	#define LO_RES_DEPTH 8
50
51	/* Local functions */
52	static void CALLBACK detectJvmExit( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime );
53	static HBITMAP loadSplashImage(_TCHAR baseDir, _TCHAR fileName);
54	static void CALLBACK splashTimeout( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime );
55	static LRESULT WINAPI WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
56
57		35
58	/* Display a Message */	36	/* Display a Message */
59	void displayMessage( _TCHAR* message )	37	void displayMessage( _TCHAR* message )
60	{	38	{
61	MessageBox( topWindow, message, officialName, MB_OK );	39	MessageBox( NULL, message, officialName, MB_OK );
62	}	40	}
63		41
64	/* Initialize Window System	42	/* Initialize Window System
Lines 68-337 Link Here
68	* Return the window handle as the data for the splash command.	46	* Return the window handle as the data for the splash command.
69	*	47	*
70	*/	48	*/
71	void initWindowSystem( int* pArgc, _TCHAR* argv[], int showSplash )	49	void initWindowSystem( int* argc, _TCHAR* argv[], _TCHAR *homeDir )
72	{
73	/* Create a window that has no decorations. */
74	topWindow = CreateWindowEx (0,
75	_T("STATIC"),
76	officialName,
77	SS_BITMAP \| WS_POPUP,
78	0,
79	0,
80	0,
81	0,
82	NULL,
83	NULL,
84	GetModuleHandle (NULL),
85	NULL);
86	oldProc = (WNDPROC) GetWindowLong (topWindow, GWL_WNDPROC);
87	SetWindowLong (topWindow, GWL_WNDPROC, (LONG) WndProc);
88	}
89
90
91	/* Show the Splash Window
92	*
93	* Open the bitmap, insert into the splash window and display it.
94	*
95	*/
96	int showSplash( _TCHAR* timeoutString, _TCHAR* homeDir, _TCHAR* featureImage )
97	{	50	{
98	int timeout = 0;
99	RECT rect;
100	HBITMAP hBitmap = 0;
101	HDC hDC;
102	int depth;
103	int x, y;
104	int width, height;
105	MSG msg;
106
107	/* Determine the splash timeout value (in seconds). */
108	if (timeoutString != NULL && _tcslen( timeoutString ) > 0)
109	{
110	_stscanf( timeoutString, _T("%d"), &timeout );
111	}
112
113	/* Load the bitmap for the feature. */
114	hDC = GetDC( NULL);
115	depth = GetDeviceCaps( hDC, BITSPIXEL ) * GetDeviceCaps( hDC, PLANES);
116	ReleaseDC(NULL, hDC);
117	if (featureImage != NULL)
118	hBitmap = LoadImage(NULL, featureImage, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
119
120	/* If the bitmap could not be found, try again using the install directory. */
121	if (hBitmap == 0)
122	hBitmap = loadSplashImage( homeDir, depth <= LO_RES_DEPTH ? loResSplash : hiResSplash );
123
124	/* If the bitmap could not be found, return an error. */
125	if (hBitmap == 0)
126	return ERROR_FILE_NOT_FOUND;
127
128	/* Load the bitmap into the splash popup window. */
129	SendMessage( topWindow, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM) hBitmap );
130
131	/* Centre the splash window and display it. */
132	GetWindowRect (topWindow, &rect);
133	width = GetSystemMetrics (SM_CXSCREEN);
134	height = GetSystemMetrics (SM_CYSCREEN);
135	x = (width - (rect.right - rect.left)) / 2;
136	y = (height - (rect.bottom - rect.top)) / 2;
137	SetWindowPos (topWindow, 0, x, y, 0, 0, SWP_NOZORDER \| SWP_NOSIZE \| SWP_NOACTIVATE);
138	ShowWindow( topWindow, SW_SHOW );
139	BringWindowToTop( topWindow );
140		51
141	/* If a timeout for the splash window was given */
142	if (timeout != 0)
143	{
144	/* Add a timeout (in milliseconds) to bring down the splash screen. */
145	SetTimer( topWindow, splashTimerId, (timeout * 1000), splashTimeout );
146	}
147
148	/* Process messages until the splash window is closed or process is terminated. */
149	while (GetMessage( &msg, NULL, 0, 0 ))
150	{
151	TranslateMessage( &msg );
152	DispatchMessage( &msg );
153	}
154
155	return 0;
156	}	52	}
157		53
		54	static jstring newJavaString(JNIEnv env, char s)
		55	{
		56	int len;
		57	jclass cls;
		58	jmethodID mid;
		59	jbyteArray ary;
		60	jstring str = 0;
		61
		62	if (s == NULL)
		63	return 0;
		64	len = strlen(s);
		65	ary = (*env)->NewByteArray(env, len);
		66	if (ary != 0)
		67	{
		68	(env)->SetByteArrayRegion(env, ary, 0, len, (jbyte )s);
		69	if (!(*env)->ExceptionOccurred(env)) {
		70	cls = (*env)->FindClass(env, "java/lang/String");
		71	mid = (*env)->GetMethodID(env, cls, "<init>", "([B)V");
		72	str = (*env)->NewObject(env, cls, mid, ary);
		73	}
		74	(*env)->DeleteLocalRef(env, ary);
		75	}
		76	return str;
		77	}
		78
		79	static jobjectArray newJavaStringArray(JNIEnv env, char *argv, int argc)
		80	{
		81	jarray cls;
		82	jarray ary;
		83	int i;
		84
		85	cls = (*env)->FindClass(env, "java/lang/String");
		86	ary = (*env)->NewObjectArray(env, argc, cls, 0);
		87	for (i = 0; i < argc; i++) {
		88	jstring str = newJavaString(env, *argv++);
		89	(*env)->SetObjectArrayElement(env, ary, i, str);
		90	(*env)->DeleteLocalRef(env, str);
		91	}
		92	return ary;
		93	}
158		94
159	/* Get the window system specific VM args */	95	/**
160	_TCHAR** getArgVM( _TCHAR *vm )	96	* Convert a wide string to a narrow one suitable for use in JNI.
		97	* Caller must free the null terminated string returned.
		98	*/
		99	static char toNarrow(_TCHAR src)
161	{	100	{
162	return argVM;	101	#ifdef UNICODE
		102	int byteCount = WideCharToMultiByte (CP_ACP, 0, (wchar_t *)src, -1, NULL, 0, NULL, NULL);
		103	char *dest = malloc(byteCount+1);
		104	dest[byteCount] = 0;
		105	WideCharToMultiByte (CP_ACP, 0, (wchar_t *)src, -1, dest, byteCount, NULL, NULL);
		106	return dest;
		107	#else
		108	return _tcsdup(src);
		109	#endif
163	}	110	}
164		111
165
166	/* Start the Java VM	112	/* Start the Java VM
167	*	113	*
168	* This method is called to start the Java virtual machine and to wait until it	114	* This method is called to start the Java virtual machine and to wait until it
169	* terminates. The function returns the exit code from the JVM.	115	* terminates. The function returns the exit code from the JVM.
170	*/	116	*/
171	int startJavaVM( _TCHAR* args[] )	117	int startJavaVM( _TCHAR* javaVM, _TCHAR* jarFile, _TCHAR* className, int argc, _TCHAR* argv[] )
172	{	118	{
173	MSG msg;	119	HINSTANCE jvmLibrary; // Library handle
174	int index, length;	120
175	_TCHAR commandLine, ch, *space;	121	//displayMessage(_T("jni invoke\n"));
176		122	jvmLibrary = LoadLibrary(javaVM);
177	/*	123	/* If the child library (JVM) would not start */
178	* Build the command line. Any argument with spaces must be in	124	if (jvmLibrary == 0)
179	* double quotes in the command line.
180	*/
181	length = 0;
182	for (index = 0; args[index] != NULL; index++)
183	{
184	/* String length plus space character */
185	length += _tcslen( args[ index ] ) + 1;
186	/* Quotes */
187	if (_tcschr( args[ index ], _T(' ') ) != NULL) length += 2;
188	}
189	commandLine = ch = malloc ( (length + 1) * sizeof(_TCHAR) );
190	for (index = 0; args[index] != NULL; index++)
191	{
192	space = _tcschr( args[ index ], _T(' '));
193	if (space != NULL) *ch++ = _T('\"');
194	_tcscpy( ch, args[index] );
195	ch += _tcslen( args[index] );
196	if (space != NULL) *ch++ = _T('\"');
197	*ch++ = _T(' ');
198	}
199	*ch = _T('\0');
200
201	/*
202	* Start the Java virtual machine. Use CreateProcess() instead of spawnv()
203	* otherwise the arguments cannot be freed since spawnv() segments fault.
204	*/
205	{
206	STARTUPINFO si;
207	PROCESS_INFORMATION pi;
208	GetStartupInfo(&si);
209	if (CreateProcess(NULL, commandLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
210	CloseHandle( pi.hThread );
211	jvmProcess = (int)pi.hProcess;
212	}
213	}
214
215	free( commandLine );
216
217	/* If the child process (JVM) would not start */
218	if (jvmProcess == -1)
219	{	125	{
220	/* Return the error number. */	126	/* Return the error number. */
		127	displayMessage(_T("child lib would not start\n"));
221	jvmExitCode = errno;	128	jvmExitCode = errno;
222	jvmProcess = 0;
223	}	129	}
224
225	/* else */
226	else	130	else
227	{	131	{
228	/* Set a timer to detect JVM process termination. */	132	/* Get the function addresses */
229	SetTimer( topWindow, jvmExitTimerId, jvmExitTimeout, detectJvmExit );	133	//displayMessage(_T("get function address\n"));
230		134	jint (JNICALL createJavaVM)(JavaVM pvm, JNIEnv env, void args);
231	/* Process messages until the JVM terminates.	135	createJavaVM = (void *)GetProcAddress(jvmLibrary, "JNI_CreateJavaVM");
232	This launcher process must continue to process events until the JVM exits	136	if (createJavaVM == 0)
233	or else Windows 2K will hang if the desktop properties (e.g., background) are	137	{
234	changed by the user. Windows does a SendMessage() to every top level window	138	/* Return the error number. */
235	process, which blocks the caller until the process responds. */	139	displayMessage(_T("createJavaVM or getDefaultJavaVMInitArgs address not found\n"));
236	while (jvmProcess != 0)	140	jvmExitCode = errno;
237	{	141	}
238	GetMessage( &msg, NULL, 0, 0 );	142	else
239	TranslateMessage( &msg );	143	{
240	DispatchMessage( &msg );	144	JavaVM jvm; / denotes a Java VM */
		145	JNIEnv env; / pointer to native method interface */
		146	int i;
		147	char *narrowJarFile = toNarrow(jarFile);
		148	//displayMessage(jarFile);
		149	char *narrowClassName = toNarrow(className);
		150	//displayMessage(className);
		151
		152	// documented here: http://java.sun.com/j2se/1.4.2/docs/guide/jni/jni-12.html#JNI_CreateJavaVM
		153	//displayMessage(_T("pack arguments\n"));
		154	JavaVMInitArgs vm_args = {0};
		155	JavaVMOption options = malloc((1 + argc) sizeof(JavaVMOption));
		156	memset(options, 0, (1 + argc) * sizeof(JavaVMOption));
		157	static char* classPath = "-Djava.class.path=";
		158	options[0].optionString = malloc(strlen(classPath) + strlen(narrowJarFile) + 1);
		159	strcpy(options[0].optionString, classPath);
		160	strcat(options[0].optionString, narrowJarFile);
		161	for (i = 0; i < argc; i++) {
		162	options[i+1].optionString = toNarrow(argv[i]);
		163	}
		164	vm_args.version = JNI_VERSION_1_4;
		165	vm_args.options = options;
		166	vm_args.nOptions = 1 + argc;
		167	vm_args.ignoreUnrecognized = JNI_TRUE;
		168
		169	/* load and initialize a Java VM, return a JNI interface pointer in env */
		170	//displayMessage(_T("about to create vm\n"));
		171	(*createJavaVM)(&jvm, &env, &vm_args);
		172	if (jvm == NULL)
		173	{
		174	displayMessage(_T("createJavaVM failed\n"));
		175	jvmExitCode = errno;
		176	}
		177	else
		178	{
		179	/* invoke the Main.test method using the JNI */
		180	//displayMessage(_T("about to FindClass\n"));
		181	jclass cls = (*env)->FindClass(env, narrowClassName);
		182	if (cls == NULL)
		183	{
		184	displayMessage(_T("FindClass failed\n"));
		185	jvmExitCode = errno;
		186	}
		187	else
		188	{
		189	//displayMessage(_T("about to GetStaticMethodID\n"));
		190	jmethodID mid = (*env)->GetStaticMethodID(env, cls, "main", "([Ljava/lang/String;)V");
		191	if (mid == NULL)
		192	{
		193	displayMessage(_T("GetStaticMethodID failed\n"));
		194	jvmExitCode = errno;
		195	}
		196	else
		197	{
		198	//displayMessage(_T("about to call main\n"));
		199	(*env)->CallStaticVoidMethod(env, cls, mid,
		200	newJavaStringArray(env, NULL, 0));
		201	// shouldn't get here, but just in case...
		202	//displayMessage(_T("main complete, destroying vm\n"));
		203	/* We are done. */
		204	(*jvm)->DestroyJavaVM(jvm);
		205	}
		206	}
		207	}
		208	for (i = 0; i < vm_args.nOptions; i++)
209	free(options[i].optionString);
210	free(options);
211	free(narrowJarFile);
212	free(narrowClassName);
241	}	213	}
242
243	/* Kill the timer. */
244	KillTimer( topWindow, jvmExitTimerId );
245	}	214	}
246		215
247	/* Return the exit code from the JVM. */	216	/* Return the exit code from the JVM. */
248	return jvmExitCode;	217	return jvmExitCode;
249	}	218	}
250
251	/* Local functions */
252
253	/* Detect JVM Process Termination */
254	static void CALLBACK detectJvmExit( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime )
255	{
256	DWORD exitCode;
257
258	/* If the JVM process has terminated */
259	if (!GetExitCodeProcess( (HANDLE)jvmProcess, &exitCode ) \|\|
260	exitCode != STILL_ACTIVE)
261	{
262	/* Save the JVM exit code. This should cause the loop in startJavaVM() to exit. */
263	jvmExitCode = exitCode;
264	jvmProcess = 0;
265	}
266	}
267
268	/* Splash Timeout */
269	static void CALLBACK splashTimeout( HWND hwnd, UINT uMsg, UINT id, DWORD dwTime )
270	{
271	/* Kill the timer. */
272	KillTimer( topWindow, id );
273	PostMessage( topWindow, WM_QUIT, 0, 0 );
274	}
275
276
277	/* Load the splash image depending on the current locale.
278	*
279	* This is the search sequence for an USA english locale:
280	*
281	* 1 - <homeDir>splash\en_US\<fileName>
282	* 2 - <homeDir>splash\en\<fileName>
283	* 3 - <homeDir>splash\<fileName>
284	*
285	* Returns an HBITMAP or NULL if the file can not be found.
286	*/
287	static HBITMAP loadSplashImage(_TCHAR* baseDir, _TCHAR* fileName)
288	{
289	HBITMAP hBitmap = NULL;
290	LCID locale;
291	_TCHAR lang[4] = {0};
292	_TCHAR country[4] = {0};
293	_TCHAR *splashFile;
294
295	locale = GetThreadLocale ();
296	GetLocaleInfo(locale, LOCALE_SISO639LANGNAME, lang, 4);
297	GetLocaleInfo(locale, LOCALE_SISO3166CTRYNAME, country, 4);
298
299	splashFile = malloc ( (_tcslen( baseDir ) + 256) * sizeof(_TCHAR) );
300
301	_stprintf( splashFile, _T("%s\\splash\\%s_%s\\%s"), baseDir, lang, country, fileName );
302	hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
303
304	if (hBitmap == NULL)
305	{
306	_stprintf( splashFile, _T("%s\\splash\\%s\\%s"), baseDir, lang, fileName );
307	hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
308	}
309
310	if (hBitmap == NULL)
311	{
312	_stprintf( splashFile, _T("%s\\splash\\%s"), baseDir, fileName );
313	hBitmap = LoadImage (NULL, splashFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
314	}
315
316	free (splashFile);
317	return hBitmap;
318	}
319
320
321	/* Window Procedure for the Spash window.
322	*
323	* A special WndProc is needed to return the proper vlaue for WM_NCHITTEST.
324	* It must also detect the message from the splash window process.
325	*/
326	static LRESULT WINAPI WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
327	{
328	switch (uMsg)
329	{
330	case WM_NCHITTEST: return HTCLIENT;
331	case WM_CLOSE:
332	PostQuitMessage( 0 );
333	break;
334	}
335	return CallWindowProc (oldProc, hwnd, uMsg, wParam, lParam);
336	}
337