IKVM.Runtime.Launcher Class Reference

Utility for launching a Java class from a main entry point. Parses JVM command line options, then passes the remainder through to the underlying Java main method. More...

Static Public Member Functions
static int	Run (Assembly assembly, string main, bool jar, string[] args, string rarg, IDictionary< string, string > properties)
	Services as the managed entry point jump for a Java executable.

Detailed Description

Utility for launching a Java class from a main entry point. Parses JVM command line options, then passes the remainder through to the underlying Java main method.

Definition at line 28 of file Launcher.cs.

Member Function Documentation

Run()

static int IKVM.Runtime.Launcher.Run ( Assembly assembly, string main, bool jar, string[] args, string rarg, IDictionary< string, string > properties )

static

Services as the managed entry point jump for a Java executable.

Parameters

assembly
main
jar
args
rarg
properties

Returns

Definition at line 263 of file Launcher.cs.

        {
            if (args is null)
                throw new ArgumentNullException(nameof(args));
 
#if FIRST_PASS || IMPORTER
            throw new NotImplementedException();
#else
            HandleDebugTrace();
 
            // initialize attribute parsing
            var initialize = properties != null ? new Dictionary<string, string>(properties) : new Dictionary<string, string>();
            var showversion = false;
            var exit = false;
            var hasMainArg = false;
            var jvmArgs = args.Where(i => rarg != null).Where(i => i.StartsWith(rarg)).Select(i => i.Substring(rarg.Length)).ToList();
            var appArgs = args.Where(i => rarg == null || i.StartsWith(rarg) == false).ToList();
            var appArgsReset = false;
 
            // classpath from environment by default
            initialize["java.class.path"] = ".";
            if (Environment.GetEnvironmentVariable("CLASSPATH") is string cp && !string.IsNullOrEmpty(cp))
                initialize["java.class.path"] = string.Join(Path.PathSeparator.ToString(), Glob(cp.Split(Path.PathSeparator)));
 
            // ikvm.home.root from environment by default
            if (Environment.GetEnvironmentVariable("IKVM_HOME_ROOT") is string ihr && !string.IsNullOrEmpty(ihr))
                initialize["ikvm.home.root"] = ihr;
 
            // ikvm.home from environment by default
            if (Environment.GetEnvironmentVariable("IKVM_HOME") is string ih && !string.IsNullOrEmpty(ih))
                initialize["ikvm.home"] = ih;
 
            // process through each incoming argument
            for (var jvmArg = jvmArgs.GetEnumerator(); jvmArg.MoveNext();)
            {
                var arg = jvmArg.Current.AsSpan();
                if (hasMainArg == false && arg.StartsWith("-".AsSpan()))
                {
                    // define system property
                    if (arg.StartsWith("-D".AsSpan()))
                    {
                        var def = arg.Slice(2);
                        var sep = def.IndexOf('=');
                        var key = sep > -1 ? def.Slice(0, sep) : def;
                        var val = sep > -1 ? def.Slice(sep + 1) : "".AsSpan();
                        initialize[key.ToString()] = val.ToString();
                        continue;
                    }
 
                    if (ArgEquals(arg, "-ea") || ArgEquals(arg, "-enableassertions"))
                    {
                        Assertions.EnableAssertions();
                        continue;
                    }
 
                    if (arg.StartsWith("-ea:".AsSpan()) || arg.StartsWith("-enableassertions:".AsSpan()))
                    {
                        if (arg.IndexOf(':') is int v && v > -1)
                            Assertions.EnableAssertions(arg.Slice(v + 1).ToString());
                    }
 
                    if (ArgEquals(arg, "-da") || ArgEquals(arg, "-disableassertions"))
                    {
                        Assertions.DisableAssertions();
                        continue;
                    }
 
                    if (arg.StartsWith("-da:".AsSpan()) || arg.StartsWith("-disableassertions:".AsSpan()))
                    {
                        if (arg.IndexOf(':') is int v && v > -1)
                            Assertions.DisableAssertions(arg.Slice(v + 1).ToString());
                    }
 
                    if (ArgEquals(arg, "-esa") || ArgEquals(arg, "-enablesystemassertions"))
                    {
                        Assertions.EnableSystemAssertions();
                        continue;
                    }
 
                    if (ArgEquals(arg, "-dsa") || ArgEquals(arg, "-disablesystemassertions"))
                    {
                        Assertions.DisableSystemAssertions();
                        continue;
                    }
 
                    if (ArgEquals(arg, "-cp") || ArgEquals(arg, "-classpath"))
                    {
                        if (jvmArg.MoveNext() == false)
                        {
                            Console.Error.WriteLine("Error: {0} requires class path specification", arg.ToString());
                            PrintHelp();
                            return 1;
                        }
 
                        initialize["java.class.path"] = string.Join(Path.PathSeparator.ToString(), Glob(jvmArg.Current.Split(Path.PathSeparator)));
                        continue;
                    }
 
                    if (ArgEquals(arg, "-version"))
                    {
                        showversion = true;
                        exit = true;
                        continue;
                    }
 
                    if (ArgEquals(arg, "-showversion"))
                    {
                        showversion = true;
                        continue;
                    }
 
                    if (ArgEquals(arg, "-jar"))
                    {
                        jar = true;
                        continue;
                    }
 
                    if (ArgEquals(arg, "-?") || ArgEquals(arg, "-help"))
                    {
                        PrintHelp();
                        return 1;
                    }
 
                    if (ArgEquals(arg, "-X"))
                    {
                        PrintXHelp();
                        return 1;
                    }
 
                    if (ArgEquals(arg, "-Xtime"))
                    {
                        Console.Error.WriteLine("Unrecognized option: {0}", arg.ToString());
                        return 1;
                    }
 
                    if (ArgEquals(arg, "-Xbreak"))
                    {
                        Debugger.Break();
                        continue;
                    }
 
                    if (ArgEquals(arg, "-Xverify"))
                    {
                        JVM.RelaxedVerification = false;
                        continue;
                    }
 
                    if (arg.StartsWith("-Xreference:".AsSpan()))
                    {
                        if (arg.IndexOf(':') is int v && v > -1)
                            AddBootClassPathAssembly(Assembly.LoadFrom(arg.Slice(v + 1).ToString()));
 
                        continue;
                    }
 
                    if (ArgEquals(arg, "-XX:+AllowNonVirtualCalls"))
                    {
                        JVM.AllowNonVirtualCalls = true;
                        continue;
                    }
 
                    if (arg.StartsWith("-Xms".AsSpan()) ||
                        arg.StartsWith("-Xmx".AsSpan()) ||
                        arg.StartsWith("-Xmn".AsSpan()) ||
                        arg.StartsWith("-Xss".AsSpan()) ||
                        arg.StartsWith("-XX:".AsSpan()) ||
                        arg.StartsWith("-mn".AsSpan()) ||
                        arg.StartsWith("-ms".AsSpan()) ||
                        arg.StartsWith("-mx".AsSpan()) ||
                        ArgEquals(arg, "-Xmixed") ||
                        ArgEquals(arg, "-Xint") ||
                        ArgEquals(arg, "-Xincgc") ||
                        ArgEquals(arg, "-Xbatch") ||
                        ArgEquals(arg, "-Xfuture") ||
                        ArgEquals(arg, "-Xrs") ||
                        ArgEquals(arg, "-Xcheck:jni") ||
                        ArgEquals(arg, "-Xshare:off") ||
                        ArgEquals(arg, "-Xshare:auto") ||
                        ArgEquals(arg, "-Xshare:on"))
                    {
                        Console.Error.WriteLine("Ignoring unrecognized option: {0}", arg.ToString());
                        continue;
                    }
 
                    Console.Error.WriteLine("Unrecognized option: {0}", arg.ToString());
                    return 1;
                }
                else if (hasMainArg == false)
                {
                    hasMainArg = true;
                    main = arg.ToString();
                    continue;
                }
                else
                {
                    // indicate we're resetting the application arguments
                    if (appArgsReset == false)
                    {
                        appArgsReset = true;
                        appArgs.Clear();
                    }
 
                    // append new application argument
                    appArgs.Add(arg.ToString());
                    continue;
                }
            }
 
            try
            {
                // if a jar file is specified, we're going to set the classpath to the jar itself
                if (jar)
                    initialize["java.class.path"] = main;
 
                // like the JDK we don't quote the args (even if they contain spaces)
                initialize["sun.java.command"] = string.Join(" ", Prepend(appArgs, main));
                initialize["sun.java.launcher"] = "SUN_STANDARD";
 
                // apply the loaded VM properties
                SetUserProperties(initialize);
 
                // VM initialization, configures system properties, done before any static initializers
                JVM.Init();
 
                // ensure the entry assembly is added to the classpath
                // we do this after Init since it triggers the VFS
                if (assembly != null)
                    AddBootClassPathAssembly(assembly);
 
                // first entry into base assembly
                EnterMainThread();
 
                // we were instructed to show the version
                if (showversion)
                    PrintVersion();
 
                // we were instructed to exit immediately
                if (exit)
                    return 0;
 
                // we require a main argument, either a class name or jar file
                if (main == null)
                {
                    PrintHelp();
                    return 1;
                }
 
                // process the main argument, returning the true value, and resetting the command property to match
                var clazz = LauncherHelperAccessor.InvokeCheckAndLoadMain(true, jar ? 2 : 1, main);
                SystemAccessor.InvokeSetProperty("sun.java.command", initialize["sun.java.command"]);
 
                // find the main method and ensure it is accessible
                var method = ClassAccessor.InvokeGetMethod(clazz, "main", ClassAccessor.InitArray(JVM.Context.ClassLoaderFactory.GetJavaTypeFromType(typeof(string[])).ClassObject), CallerIDAccessor.InvokeCreate(typeof(Launcher).TypeHandle));
                MethodAccessor.InvokeSetAccessible(method, true);
 
                try
                {
                    // invoke main method, which is responsible for exit
                    MethodAccessor.InvokeInvoke(method, null, new[] { appArgs.ToArray() });
                    return 0;
                }
                catch (java.lang.reflect.InvocationTargetException e)
                {
                    // we want to unwrap the cause to report to the user
                    ExceptionDispatchInfo.Capture(e.getCause()).Throw();
                    throw null;
                }
            }
            catch (Exception e)
            {
                var thread = ThreadAccessor.InvokeCurrentThread();
                ThreadGroupAccessor.InvokeUncaughtException(ThreadAccessor.InvokeGetThreadGroup(thread), thread, ikvm.runtime.Util.mapException(e));
            }
            finally
            {
                ExitMainThread();
            }
 
            return 1;
#endif
        }

---

The documentation for this class was generated from the following file:

• src/IKVM.Runtime/Launcher.cs