jdk/src/share/bin/java.c
author ksrini
Fri, 09 Jul 2010 11:04:34 -0700
changeset 6005 f9e6c98d4ee3
parent 5506 202f599c92aa
child 6535 77ffd0e75bfb
permissions -rw-r--r--
6921472: RFE: java launcher code needs clean up Summary: This changeset also contains fixes for 6405284, 6753938 and 6922500 Reviewed-by: darcy
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
     2
 * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4525
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4525
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4525
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4525
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4525
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
 * Shared source for 'java' command line tool.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
 * If JAVA_ARGS is defined, then acts as a launcher for applications. For
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
 * instance, the JDK command line tools such as javac and javadoc (see
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
 * makefiles for more details) are built with this program.  Any arguments
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
 * prefixed with '-J' will be passed directly to the 'java' command.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
 * One job of the launcher is to remove command line options which the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
 * vm does not understand and will not process.  These options include
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * options which select which style of vm is run (e.g. -client and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 * -server) as well as options which select the data model to use.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * Additionally, for tools which invoke an underlying vm "-J-foo"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * options are turned into "-foo" options to the vm.  This option
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * filtering is handled in a number of places in the launcher, some of
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * it in machine-dependent code.  In this file, the function
4340
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    44
 * CheckJvmType removes vm style options and TranslateApplicationArgs
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    45
 * removes "-J" prefixes.  The CreateExecutionEnvironment function processes
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    46
 * and removes -d<n> options. On unix, there is a possibility that the running
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    47
 * data model may not match to the desired data model, in this case an exec is
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    48
 * required to start the desired model. If the data models match, then
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    49
 * ParseArguments will remove the -d<n> flags. If the data models do not match
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
    50
 * the CreateExecutionEnviroment will remove the -d<n> flags.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
#include "java.h"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
 * A NOTE TO DEVELOPERS: For performance reasons it is important that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
 * the program image remain relatively small until after SelectVersion
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
 * CreateExecutionEnvironment have finished their possibly recursive
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 * processing. Watch everything, but resist all temptations to use Java
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 * interfaces.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
static jboolean printVersion = JNI_FALSE; /* print and exit */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
static jboolean showVersion = JNI_FALSE;  /* print but continue */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
static jboolean printUsage = JNI_FALSE;   /* print and exit*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
static jboolean printXUsage = JNI_FALSE;  /* print and exit*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
static const char *_program_name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
static const char *_launcher_name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
static jboolean _is_java_args = JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
static const char *_fVersion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
static const char *_dVersion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
static jboolean _wc_enabled = JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
static jint _ergo_policy = DEFAULT_POLICY;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
 * Entries for splash screen environment variables.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
 * putenv is performed in SelectVersion. We need
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
 * them in memory until UnsetEnv, so they are made static
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
 * global instead of auto local.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
static char* splash_file_entry = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
static char* splash_jar_entry = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
 * List of VM options to be specified when the VM is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
static JavaVMOption *options;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
static int numOptions, maxOptions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
 * Prototypes for functions internal to launcher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
static void SetClassPath(const char *s);
4525
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
    96
static void SetModulesBootClassPath(const char *s);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
static void SelectVersion(int argc, char **argv, char **main_class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
static jboolean ParseArguments(int *pargc, char ***pargv, char **pjarfile,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
                               char **pclassname, int *pret, const char *jvmpath);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
                              InvocationFunctions *ifn);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
static jstring NewPlatformString(JNIEnv *env, char *s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   104
static jclass LoadMainClass(JNIEnv *env, jboolean isJar, char *name);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
static void TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
static jboolean AddApplicationOptions(int cpathc, const char **cpathv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
static void SetApplicationClassPath(const char**);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
static void PrintJavaVersion(JNIEnv *env, jboolean extraLF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
static void PrintUsage(JNIEnv* env, jboolean doXUsage);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
static void SetPaths(int argc, char **argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
static void DumpState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
static jboolean RemovableOption(char *option);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
/* Maximum supported entries from jvm.cfg. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
#define INIT_MAX_KNOWN_VMS      10
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
/* Values for vmdesc.flag */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
enum vmdesc_flag {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
    VM_UNKNOWN = -1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
    VM_KNOWN,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
    VM_ALIASED_TO,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
    VM_WARN,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
    VM_ERROR,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
    VM_IF_SERVER_CLASS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
    VM_IGNORE
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
};
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
struct vmdesc {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
    char *name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
    int flag;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
    char *alias;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
    char *server_class;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
};
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
static struct vmdesc *knownVMs = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
static int knownVMsCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
static int knownVMsLimit = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
static void GrowKnownVMs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
static int  KnownVMIndex(const char* name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
static void FreeKnownVMs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
static void ShowSplashScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
static jboolean IsWildCardEnabled();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
#define ARG_CHECK(n, f, a) if (n < 1) { \
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   149
    JLI_ReportErrorMessage(f, a); \
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
    printUsage = JNI_TRUE; \
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
    *pret = 1; \
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
    return JNI_TRUE; \
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
 * Running Java code in primordial thread caused many problems. We will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
 * create a new thread to invoke JVM. See 6316197 for more information.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
static jlong threadStackSize = 0;  /* stack size of the new thread */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
int JNICALL JavaMain(void * args); /* entry point                  */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
typedef struct {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
  int     argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
  char ** argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
  char *  jarfile;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
  char *  classname;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
  InvocationFunctions ifn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
} JavaMainArgs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
 * Entry point.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
int
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
JLI_Launch(int argc, char ** argv,              /* main argc, argc */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
        int jargc, const char** jargv,          /* java args */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
        int appclassc, const char** appclassv,  /* app classpath */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
        const char* fullversion,                /* full version defined */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
        const char* dotversion,                 /* dot version defined */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
        const char* pname,                      /* program name */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
        const char* lname,                      /* launcher name */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
        jboolean javaargs,                      /* JAVA_ARGS */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
        jboolean cpwildcard,                    /* classpath wildcard*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
        jboolean javaw,                         /* windows-only javaw */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
        jint ergo                               /* ergonomics class policy */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
    char *jarfile = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    char *classname = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
    char *cpath = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
    char *main_class = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
    int ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
    InvocationFunctions ifn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
    jlong start, end;
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   195
    char jvmpath[MAXPATHLEN];
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   196
    char jrepath[MAXPATHLEN];
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
    _fVersion = fullversion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
    _dVersion = dotversion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
    _launcher_name = lname;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
    _program_name = pname;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
    _is_java_args = javaargs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
    _wc_enabled = cpwildcard;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
    _ergo_policy = ergo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
39
560da37936db 6596475: (launcher) javaw should call InitCommonControls
ksrini
parents: 2
diff changeset
   206
    InitLauncher(javaw);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
    DumpState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
     * Make sure the specified version of the JRE is running.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
     * There are three things to note about the SelectVersion() routine:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
     *  1) If the version running isn't correct, this routine doesn't
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
     *     return (either the correct version has been exec'd or an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
     *     was issued).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
     *  2) Argc and Argv in this scope are *not* altered by this routine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
     *     It is the responsibility of subsequent code to ignore the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
     *     arguments handled by this routine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
     *  3) As a side-effect, the variable "main_class" is guaranteed to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
     *     be set (if it should ever be set).  This isn't exactly the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
     *     poster child for structured programming, but it is a small
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
     *     price to pay for not processing a jar file operand twice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
     *     (Note: This side effect has been disabled.  See comment on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
     *     bugid 5030265 below.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
    SelectVersion(argc, argv, &main_class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   228
    if (JLI_IsTraceLauncher()) {
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   229
        int i;
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   230
        printf("Command line args:\n");
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   231
        for (i = 0; i < argc ; i++) {
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   232
            printf("argv[%d] = %s\n", i, argv[i]);
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   233
        }
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   234
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
    CreateExecutionEnvironment(&argc, &argv,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
                               jrepath, sizeof(jrepath),
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   238
                               jvmpath, sizeof(jvmpath));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    ifn.CreateJavaVM = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
    ifn.GetDefaultJavaVMInitArgs = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
        start = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
    if (!LoadJavaVM(jvmpath, &ifn)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
        return(6);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
        end   = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
    JLI_TraceLauncher("%ld micro seconds to LoadJavaVM\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
             (long)(jint)Counter2Micros(end-start));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
    ++argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
    --argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
    if (IsJavaArgs()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
        /* Preprocess wrapper arguments */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
        TranslateApplicationArgs(jargc, jargv, &argc, &argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
        if (!AddApplicationOptions(appclassc, appclassv)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
            return(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        /* Set default CLASSPATH */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
        cpath = getenv("CLASSPATH");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
        if (cpath == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
            cpath = ".";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
        SetClassPath(cpath);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
     *  Parse command line options; if the return value of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
     *  ParseArguments is false, the program should exit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
    if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret, jvmpath)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
        return(ret);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
4525
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   284
    /* Set bootclasspath for modules */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   285
    SetModulesBootClassPath(jrepath);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   286
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
    /* Override class path if -jar flag was specified */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
    if (jarfile != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
        SetClassPath(jarfile);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
    /* set the -Dsun.java.command pseudo property */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
    SetJavaCommandLineProp(classname, jarfile, argc, argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
    /* Set the -Dsun.java.launcher pseudo property */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
    SetJavaLauncherProp();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
    /* set the -Dsun.java.launcher.* platform properties */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
    SetJavaLauncherPlatformProps();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
    /* Show the splash screen if needed */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
    ShowSplashScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
    return ContinueInNewThread(&ifn, argc, argv, jarfile, classname, ret);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
}
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   307
/*
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   308
 * Always detach the main thread so that it appears to have ended when
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   309
 * the application's main method exits.  This will invoke the
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   310
 * uncaught exception handler machinery if main threw an
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   311
 * exception.  An uncaught exception handler cannot change the
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   312
 * launcher's return code except by calling System.exit.
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   313
 *
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   314
 * Wait for all non-daemon threads to end, then destroy the VM.
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   315
 * This will actually create a trivial new Java waiter thread
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   316
 * named "DestroyJavaVM", but this will be seen as a different
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   317
 * thread from the one that executed main, even though they are
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   318
 * the same C thread.  This allows mainThread.join() and
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   319
 * mainThread.isAlive() to work as expected.
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   320
 */
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   321
#define LEAVE() \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   322
    if ((*vm)->DetachCurrentThread(vm) != 0) { \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   323
        JLI_ReportErrorMessage(JVM_ERROR2); \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   324
        ret = 1; \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   325
    } \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   326
    (*vm)->DestroyJavaVM(vm); \
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   327
    return ret \
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   329
#define CHECK_EXCEPTION_NULL_LEAVE(e) \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   330
    if ((*env)->ExceptionOccurred(env)) { \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   331
        JLI_ReportExceptionDescription(env); \
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   332
        LEAVE(); \
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   333
    } \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   334
    if ((e) == NULL) { \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   335
        JLI_ReportErrorMessage(JNI_ERROR); \
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   336
        LEAVE(); \
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   337
    }
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   338
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   339
#define CHECK_EXCEPTION_LEAVE(rv) \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   340
    if ((*env)->ExceptionOccurred(env)) { \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   341
        JLI_ReportExceptionDescription(env); \
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   342
        ret = (rv); \
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   343
        LEAVE(); \
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   344
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
int JNICALL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
JavaMain(void * _args)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
    JavaMainArgs *args = (JavaMainArgs *)_args;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
    int argc = args->argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
    char **argv = args->argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
    char *jarfile = args->jarfile;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
    char *classname = args->classname;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
    InvocationFunctions ifn = args->ifn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
    JavaVM *vm = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
    JNIEnv *env = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
    jstring mainClassName;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
    jclass mainClass;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
    jmethodID mainID;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
    jobjectArray mainArgs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
    int ret = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
    jlong start, end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
    /* Initialize the virtual machine */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
    start = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
    if (!InitializeJVM(&vm, &env, &ifn)) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   368
        JLI_ReportErrorMessage(JVM_ERROR1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
        exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
    if (printVersion || showVersion) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
        PrintJavaVersion(env, showVersion);
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   374
        CHECK_EXCEPTION_LEAVE(0);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
        if (printVersion) {
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   376
            LEAVE();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
    /* If the user specified neither a class name nor a JAR file */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
    if (printXUsage || printUsage || (jarfile == 0 && classname == 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        PrintUsage(env, printXUsage);
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   383
        CHECK_EXCEPTION_LEAVE(1);
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   384
        LEAVE();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
    FreeKnownVMs();  /* after last possible PrintUsage() */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
        end = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
        JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
               (long)(jint)Counter2Micros(end-start));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
    /* At this stage, argc/argv have the applications' arguments */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
    if (JLI_IsTraceLauncher()){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
        int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
        printf("Main-Class is '%s'\n", classname ? classname : "");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
        printf("Apps' argc is %d\n", argc);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
        for (i=0; i < argc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
            printf("    argv[%2d] = '%s'\n", i, argv[i]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
    ret = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
     * Get the application's main class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
     * See bugid 5030265.  The Main-Class name has already been parsed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
     * from the manifest, but not parsed properly for UTF-8 support.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
     * Hence the code here ignores the value previously extracted and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
     * uses the pre-existing code to reextract the value.  This is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
     * possibly an end of release cycle expedient.  However, it has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
     * also been discovered that passing some character sets through
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
     * the environment has "strange" behavior on some variants of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
     * Windows.  Hence, maybe the manifest parsing code local to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
     * launcher should never be enhanced.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
     * Hence, future work should either:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
     *     1)   Correct the local parsing code and verify that the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
     *          Main-Class attribute gets properly passed through
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
     *          all environments,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
     *     2)   Remove the vestages of maintaining main_class through
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
     *          the environment (and remove these comments).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
    if (jarfile != 0) {
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   428
        mainClass = LoadMainClass(env, JNI_TRUE, jarfile);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
    } else {
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   430
        mainClass = LoadMainClass(env, JNI_FALSE, classname);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
    }
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   432
    CHECK_EXCEPTION_NULL_LEAVE(mainClass);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   434
    /*
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   435
     * The LoadMainClass not only loads the main class, it will also ensure
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   436
     * that the main method's signature is correct, therefore further checking
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   437
     * is not required. The main method is invoked here so that extraneous java
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   438
     * stacks are not in the application stack trace.
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   439
     */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
    mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
                                       "([Ljava/lang/String;)V");
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   442
    CHECK_EXCEPTION_NULL_LEAVE(mainID);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
    /* Build argument array */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
    mainArgs = NewPlatformStringArray(env, argv, argc);
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
   446
    CHECK_EXCEPTION_NULL_LEAVE(mainArgs);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
    /* Invoke main method. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
    (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
     * The launcher's exit code (in the absence of calls to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
     * System.exit) will be non-zero if main threw an exception.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
    ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
   456
    LEAVE();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
 * Checks the command line options to find which JVM type was
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
 * specified.  If no command line option was given for the JVM type,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
 * the default type is used.  The environment variable
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
 * JDK_ALTERNATE_VM and the command line option -XXaltjvm= are also
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
 * checked as ways of specifying which JVM type to invoke.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
char *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
CheckJvmType(int *pargc, char ***argv, jboolean speculative) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
    int i, argi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
    int argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
    char **newArgv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
    int newArgvIdx = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
    int isVMType;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
    int jvmidx = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
    char *jvmtype = getenv("JDK_ALTERNATE_VM");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
    argc = *pargc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
    /* To make things simpler we always copy the argv array */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
    newArgv = JLI_MemAlloc((argc + 1) * sizeof(char *));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
    /* The program name is always present */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
    newArgv[newArgvIdx++] = (*argv)[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
    for (argi = 1; argi < argc; argi++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
        char *arg = (*argv)[argi];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
        isVMType = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
        if (IsJavaArgs()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
            if (arg[0] != '-') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
                newArgv[newArgvIdx++] = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
            if (JLI_StrCmp(arg, "-classpath") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
                JLI_StrCmp(arg, "-cp") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
                newArgv[newArgvIdx++] = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
                argi++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
                if (argi < argc) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
                    newArgv[newArgvIdx++] = (*argv)[argi];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
            if (arg[0] != '-') break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
        /* Did the user pass an explicit VM type? */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
        i = KnownVMIndex(arg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
        if (i >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
            jvmtype = knownVMs[jvmidx = i].name + 1; /* skip the - */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
            isVMType = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
            *pargc = *pargc - 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
        /* Did the user specify an "alternate" VM? */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
        else if (JLI_StrCCmp(arg, "-XXaltjvm=") == 0 || JLI_StrCCmp(arg, "-J-XXaltjvm=") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
            isVMType = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
            jvmtype = arg+((arg[1]=='X')? 10 : 12);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
            jvmidx = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
        if (!isVMType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
            newArgv[newArgvIdx++] = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
     * Finish copying the arguments if we aborted the above loop.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
     * NOTE that if we aborted via "break" then we did NOT copy the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
     * last argument above, and in addition argi will be less than
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
     * argc.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
    while (argi < argc) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
        newArgv[newArgvIdx++] = (*argv)[argi];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
        argi++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
    /* argv is null-terminated */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
    newArgv[newArgvIdx] = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
    /* Copy back argv */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
    *argv = newArgv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
    *pargc = newArgvIdx;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
    /* use the default VM type if not specified (no alias processing) */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
    if (jvmtype == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
      char* result = knownVMs[0].name+1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
      /* Use a different VM type if we are on a server class machine? */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
      if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
          (ServerClassMachine() == JNI_TRUE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
        result = knownVMs[0].server_class+1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
      JLI_TraceLauncher("Default VM: %s\n", result);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
      return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
    /* if using an alternate VM, no alias processing */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
    if (jvmidx < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
      return jvmtype;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
    /* Resolve aliases first */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
      int loopCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
      while (knownVMs[jvmidx].flag == VM_ALIASED_TO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
        int nextIdx = KnownVMIndex(knownVMs[jvmidx].alias);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
        if (loopCount > knownVMsCount) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
          if (!speculative) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   568
            JLI_ReportErrorMessage(CFG_ERROR1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
            exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
          } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
            return "ERROR";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
            /* break; */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
          }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
        if (nextIdx < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
          if (!speculative) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   578
            JLI_ReportErrorMessage(CFG_ERROR2, knownVMs[jvmidx].alias);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
            exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
          } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
            return "ERROR";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
          }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
        jvmidx = nextIdx;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
        jvmtype = knownVMs[jvmidx].name+1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
        loopCount++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
    switch (knownVMs[jvmidx].flag) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
    case VM_WARN:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
        if (!speculative) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   593
            JLI_ReportErrorMessage(CFG_WARN1, jvmtype, knownVMs[0].name + 1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
        /* fall through */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
    case VM_IGNORE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
        jvmtype = knownVMs[jvmidx=0].name + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
        /* fall through */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
    case VM_KNOWN:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
    case VM_ERROR:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
        if (!speculative) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   603
            JLI_ReportErrorMessage(CFG_ERROR3, jvmtype);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
            exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
            return "ERROR";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
    return jvmtype;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
/* copied from HotSpot function "atomll()" */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
static int
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
parse_stack_size(const char *s, jlong *result) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
  jlong n = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
  int args_read = sscanf(s, jlong_format_specifier(), &n);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
  if (args_read != 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
    return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
  while (*s != '\0' && *s >= '0' && *s <= '9') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
    s++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
  // 4705540: illegal if more characters are found after the first non-digit
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
  if (JLI_StrLen(s) > 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
    return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
  switch (*s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
    case 'T': case 't':
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
      *result = n * GB * KB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
      return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
    case 'G': case 'g':
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
      *result = n * GB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
      return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
    case 'M': case 'm':
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
      *result = n * MB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
      return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
    case 'K': case 'k':
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
      *result = n * KB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
      return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
    case '\0':
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
      *result = n;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
      return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
    default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
      /* Create JVM with default stack and let VM handle malformed -Xss string*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
      return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
 * Adds a new VM option with the given given name and value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
void
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
AddOption(char *str, void *info)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
     * Expand options array if needed to accommodate at least one more
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
     * VM option.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
    if (numOptions >= maxOptions) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
        if (options == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
            maxOptions = 4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
            options = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
            JavaVMOption *tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
            maxOptions *= 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
            tmp = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
            memcpy(tmp, options, numOptions * sizeof(JavaVMOption));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
            JLI_MemFree(options);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
            options = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
    options[numOptions].optionString = str;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
    options[numOptions++].extraInfo = info;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
    if (JLI_StrCCmp(str, "-Xss") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
      jlong tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
      if (parse_stack_size(str + 4, &tmp)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
        threadStackSize = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
SetClassPath(const char *s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
    char *def;
3054
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   688
    const char *orig = s;
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   689
    static const char format[] = "-Djava.class.path=%s";
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
    s = JLI_WildcardExpandClasspath(s);
3054
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   691
    def = JLI_MemAlloc(sizeof(format)
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   692
                       - 2 /* strlen("%s") */
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   693
                       + JLI_StrLen(s));
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   694
    sprintf(def, format, s);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
    AddOption(def, NULL);
3054
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   696
    if (s != orig)
ddb6acba8b6f 6851653: (launcher) Make every java process 20 bytes smaller
martin
parents: 2624
diff changeset
   697
        JLI_MemFree((char *) s);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
/*
4525
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   701
 * Set the bootclasspath for modules.
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   702
 * A temporary workaround until jigsaw is integrated into JDK 7.
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   703
 */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   704
static void
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   705
SetModulesBootClassPath(const char *jrepath)
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   706
{
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   707
    char *def, *s;
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   708
    char pathname[MAXPATHLEN];
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   709
    const char separator[] = { FILE_SEPARATOR, '\0' };
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   710
    const char *orig = jrepath;
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   711
    static const char format[] = "-Xbootclasspath/p:%s";
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   712
    struct stat statbuf;
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   713
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   714
    /* return if jre/lib/rt.jar exists */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   715
    sprintf(pathname, "%s%slib%srt.jar", jrepath, separator, separator);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   716
    if (stat(pathname, &statbuf) == 0) {
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   717
        return;
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   718
    }
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   719
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   720
    /* return if jre/classes exists */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   721
    sprintf(pathname, "%s%sclasses", jrepath, separator);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   722
    if (stat(pathname, &statbuf) == 0) {
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   723
        return;
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   724
    }
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   725
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   726
    /* modularized jre */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   727
    sprintf(pathname, "%s%slib%s*", jrepath, separator, separator);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   728
    s = (char *) JLI_WildcardExpandClasspath(pathname);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   729
    def = JLI_MemAlloc(sizeof(format)
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   730
                       - 2 /* strlen("%s") */
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   731
                       + JLI_StrLen(s));
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   732
    sprintf(def, format, s);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   733
    AddOption(def, NULL);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   734
    if (s != orig)
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   735
        JLI_MemFree((char *) s);
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   736
}
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   737
80191930aa5f 6909573: Temporary launcher support to add modules in the bootclasspath
mchung
parents: 4340
diff changeset
   738
/*
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
 * The SelectVersion() routine ensures that an appropriate version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
 * the JRE is running.  The specification for the appropriate version
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
 * is obtained from either the manifest of a jar file (preferred) or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
 * from command line options.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
 * The routine also parses splash screen command line options and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
 * passes on their values in private environment variables.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
SelectVersion(int argc, char **argv, char **main_class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
    char    *arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
    char    **new_argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
    char    **new_argp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
    char    *operand;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
    char    *version = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
    char    *jre = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
    int     jarflag = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
    int     headlessflag = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
    int     restrict_search = -1;               /* -1 implies not known */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
    manifest_info info;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
    char    env_entry[MAXNAMELEN + 24] = ENV_ENTRY "=";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
    char    *splash_file_name = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
    char    *splash_jar_name = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
    char    *env_in;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
    int     res;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
     * If the version has already been selected, set *main_class
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
     * with the value passed through the environment (if any) and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
     * simply return.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
    if ((env_in = getenv(ENV_ENTRY)) != NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
        if (*env_in != '\0')
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
            *main_class = JLI_StringDup(env_in);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
     * Scan through the arguments for options relevant to multiple JRE
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
     * support.  For reference, the command line syntax is defined as:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
     * SYNOPSIS
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
     *      java [options] class [argument...]
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
     *      java [options] -jar file.jar [argument...]
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
     * As the scan is performed, make a copy of the argument list with
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
     * the version specification options (new to 1.5) removed, so that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
     * a version less than 1.5 can be exec'd.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
     * Note that due to the syntax of the native Windows interface
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
     * CreateProcess(), processing similar to the following exists in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
     * the Windows platform specific routine ExecJRE (in java_md.c).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
     * Changes here should be reproduced there.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
    new_argv = JLI_MemAlloc((argc + 1) * sizeof(char*));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
    new_argv[0] = argv[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
    new_argp = &new_argv[1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
    argc--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
    argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
    while ((arg = *argv) != 0 && *arg == '-') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
        if (JLI_StrCCmp(arg, "-version:") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
            version = arg + 9;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
        } else if (JLI_StrCmp(arg, "-jre-restrict-search") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
            restrict_search = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
        } else if (JLI_StrCmp(arg, "-no-jre-restrict-search") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
            restrict_search = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
            if (JLI_StrCmp(arg, "-jar") == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
                jarflag = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
            /* deal with "unfortunate" classpath syntax */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
            if ((JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
              (argc >= 2)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
                *new_argp++ = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
                argc--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
                argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
                arg = *argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
            /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
             * Checking for headless toolkit option in the some way as AWT does:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
             * "true" means true and any other value means false
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
            if (JLI_StrCmp(arg, "-Djava.awt.headless=true") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
                headlessflag = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
            } else if (JLI_StrCCmp(arg, "-Djava.awt.headless=") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
                headlessflag = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
            } else if (JLI_StrCCmp(arg, "-splash:") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
                splash_file_name = arg+8;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
            *new_argp++ = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
        argc--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
        argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
    if (argc <= 0) {    /* No operand? Possibly legit with -[full]version */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
        operand = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
        argc--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
        *new_argp++ = operand = *argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
    while (argc-- > 0)  /* Copy over [argument...] */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
        *new_argp++ = *argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
    *new_argp = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
     * If there is a jar file, read the manifest. If the jarfile can't be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
     * read, the manifest can't be read from the jar file, or the manifest
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
     * is corrupt, issue the appropriate error messages and exit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
     * Even if there isn't a jar file, construct a manifest_info structure
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
     * containing the command line information.  It's a convenient way to carry
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
     * this data around.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
    if (jarflag && operand) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
        if ((res = JLI_ParseManifest(operand, &info)) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
            if (res == -1)
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   856
                JLI_ReportErrorMessage(JAR_ERROR2, operand);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
            else
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   858
                JLI_ReportErrorMessage(JAR_ERROR3, operand);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
            exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
         * Command line splash screen option should have precedence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
         * over the manifest, so the manifest data is used only if
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
         * splash_file_name has not been initialized above during command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
         * line parsing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
        if (!headlessflag && !splash_file_name && info.splashscreen_image_file_name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
            splash_file_name = info.splashscreen_image_file_name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
            splash_jar_name = operand;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
        info.manifest_version = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
        info.main_class = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
        info.jre_version = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
        info.jre_restrict_search = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
     * Passing on splash screen info in environment variables
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
    if (splash_file_name && !headlessflag) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
        char* splash_file_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_FILE_ENV_ENTRY "=")+JLI_StrLen(splash_file_name)+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
        JLI_StrCpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
        JLI_StrCat(splash_file_entry, splash_file_name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
        putenv(splash_file_entry);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
    if (splash_jar_name && !headlessflag) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
        char* splash_jar_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_JAR_ENV_ENTRY "=")+JLI_StrLen(splash_jar_name)+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
        JLI_StrCpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
        JLI_StrCat(splash_jar_entry, splash_jar_name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
        putenv(splash_jar_entry);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
     * The JRE-Version and JRE-Restrict-Search values (if any) from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
     * manifest are overwritten by any specified on the command line.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
    if (version != NULL)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
        info.jre_version = version;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
    if (restrict_search != -1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
        info.jre_restrict_search = restrict_search;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
     * "Valid" returns (other than unrecoverable errors) follow.  Set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
     * main_class as a side-effect of this routine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
    if (info.main_class != NULL)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
        *main_class = JLI_StringDup(info.main_class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
     * If no version selection information is found either on the command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
     * line or in the manifest, simply return.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
    if (info.jre_version == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
        JLI_FreeManifest();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
        JLI_MemFree(new_argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
     * Check for correct syntax of the version specification (JSR 56).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
    if (!JLI_ValidVersionString(info.jre_version)) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   925
        JLI_ReportErrorMessage(SPC_ERROR1, info.jre_version);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
        exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
     * Find the appropriate JVM on the system. Just to be as forgiving as
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
     * possible, if the standard algorithms don't locate an appropriate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
     * jre, check to see if the one running will satisfy the requirements.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
     * This can happen on systems which haven't been set-up for multiple
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
     * JRE support.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
    jre = LocateJRE(&info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
    JLI_TraceLauncher("JRE-Version = %s, JRE-Restrict-Search = %s Selected = %s\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
        (info.jre_version?info.jre_version:"null"),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
        (info.jre_restrict_search?"true":"false"), (jre?jre:"null"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
    if (jre == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
        if (JLI_AcceptableRelease(GetFullVersion(), info.jre_version)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
            JLI_FreeManifest();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
            JLI_MemFree(new_argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
        } else {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
   947
            JLI_ReportErrorMessage(CFG_ERROR4, info.jre_version);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
            exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
     * If I'm not the chosen one, exec the chosen one.  Returning from
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
     * ExecJRE indicates that I am indeed the chosen one.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
     * The private environment variable _JAVA_VERSION_SET is used to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
     * prevent the chosen one from re-reading the manifest file and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
     * using the values found within to override the (potential) command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
     * line flags stripped from argv (because the target may not
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
     * understand them).  Passing the MainClass value is an optimization
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
     * to avoid locating, expanding and parsing the manifest extra
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
     * times.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
     */
2598
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   964
    if (info.main_class != NULL) {
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   965
        if (JLI_StrLen(info.main_class) <= MAXNAMELEN) {
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   966
            (void)JLI_StrCat(env_entry, info.main_class);
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   967
        } else {
2624
asaha
parents: 1323 2598
diff changeset
   968
            JLI_ReportErrorMessage(CLS_ERROR5, MAXNAMELEN);
2598
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   969
            exit(1);
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   970
        }
6f980e1d6e31 6733959: Insufficient checks for "Main-Class" manifest entry in JAR files
ksrini
parents: 399
diff changeset
   971
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
    (void)putenv(env_entry);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
    ExecJRE(jre, new_argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
    JLI_FreeManifest();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
    JLI_MemFree(new_argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
    return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
 * Parses command line arguments.  Returns JNI_FALSE if launcher
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
 * should exit without starting vm, returns JNI_TRUE if vm needs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
 * to be started to process  given options. *pret (the launcher
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
 * process return value) is set to 0 for a normal exit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
static jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
ParseArguments(int *pargc, char ***pargv, char **pjarfile,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
                       char **pclassname, int *pret, const char *jvmpath)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
    int argc = *pargc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
    char **argv = *pargv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
    jboolean jarflag = JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
    char *arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
    *pret = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
    while ((arg = *argv) != 0 && *arg == '-') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
        argv++; --argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
        if (JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
            ARG_CHECK (argc, ARG_ERROR1, arg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
            SetClassPath(*argv);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
            argv++; --argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
        } else if (JLI_StrCmp(arg, "-jar") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
            ARG_CHECK (argc, ARG_ERROR2, arg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
            jarflag = JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
        } else if (JLI_StrCmp(arg, "-help") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
                   JLI_StrCmp(arg, "-h") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
                   JLI_StrCmp(arg, "-?") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
            printUsage = JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
            return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
        } else if (JLI_StrCmp(arg, "-version") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
            printVersion = JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
            return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
        } else if (JLI_StrCmp(arg, "-showversion") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
            showVersion = JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
        } else if (JLI_StrCmp(arg, "-X") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
            printXUsage = JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
            return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
 * The following case provide backward compatibility with old-style
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
 * command line options.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
        } else if (JLI_StrCmp(arg, "-fullversion") == 0) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1023
            JLI_ReportMessage("%s full version \"%s\"", _launcher_name, GetFullVersion());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
            return JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
        } else if (JLI_StrCmp(arg, "-verbosegc") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
            AddOption("-verbose:gc", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
        } else if (JLI_StrCmp(arg, "-t") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
            AddOption("-Xt", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
        } else if (JLI_StrCmp(arg, "-tm") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
            AddOption("-Xtm", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
        } else if (JLI_StrCmp(arg, "-debug") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
            AddOption("-Xdebug", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
        } else if (JLI_StrCmp(arg, "-noclassgc") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
            AddOption("-Xnoclassgc", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
        } else if (JLI_StrCmp(arg, "-Xfuture") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
            AddOption("-Xverify:all", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
        } else if (JLI_StrCmp(arg, "-verify") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
            AddOption("-Xverify:all", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
        } else if (JLI_StrCmp(arg, "-verifyremote") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
            AddOption("-Xverify:remote", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
        } else if (JLI_StrCmp(arg, "-noverify") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
            AddOption("-Xverify:none", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
        } else if (JLI_StrCCmp(arg, "-prof") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
            char *p = arg + 5;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
            char *tmp = JLI_MemAlloc(JLI_StrLen(arg) + 50);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
            if (*p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
                sprintf(tmp, "-Xrunhprof:cpu=old,file=%s", p + 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
                sprintf(tmp, "-Xrunhprof:cpu=old,file=java.prof");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
            AddOption(tmp, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
        } else if (JLI_StrCCmp(arg, "-ss") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
                   JLI_StrCCmp(arg, "-oss") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
                   JLI_StrCCmp(arg, "-ms") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
                   JLI_StrCCmp(arg, "-mx") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
            char *tmp = JLI_MemAlloc(JLI_StrLen(arg) + 6);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
            sprintf(tmp, "-X%s", arg + 1); /* skip '-' */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
            AddOption(tmp, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
        } else if (JLI_StrCmp(arg, "-checksource") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
                   JLI_StrCmp(arg, "-cs") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
                   JLI_StrCmp(arg, "-noasyncgc") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
            /* No longer supported */
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1063
            JLI_ReportErrorMessage(ARG_WARN, arg);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
        } else if (JLI_StrCCmp(arg, "-version:") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
                   JLI_StrCmp(arg, "-no-jre-restrict-search") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
                   JLI_StrCmp(arg, "-jre-restrict-search") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
                   JLI_StrCCmp(arg, "-splash:") == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
            ; /* Ignore machine independent options already handled */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
        } else if (RemovableOption(arg) ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
            ; /* Do not pass option to vm. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
            AddOption(arg, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
    if (--argc >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
        if (jarflag) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
            *pjarfile = *argv++;
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
  1079
            *pclassname = NULL;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
        } else {
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
  1081
            *pjarfile = NULL;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
            *pclassname = *argv++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
        *pargc = argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
        *pargv = argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
    }
6005
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
  1087
    if (*pjarfile == NULL && *pclassname == NULL) {
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
  1088
        *pret = 1;
f9e6c98d4ee3 6921472: RFE: java launcher code needs clean up
ksrini
parents: 5506
diff changeset
  1089
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
    return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
 * Initializes the Java Virtual Machine. Also frees options array when
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
 * finished.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
static jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
    JavaVMInitArgs args;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
    jint r;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
    memset(&args, 0, sizeof(args));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
    args.version  = JNI_VERSION_1_2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
    args.nOptions = numOptions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
    args.options  = options;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
    args.ignoreUnrecognized = JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
        int i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
        printf("JavaVM args:\n    ");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
        printf("version 0x%08lx, ", (long)args.version);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
        printf("ignoreUnrecognized is %s, ",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
               args.ignoreUnrecognized ? "JNI_TRUE" : "JNI_FALSE");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
        printf("nOptions is %ld\n", (long)args.nOptions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
        for (i = 0; i < numOptions; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
            printf("    option[%2d] = '%s'\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
                   i, args.options[i].optionString);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
    r = ifn->CreateJavaVM(pvm, (void **)penv, &args);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
    JLI_MemFree(options);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
    return r == JNI_OK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
#define NULL_CHECK0(e) if ((e) == 0) { \
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1128
    JLI_ReportErrorMessage(JNI_ERROR); \
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
    return 0; \
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1131
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1132
#define NULL_CHECK(e) if ((e) == 0) { \
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1133
    JLI_ReportErrorMessage(JNI_ERROR); \
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
    return; \
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
static jstring platformEncoding = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
static jstring getPlatformEncoding(JNIEnv *env) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
    if (platformEncoding == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
        jstring propname = (*env)->NewStringUTF(env, "sun.jnu.encoding");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
        if (propname) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
            jclass cls;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
            jmethodID mid;
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1144
            NULL_CHECK0 (cls = FindBootStrapClass(env, "java/lang/System"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
            NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
                                   env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
                                   "getProperty",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
                                   "(Ljava/lang/String;)Ljava/lang/String;"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
            platformEncoding = (*env)->CallStaticObjectMethod (
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
                                    env, cls, mid, propname);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1153
    return platformEncoding;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
static jboolean isEncodingSupported(JNIEnv *env, jstring enc) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
    jclass cls;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
    jmethodID mid;
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1159
    NULL_CHECK0 (cls = FindBootStrapClass(env, "java/nio/charset/Charset"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
    NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
                           env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
                           "isSupported",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
                           "(Ljava/lang/String;)Z"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1164
    return (*env)->CallStaticBooleanMethod(env, cls, mid, enc);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1165
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1166
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1167
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1168
 * Returns a new Java string object for the specified platform string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
static jstring
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
NewPlatformString(JNIEnv *env, char *s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
    int len = (int)JLI_StrLen(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
    jclass cls;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
    jmethodID mid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
    jbyteArray ary;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
    jstring enc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
    if (s == NULL)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
        return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
    enc = getPlatformEncoding(env);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1182
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
    ary = (*env)->NewByteArray(env, len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
    if (ary != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
        jstring str = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
        (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
        if (!(*env)->ExceptionOccurred(env)) {
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1188
            NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
            if (isEncodingSupported(env, enc) == JNI_TRUE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
                NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
                                          "([BLjava/lang/String;)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
                str = (*env)->NewObject(env, cls, mid, ary, enc);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
                /*If the encoding specified in sun.jnu.encoding is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
                  endorsed by "Charset.isSupported" we have to fall back
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
                  to use String(byte[]) explicitly here without specifying
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
                  the encoding name, in which the StringCoding class will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
                  pickup the iso-8859-1 as the fallback converter for us.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
                */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
                NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
                                          "([B)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
                str = (*env)->NewObject(env, cls, mid, ary);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
            (*env)->DeleteLocalRef(env, ary);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
            return str;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
    return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
 * Returns a new array of Java string objects for the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
 * array of platform strings.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
static jobjectArray
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
    jarray cls;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
    jarray ary;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
    int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1222
    NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
    NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
    for (i = 0; i < strc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
        jstring str = NewPlatformString(env, *strv++);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
        NULL_CHECK0(str);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
        (*env)->SetObjectArrayElement(env, ary, i, str);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
        (*env)->DeleteLocalRef(env, str);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
    return ary;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
/*
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1234
 * Loads a class and verifies that the main class is present and it is ok to
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1235
 * call it for more details refer to the java implementation.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
static jclass
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1238
LoadMainClass(JNIEnv *env, jboolean isJar, char *name)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
    jclass cls;
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1241
    jmethodID mid;
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1242
    jstring str;
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1243
    jobject result;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
    jlong start, end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1246
    if (JLI_IsTraceLauncher()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
        start = CounterGet();
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1248
    }
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1249
    NULL_CHECK0(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1250
    NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, "checkAndLoadMain",
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1251
                                          "(ZZLjava/lang/String;)Ljava/lang/Object;"));
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1252
    str = (*env)->NewStringUTF(env, name);
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1253
    result = (*env)->CallStaticObjectMethod(env, cls, mid, JNI_TRUE, isJar, str);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
        end   = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
        printf("%ld micro seconds to load main class\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1258
               (long)(jint)Counter2Micros(end-start));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1259
        printf("----_JAVA_LAUNCHER_DEBUG----\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1260
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1262
    return (jclass)result;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1263
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
 * For tools, convert command line args thus:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
 *   javac -cp foo:foo/"*" -J-ms32m ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
 *   java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
 * Takes 4 parameters, and returns the populated arguments
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
    int argc = *pargc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
    char **argv = *pargv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
    int nargc = argc + jargc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
    char **nargv = JLI_MemAlloc((nargc + 1) * sizeof(char *));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
    int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
    *pargc = nargc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
    *pargv = nargv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
    /* Copy the VM arguments (i.e. prefixed with -J) */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
    for (i = 0; i < jargc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
        const char *arg = jargv[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
        if (arg[0] == '-' && arg[1] == 'J') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
            *nargv++ = ((arg + 2) == NULL) ? NULL : JLI_StringDup(arg + 2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
    for (i = 0; i < argc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
        char *arg = argv[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
        if (arg[0] == '-' && arg[1] == 'J') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
            if (arg[2] == '\0') {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1296
                JLI_ReportErrorMessage(ARG_ERROR3);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
                exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
            *nargv++ = arg + 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
    /* Copy the rest of the arguments */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
    for (i = 0; i < jargc ; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
        const char *arg = jargv[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
        if (arg[0] != '-' || arg[1] != 'J') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
            *nargv++ = (arg == NULL) ? NULL : JLI_StringDup(arg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
    for (i = 0; i < argc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
        char *arg = argv[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
        if (arg[0] == '-') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
            if (arg[1] == 'J')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
            if (IsWildCardEnabled() && arg[1] == 'c'
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
                && (JLI_StrCmp(arg, "-cp") == 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
                    JLI_StrCmp(arg, "-classpath") == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
                && i < argc - 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
                *nargv++ = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
                *nargv++ = (char *) JLI_WildcardExpandClasspath(argv[i+1]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
                i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1322
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
        *nargv++ = arg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
    *nargv = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
 * For our tools, we try to add 3 VM options:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
 *      -Denv.class.path=<envcp>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
 *      -Dapplication.home=<apphome>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
 *      -Djava.class.path=<appcp>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1335
 * <envcp>   is the user's setting of CLASSPATH -- for instance the user
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1336
 *           tells javac where to find binary classes through this environment
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
 *           variable.  Notice that users will be able to compile against our
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
 *           tools classes (sun.tools.javac.Main) only if they explicitly add
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
 *           tools.jar to CLASSPATH.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
 * <apphome> is the directory where the application is installed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
 * <appcp>   is the classpath to where our apps' classfiles are.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
static jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
AddApplicationOptions(int cpathc, const char **cpathv)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
    char *envcp, *appcp, *apphome;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
    char home[MAXPATHLEN]; /* application home */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
    char separator[] = { PATH_SEPARATOR, '\0' };
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
    int size, i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1350
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
        const char *s = getenv("CLASSPATH");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
        if (s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
            s = (char *) JLI_WildcardExpandClasspath(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
            /* 40 for -Denv.class.path= */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
            envcp = (char *)JLI_MemAlloc(JLI_StrLen(s) + 40);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
            sprintf(envcp, "-Denv.class.path=%s", s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
            AddOption(envcp, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
    if (!GetApplicationHome(home, sizeof(home))) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1363
        JLI_ReportErrorMessage(CFG_ERROR5);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
        return JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
    /* 40 for '-Dapplication.home=' */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
    apphome = (char *)JLI_MemAlloc(JLI_StrLen(home) + 40);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
    sprintf(apphome, "-Dapplication.home=%s", home);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
    AddOption(apphome, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
    /* How big is the application's classpath? */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
    size = 40;                                 /* 40: "-Djava.class.path=" */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
    for (i = 0; i < cpathc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
        size += (int)JLI_StrLen(home) + (int)JLI_StrLen(cpathv[i]) + 1; /* 1: separator */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
    appcp = (char *)JLI_MemAlloc(size + 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
    JLI_StrCpy(appcp, "-Djava.class.path=");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
    for (i = 0; i < cpathc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
        JLI_StrCat(appcp, home);                        /* c:\program files\myapp */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1381
        JLI_StrCat(appcp, cpathv[i]);           /* \lib\myapp.jar         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1382
        JLI_StrCat(appcp, separator);           /* ;                      */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
    appcp[JLI_StrLen(appcp)-1] = '\0';  /* remove trailing path separator */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
    AddOption(appcp, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
    return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1388
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1389
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
 * inject the -Dsun.java.command pseudo property into the args structure
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
 * this pseudo property is used in the HotSpot VM to expose the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
 * Java class name and arguments to the main method to the VM. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
 * HotSpot VM uses this pseudo property to store the Java class name
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
 * (or jar file name) and the arguments to the class's main method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
 * to the instrumentation memory region. The sun.java.command pseudo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
 * property is not exported by HotSpot to the Java layer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
SetJavaCommandLineProp(char *classname, char *jarfile,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
                       int argc, char **argv)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
    int i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
    size_t len = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
    char* javaCommand = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
    char* dashDstr = "-Dsun.java.command=";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
    if (classname == NULL && jarfile == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
        /* unexpected, one of these should be set. just return without
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
         * setting the property
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
    /* if the class name is not set, then use the jarfile name */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
    if (classname == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
        classname = jarfile;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
    /* determine the amount of memory to allocate assuming
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
     * the individual components will be space separated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
    len = JLI_StrLen(classname);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
    for (i = 0; i < argc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
        len += JLI_StrLen(argv[i]) + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
    /* allocate the memory */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
    javaCommand = (char*) JLI_MemAlloc(len + JLI_StrLen(dashDstr) + 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
    /* build the -D string */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1432
    *javaCommand = '\0';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
    JLI_StrCat(javaCommand, dashDstr);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
    JLI_StrCat(javaCommand, classname);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
    for (i = 0; i < argc; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
        /* the components of the string are space separated. In
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
         * the case of embedded white space, the relationship of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
         * the white space separated components to their true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
         * positional arguments will be ambiguous. This issue may
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
         * be addressed in a future release.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
        JLI_StrCat(javaCommand, " ");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
        JLI_StrCat(javaCommand, argv[i]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
    AddOption(javaCommand, NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
 * JVM would like to know if it's created by a standard Sun launcher, or by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
 * user native application, the following property indicates the former.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
void SetJavaLauncherProp() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
  AddOption("-Dsun.java.launcher=SUN_STANDARD", NULL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1458
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
 * Prints the version information from the java.version and other properties.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1462
PrintJavaVersion(JNIEnv *env, jboolean extraLF)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1463
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
    jclass ver;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
    jmethodID print;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1467
    NULL_CHECK(ver = FindBootStrapClass(env, "sun/misc/Version"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
    NULL_CHECK(print = (*env)->GetStaticMethodID(env,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
                                                 ver,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
                                                 (extraLF == JNI_TRUE) ? "println" : "print",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
                                                 "()V"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
                                                 )
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
              );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
    (*env)->CallStaticVoidMethod(env, ver, print);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
/*
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1479
 * Prints default usage or the Xusage message, see sun.launcher.LauncherHelper.java
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
PrintUsage(JNIEnv* env, jboolean doXUsage)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
  jclass cls;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
  jmethodID initHelp, vmSelect, vmSynonym, vmErgo, printHelp, printXUsageMessage;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
  jstring jprogname, vm1, vm2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
  int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
1323
e14a3b3536cd 6742159: (launcher) improve the java launching mechanism
ksrini
parents: 1145
diff changeset
  1489
  NULL_CHECK(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
  if (doXUsage) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
    NULL_CHECK(printXUsageMessage = (*env)->GetStaticMethodID(env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
                                        "printXUsageMessage", "(Z)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
    (*env)->CallStaticVoidMethod(env, cls, printXUsageMessage, JNI_TRUE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
  } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
    NULL_CHECK(initHelp = (*env)->GetStaticMethodID(env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
                                        "initHelpMessage", "(Ljava/lang/String;)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
    NULL_CHECK(vmSelect = (*env)->GetStaticMethodID(env, cls, "appendVmSelectMessage",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
                                        "(Ljava/lang/String;Ljava/lang/String;)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
    NULL_CHECK(vmSynonym = (*env)->GetStaticMethodID(env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
                                        "appendVmSynonymMessage",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
                                        "(Ljava/lang/String;Ljava/lang/String;)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
    NULL_CHECK(vmErgo = (*env)->GetStaticMethodID(env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
                                        "appendVmErgoMessage", "(ZLjava/lang/String;)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
    NULL_CHECK(printHelp = (*env)->GetStaticMethodID(env, cls,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
                                        "printHelpMessage", "(Z)V"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
    jprogname = (*env)->NewStringUTF(env, _program_name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
    /* Initialize the usage message with the usual preamble */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
    (*env)->CallStaticVoidMethod(env, cls, initHelp, jprogname);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
    /* Assemble the other variant part of the usage */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
    if ((knownVMs[0].flag == VM_KNOWN) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
        (knownVMs[0].flag == VM_IF_SERVER_CLASS)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
      vm1 = (*env)->NewStringUTF(env, knownVMs[0].name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
      vm2 =  (*env)->NewStringUTF(env, knownVMs[0].name+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
      (*env)->CallStaticVoidMethod(env, cls, vmSelect, vm1, vm2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
    for (i=1; i<knownVMsCount; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
      if (knownVMs[i].flag == VM_KNOWN) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
        vm1 =  (*env)->NewStringUTF(env, knownVMs[i].name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
        vm2 =  (*env)->NewStringUTF(env, knownVMs[i].name+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
        (*env)->CallStaticVoidMethod(env, cls, vmSelect, vm1, vm2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
    for (i=1; i<knownVMsCount; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
      if (knownVMs[i].flag == VM_ALIASED_TO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
        vm1 =  (*env)->NewStringUTF(env, knownVMs[i].name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
        vm2 =  (*env)->NewStringUTF(env, knownVMs[i].alias+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
        (*env)->CallStaticVoidMethod(env, cls, vmSynonym, vm1, vm2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
    /* The first known VM is the default */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
      jboolean isServerClassMachine = ServerClassMachine();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
      const char* defaultVM  =  knownVMs[0].name+1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
      if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) && isServerClassMachine) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1546
        defaultVM = knownVMs[0].server_class+1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1549
      vm1 =  (*env)->NewStringUTF(env, defaultVM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
      (*env)->CallStaticVoidMethod(env, cls, vmErgo, isServerClassMachine,  vm1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
    /* Complete the usage message and print to stderr*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
    (*env)->CallStaticVoidMethod(env, cls, printHelp, JNI_TRUE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
  }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
  return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
 * Read the jvm.cfg file and fill the knownJVMs[] array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
 * The functionality of the jvm.cfg file is subject to change without
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
 * notice and the mechanism will be removed in the future.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
 * The lexical structure of the jvm.cfg file is as follows:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
 *     jvmcfg         :=  { vmLine }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
 *     vmLine         :=  knownLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
 *                    |   aliasLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
 *                    |   warnLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
 *                    |   ignoreLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
 *                    |   errorLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
 *                    |   predicateLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
 *                    |   commentLine
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
 *     knownLine      :=  flag  "KNOWN"                  EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
 *     warnLine       :=  flag  "WARN"                   EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
 *     ignoreLine     :=  flag  "IGNORE"                 EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
 *     errorLine      :=  flag  "ERROR"                  EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
 *     aliasLine      :=  flag  "ALIASED_TO"       flag  EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1580
 *     predicateLine  :=  flag  "IF_SERVER_CLASS"  flag  EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1581
 *     commentLine    :=  "#" text                       EOL
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
 *     flag           :=  "-" identifier
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
 * The semantics are that when someone specifies a flag on the command line:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
 * - if the flag appears on a knownLine, then the identifier is used as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
 *   the name of the directory holding the JVM library (the name of the JVM).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
 * - if the flag appears as the first flag on an aliasLine, the identifier
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
 *   of the second flag is used as the name of the JVM.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
 * - if the flag appears on a warnLine, the identifier is used as the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
 *   name of the JVM, but a warning is generated.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
 * - if the flag appears on an ignoreLine, the identifier is recognized as the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
 *   name of a JVM, but the identifier is ignored and the default vm used
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
 * - if the flag appears on an errorLine, an error is generated.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
 * - if the flag appears as the first flag on a predicateLine, and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
 *   the machine on which you are running passes the predicate indicated,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
 *   then the identifier of the second flag is used as the name of the JVM,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
 *   otherwise the identifier of the first flag is used as the name of the JVM.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
 * If no flag is given on the command line, the first vmLine of the jvm.cfg
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
 * file determines the name of the JVM.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1600
 * PredicateLines are only interpreted on first vmLine of a jvm.cfg file,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
 * since they only make sense if someone hasn't specified the name of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
 * JVM on the command line.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
 * The intent of the jvm.cfg file is to allow several JVM libraries to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
 * be installed in different subdirectories of a single JRE installation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1606
 * for space-savings and convenience in testing.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
 * The intent is explicitly not to provide a full aliasing or predicate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
 * mechanism.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1609
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1610
jint
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
ReadKnownVMs(const char *jrepath, const char * arch, jboolean speculative)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
    FILE *jvmCfg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
    char jvmCfgName[MAXPATHLEN+20];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
    char line[MAXPATHLEN+20];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
    int cnt = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
    int lineno = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
    jlong start, end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
    int vmType;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
    char *tmpPtr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
    char *altVMName = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
    char *serverClassVMName = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
    static char *whiteSpace = " \t";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
        start = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1627
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
    JLI_StrCpy(jvmCfgName, jrepath);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
    JLI_StrCat(jvmCfgName, FILESEP "lib" FILESEP);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
    JLI_StrCat(jvmCfgName, arch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
    JLI_StrCat(jvmCfgName, FILESEP "jvm.cfg");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
    jvmCfg = fopen(jvmCfgName, "r");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
    if (jvmCfg == NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
      if (!speculative) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1636
        JLI_ReportErrorMessage(CFG_ERROR6, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
        exit(1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
      } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
    while (fgets(line, sizeof(line), jvmCfg) != NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
        vmType = VM_UNKNOWN;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
        lineno++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
        if (line[0] == '#')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
            continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
        if (line[0] != '-') {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1648
            JLI_ReportErrorMessage(CFG_WARN2, lineno, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
        if (cnt >= knownVMsLimit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
            GrowKnownVMs(cnt);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
        line[JLI_StrLen(line)-1] = '\0'; /* remove trailing newline */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
        tmpPtr = line + JLI_StrCSpn(line, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
        if (*tmpPtr == 0) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1656
            JLI_ReportErrorMessage(CFG_WARN3, lineno, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
            /* Null-terminate this string for JLI_StringDup below */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
            *tmpPtr++ = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
            tmpPtr += JLI_StrSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
            if (*tmpPtr == 0) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1662
                JLI_ReportErrorMessage(CFG_WARN3, lineno, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
                if (!JLI_StrCCmp(tmpPtr, "KNOWN")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
                    vmType = VM_KNOWN;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
                } else if (!JLI_StrCCmp(tmpPtr, "ALIASED_TO")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
                    tmpPtr += JLI_StrCSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
                    if (*tmpPtr != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
                        tmpPtr += JLI_StrSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
                    if (*tmpPtr == 0) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1672
                        JLI_ReportErrorMessage(CFG_WARN3, lineno, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
                        /* Null terminate altVMName */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
                        altVMName = tmpPtr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
                        tmpPtr += JLI_StrCSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
                        *tmpPtr = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
                        vmType = VM_ALIASED_TO;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
                } else if (!JLI_StrCCmp(tmpPtr, "WARN")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
                    vmType = VM_WARN;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
                } else if (!JLI_StrCCmp(tmpPtr, "IGNORE")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
                    vmType = VM_IGNORE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
                } else if (!JLI_StrCCmp(tmpPtr, "ERROR")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
                    vmType = VM_ERROR;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
                } else if (!JLI_StrCCmp(tmpPtr, "IF_SERVER_CLASS")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
                    tmpPtr += JLI_StrCSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
                    if (*tmpPtr != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
                        tmpPtr += JLI_StrSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
                    if (*tmpPtr == 0) {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1692
                        JLI_ReportErrorMessage(CFG_WARN4, lineno, jvmCfgName);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
                        /* Null terminate server class VM name */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
                        serverClassVMName = tmpPtr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
                        tmpPtr += JLI_StrCSpn(tmpPtr, whiteSpace);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
                        *tmpPtr = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1698
                        vmType = VM_IF_SERVER_CLASS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
                } else {
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1701
                    JLI_ReportErrorMessage(CFG_WARN5, lineno, &jvmCfgName[0]);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
                    vmType = VM_KNOWN;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
        JLI_TraceLauncher("jvm.cfg[%d] = ->%s<-\n", cnt, line);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
        if (vmType != VM_UNKNOWN) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
            knownVMs[cnt].name = JLI_StringDup(line);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
            knownVMs[cnt].flag = vmType;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
            switch (vmType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
            case VM_ALIASED_TO:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
                knownVMs[cnt].alias = JLI_StringDup(altVMName);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
                JLI_TraceLauncher("    name: %s  vmType: %s  alias: %s\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
                   knownVMs[cnt].name, "VM_ALIASED_TO", knownVMs[cnt].alias);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1718
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1719
            case VM_IF_SERVER_CLASS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1720
                knownVMs[cnt].server_class = JLI_StringDup(serverClassVMName);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1721
                JLI_TraceLauncher("    name: %s  vmType: %s  server_class: %s\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1722
                    knownVMs[cnt].name, "VM_IF_SERVER_CLASS", knownVMs[cnt].server_class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1723
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
            cnt++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
    fclose(jvmCfg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
    knownVMsCount = cnt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
    if (JLI_IsTraceLauncher()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
        end   = CounterGet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
        printf("%ld micro seconds to parse jvm.cfg\n",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1734
               (long)(jint)Counter2Micros(end-start));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1735
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1736
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1737
    return cnt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1738
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1739
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
GrowKnownVMs(int minimum)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
    struct vmdesc* newKnownVMs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
    int newMax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
    newMax = (knownVMsLimit == 0 ? INIT_MAX_KNOWN_VMS : (2 * knownVMsLimit));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
    if (newMax <= minimum) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
        newMax = minimum;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
    newKnownVMs = (struct vmdesc*) JLI_MemAlloc(newMax * sizeof(struct vmdesc));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
    if (knownVMs != NULL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
        memcpy(newKnownVMs, knownVMs, knownVMsLimit * sizeof(struct vmdesc));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
    JLI_MemFree(knownVMs);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
    knownVMs = newKnownVMs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
    knownVMsLimit = newMax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
/* Returns index of VM or -1 if not found */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
static int
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
KnownVMIndex(const char* name)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
    int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
    if (JLI_StrCCmp(name, "-J") == 0) name += 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
    for (i = 0; i < knownVMsCount; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
        if (!JLI_StrCmp(name, knownVMs[i].name)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
            return i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
    return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
FreeKnownVMs()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
    int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
    for (i = 0; i < knownVMsCount; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
        JLI_MemFree(knownVMs[i].name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
        knownVMs[i].name = NULL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
    JLI_MemFree(knownVMs);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
 * Displays the splash screen according to the jar file name
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
 * and image file names stored in environment variables
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
ShowSplashScreen()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
    const char *jar_name = getenv(SPLASH_JAR_ENV_ENTRY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
    const char *file_name = getenv(SPLASH_FILE_ENV_ENTRY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
    int data_size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
    void *image_data;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
    if (jar_name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
        image_data = JLI_JarUnpackFile(jar_name, file_name, &data_size);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
        if (image_data) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
            DoSplashInit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
            DoSplashLoadMemory(image_data, data_size);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
            JLI_MemFree(image_data);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
    } else if (file_name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
        DoSplashInit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
        DoSplashLoadFile(file_name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
    DoSplashSetFileJarName(file_name, jar_name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
     * Done with all command line processing and potential re-execs so
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
     * clean up the environment.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
    (void)UnsetEnv(ENV_ENTRY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
    (void)UnsetEnv(SPLASH_FILE_ENV_ENTRY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
    (void)UnsetEnv(SPLASH_JAR_ENV_ENTRY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
    JLI_MemFree(splash_jar_entry);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
    JLI_MemFree(splash_file_entry);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
const char*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
GetDotVersion()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
    return _dVersion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
const char*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
GetFullVersion()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
    return _fVersion;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
const char*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
GetProgramName()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
    return _program_name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
const char*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
GetLauncherName()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
    return _launcher_name;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
jint
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
GetErgoPolicy()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
    return _ergo_policy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
IsJavaArgs()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
    return _is_java_args;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1862
static jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
IsWildCardEnabled()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
    return _wc_enabled;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
static int
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
ContinueInNewThread(InvocationFunctions* ifn, int argc,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
                     char **argv, char *jarfile, char *classname, int ret)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
     * If user doesn't specify stack size, check if VM has a preference.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
     * Note that HotSpot no longer supports JNI_VERSION_1_1 but it will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
     * return its default stack size through the init args structure.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
    if (threadStackSize == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
      struct JDK1_1InitArgs args1_1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
      memset((void*)&args1_1, 0, sizeof(args1_1));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
      args1_1.version = JNI_VERSION_1_1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
      ifn->GetDefaultJavaVMInitArgs(&args1_1);  /* ignore return value */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
      if (args1_1.javaStackSize > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
         threadStackSize = args1_1.javaStackSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
    { /* Create a new thread to create JVM and invoke main method */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
      JavaMainArgs args;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
      int rslt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
      args.argc = argc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
      args.argv = argv;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
      args.jarfile = jarfile;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
      args.classname = classname;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
      args.ifn = *ifn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
      rslt = ContinueInNewThread0(JavaMain, threadStackSize, (void*)&args);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
      /* If the caller has deemed there is an error we
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
       * simply return that, otherwise we return the value of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
       * the callee
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
       */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
      return (ret != 0) ? ret : rslt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
static void
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
DumpState()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
    if (!JLI_IsTraceLauncher()) return ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
    printf("Launcher state:\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
    printf("\tdebug:%s\n", (JLI_IsTraceLauncher() == JNI_TRUE) ? "on" : "off");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
    printf("\tjavargs:%s\n", (_is_java_args == JNI_TRUE) ? "on" : "off");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
    printf("\tprogram name:%s\n", GetProgramName());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
    printf("\tlauncher name:%s\n", GetLauncherName());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
    printf("\tjavaw:%s\n", (IsJavaw() == JNI_TRUE) ? "on" : "off");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1917
    printf("\tfullversion:%s\n", GetFullVersion());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
    printf("\tdotversion:%s\n", GetDotVersion());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
    printf("\tergo_policy:");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
    switch(GetErgoPolicy()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
        case NEVER_SERVER_CLASS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
            printf("NEVER_ACT_AS_A_SERVER_CLASS_MACHINE\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
        case ALWAYS_SERVER_CLASS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
            printf("ALWAYS_ACT_AS_A_SERVER_CLASS_MACHINE\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
            printf("DEFAULT_ERGONOMICS_POLICY\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1930
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
 * Return JNI_TRUE for an option string that has no effect but should
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
 * _not_ be passed on to the vm; return JNI_FALSE otherwise.  On
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
 * Solaris SPARC, this screening needs to be done if:
4340
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
  1936
 *    -d32 or -d64 is passed to a binary with an unmatched data model
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
  1937
 *    (the exec in CreateExecutionEnvironment removes -d<n> options and points the
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
  1938
 *    exec to the proper binary).  In the case of when the data model and the
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
  1939
 *    requested version is matched, an exec would not occur, and these options
ec6ba551fa78 6367077: Purge LD_LIBRARY_PATH usage from the launcher
ksrini
parents: 3054
diff changeset
  1940
 *    were erroneously passed to the vm.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
jboolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
RemovableOption(char * option)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
  /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
   * Unconditionally remove both -d32 and -d64 options since only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
   * the last such options has an effect; e.g.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
   * java -d32 -d64 -d32 -version
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
   * is equivalent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
   * java -d32 -version
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1952
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1953
  if( (JLI_StrCCmp(option, "-d32")  == 0 ) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
      (JLI_StrCCmp(option, "-d64")  == 0 ) )
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
    return JNI_TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
  else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
    return JNI_FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
 * A utility procedure to always print to stderr
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
void
1145
404b11752c57 6685121: (launcher) make ReportErrorMessages accessible by other launcher subsystems
ksrini
parents: 399
diff changeset
  1964
JLI_ReportMessage(const char* fmt, ...)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1966
    va_list vl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1967
    va_start(vl, fmt);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
    vfprintf(stderr, fmt, vl);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
    fprintf(stderr, "\n");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
    va_end(vl);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
}