IKVM.Tools.Runner.Exporter.IkvmExporterLauncher Class Reference

Provides methods to launch the IKVM importer. More...

Inheritance diagram for IKVM.Tools.Runner.Exporter.IkvmExporterLauncher:

Public Member Functions
	IkvmExporterLauncher (string toolPath, IIkvmToolDiagnosticEventListener listener)
	Initializes a new instance.
	IkvmExporterLauncher (IIkvmToolDiagnosticEventListener listener)
	Initializes a new instance.
	IkvmExporterLauncher (string toolPath)
	Initializes a new instance.
async Task< int >	ExecuteAsync (IkvmExporterOptions options, CancellationToken cancellationToken=default)
	Executes the compiler.
Public Member Functions inherited from IKVM.Tools.Runner.IkvmToolLauncher
	IkvmToolLauncher (string toolName, string toolPath, IIkvmToolDiagnosticEventListener listener)
	Initializes a new instance.
string?	GetToolExe ()
	Gets the path to executable for the given environment.

Additional Inherited Members
Protected Member Functions inherited from IKVM.Tools.Runner.IkvmToolLauncher
ValueTask	LogEventAsync (in IkvmToolDiagnosticEvent @event, CancellationToken cancellationToken)
	Logs an event if a listener is provided.
ValueTask	LogEventAsync (IkvmToolDiagnosticEventLevel level, string message, string[] args, CancellationToken cancellationToken)
	Logs an anonymous event if a listener is provided.
ValueTask	ParseAndLogEventAsync (string line, CancellationToken cancellationToken)
	Parses the line and logs it.
IkvmToolDiagnosticEvent	ParseEvent (string line)
	Parse a line of JSON tool output into a diagnostic event.

Detailed Description

Provides methods to launch the IKVM importer.

Definition at line 21 of file IkvmExporterLauncher.cs.

Constructor & Destructor Documentation

IkvmExporterLauncher() [1/3]

IKVM.Tools.Runner.Exporter.IkvmExporterLauncher.IkvmExporterLauncher	(	string	toolPath,
		IIkvmToolDiagnosticEventListener	listener )

Initializes a new instance.

Parameters

toolPath
listener

Definition at line 32 of file IkvmExporterLauncher.cs.

                                                                                                :
            base(TOOLNAME, toolPath, listener)
        {
 
        }

IkvmExporterLauncher() [2/3]

IKVM.Tools.Runner.Exporter.IkvmExporterLauncher.IkvmExporterLauncher

(

IIkvmToolDiagnosticEventListener

listener

)

Initializes a new instance.

Parameters

listener

Definition at line 42 of file IkvmExporterLauncher.cs.

                                                                               :
            this(TOOLPATH, listener)
        {
 
        }

IkvmExporterLauncher() [3/3]

IKVM.Tools.Runner.Exporter.IkvmExporterLauncher.IkvmExporterLauncher

(

string

toolPath

)

Initializes a new instance.

Parameters

toolPath

Definition at line 52 of file IkvmExporterLauncher.cs.

                                                     :
            this(toolPath, new IkvmToolNullDiagnosticListener())
        {
 
        }

Member Function Documentation

ExecuteAsync()

async Task< int > IKVM.Tools.Runner.Exporter.IkvmExporterLauncher.ExecuteAsync	(	IkvmExporterOptions	options,
		CancellationToken	cancellationToken = default )

Executes the compiler.

Parameters

options
cancellationToken

Returns

Exceptions

NullReferenceException

Definition at line 65 of file IkvmExporterLauncher.cs.

        {
            if (options is null)
                throw new ArgumentNullException(nameof(options));
 
            var args = new List<string>();
 
            if (options.Output is not null)
            {
                args.Add("--out");
                args.Add(options.Output);
            }
 
            if (options.References is not null)
            {
                foreach (var reference in options.References)
                {
                    args.Add("--reference");
                    args.Add(reference);
                }
            }
 
            if (options.Namespaces is not null)
            {
                foreach (var ns in options.Namespaces)
                {
                    args.Add("--ns");
                    args.Add(ns);
                }
            }
 
            if (options.Shared)
                args.Add("--shared");
 
            if (options.NoStdLib)
                args.Add("--nostdlib");
 
            if (options.Forwarders)
                args.Add("--forwarders");
 
            if (options.IncludeNonPublicTypes)
                args.Add("--non-public-types");
 
            if (options.IncludeNonPublicInterfaces)
                args.Add("--non-public-interfaces");
 
            if (options.IncludeNonPublicMembers)
                args.Add("--non-public-members");
 
            if (options.IncludeParameterNames)
                args.Add("--parameters");
 
            if (options.Bootstrap)
                args.Add("--bootstrap");
 
            if (options.Lib is not null)
            {
                foreach (var i in options.Lib)
                {
                    args.Add("--lib");
                    args.Add(i);
                }
            }
 
            if (options.ContinueOnError)
                args.Add("--skiperror");
 
            args.Add("--log");
            args.Add("json,file=stderr");
 
            if (options.Input is not null)
                args.Add(options.Input);
 
            // path to the temporary response file
            var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, new CancellationToken());
 
            // combine manual cancellation with timeout
            var ctk = cts.Token;
            if (options.Timeout != Timeout.Infinite)
                ctk = CancellationTokenSource.CreateLinkedTokenSource(ctk, new CancellationTokenSource(options.Timeout).Token).Token;
 
            try
            {
                // locate EXE file
                string? wrap = null;
                var exe = GetToolExe();
                if (exe is null || File.Exists(exe) == false)
                    throw new FileNotFoundException($"Could not locate tool at '{exe}'.");
 
                // executing on Unix requires some considerations
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    // tool executables on Unix need to be invoked through Mono
                    if (exe.EndsWith(".exe"))
                    {
                        wrap = "mono";
                    }
                    else
                    {
                        // else we need to ensure executable bit is set
 
                        try
                        {
                            var psx = Mono.Unix.UnixFileSystemInfo.GetFileSystemEntry(exe);
                            if (psx.FileAccessPermissions.HasFlag(Mono.Unix.FileAccessPermissions.UserExecute) == false)
                                psx.FileAccessPermissions |= Mono.Unix.FileAccessPermissions.UserExecute;
                        }
                        catch (Exception e)
                        {
                            throw new IkvmToolException($"Could not set user executable bit on '{exe}'.", e);
                        }
                    }
                }
 
                // configure CLI, with wrapper if required
                Command cli;
                if (wrap != null)
                {
                    cli = Cli.Wrap(wrap);
                    args.Insert(0, exe);
                }
                else
                    cli = Cli.Wrap(exe);
 
                // set configuration of CLI
                cli = cli.WithWorkingDirectory(Environment.CurrentDirectory);
                cli = cli.WithArguments(args);
                cli = cli.WithValidation(CommandResultValidation.None);
 
                // log the command we're about to run
                await LogEventAsync(IkvmToolDiagnosticEventLevel.Trace, "Executing {0} {1}", [cli.TargetFilePath, cli.Arguments], ctk);
 
                // send output to MSBuild (TODO, replace with binary reading)
                cli = cli.WithStandardErrorPipe(PipeTarget.ToDelegate(l => ParseAndLogEventAsync(l, cancellationToken).AsTask()));
 
                // execute command
                var pid = cli.ExecuteAsync(ctk);
 
                // windows provides special support for killing subprocesses on termination of parent
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                    try
                    {
                        if (pid.Task.IsCompleted == false)
                            WindowsChildProcessTracker.AddProcess(Process.GetProcessById(pid.ProcessId));
                    }
                    catch
                    {
                        await LogEventAsync(IkvmToolDiagnosticEventLevel.Error, "Failed to attach child process.", [], ctk);
                    }
 
                // wait for the execution to finish
                var ret = await pid;
 
                // check that we exited successfully
                return ret.ExitCode;
            }
            finally
            {
                // cancel the execution if it is still running
                if (cts != null)
                    cts.Cancel();
            }
        }

---

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

• src/IKVM.Tools.Runner/Exporter/IkvmExporterLauncher.cs