Inheritance diagram for IKVM.Tools.Importer.ImportCommand:

Public Member Functions
	ImportCommand (bool root=true)
	Initializes a new instance.

Properties
Argument< FileInfo[]>	InputsArgument `[get, set]`

Option< FileInfo?>	OutputOption `[get, set]`

Option< string?>	AssemblyNameOption `[get, set]`

Option< string?>	TargetOption `[get, set]`

Option< string?>	PlatformOption `[get, set]`

Option< string?>	ApartmentOption `[get, set]`

Option< bool >	NoGlobbingOption `[get, set]`

Option< string[]>	PropertiesOption `[get, set]`

Option< string?>	EnableAssertionsOption `[get, set]`

Option< string?>	DisableAssertionsOption `[get, set]`

Option< bool >	RemoveAssertionsOption `[get, set]`

Option< string >	MainClassOption `[get, set]`

Option< string[]>	ReferenceOption `[get, set]`

Option< string[]>	RecurseOption `[get, set]`

Option< string[]>	ResourceOption `[get, set]`

Option< string[]>	ExternalResourceOption `[get, set]`

Option< bool >	NoJNIOption `[get, set]`

Option< FileInfo?>	ExcludeOption `[get, set]`

Option< string?>	VersionOption `[get, set]`

Option< string?>	FileVersionOption `[get, set]`

Option< FileInfo?>	Win32IconOption `[get, set]`

Option< FileInfo?>	Win32ManifestOption `[get, set]`

Option< FileInfo?>	KeyFileOption `[get, set]`

Option< string?>	KeyOption `[get, set]`

Option< bool >	DelaySignOption `[get, set]`

Option< string?>	DebugOption `[get, set]`

Option< bool >	DeterministicOption `[get, set]`

Option< bool >	OptimizeOption `[get, set]`

Option< DirectoryInfo?>	SourcePathOption `[get, set]`

Option< FileInfo?>	RemapOption `[get, set]`

Option< bool >	NoStackTraceInfoOption `[get, set]`

Option< bool >	RemoveUnusedPrivateFieldsOption `[get, set]`

Option< bool >	CompressResourcesOption `[get, set]`

Option< bool >	StrictFinalFieldSemanticsOption `[get, set]`

Option< string[]>	PrivatePackageOption `[get, set]`

Option< string[]>	PublicPackageOption `[get, set]`

Option< Diagnostic[]>	NoWarnOption `[get, set]`

Option< Diagnostic[]>	WarnAsErrorOption `[get, set]`

Option< FileInfo?>?	RuntimeOption `[get, set]`

Option< string?>	ClassLoaderOption `[get, set]`

Option< bool >?	SharedClassLoaderOption `[get, set]`

Option< string?>	BaseAddressOption `[get, set]`

Option< string?>	FileAlignOption `[get, set]`

Option< bool >	NoPeerCrossReferenceOption `[get, set]`

Option< bool >	NoStdLibOption `[get, set]`

Option< DirectoryInfo[]>	LibraryOption `[get, set]`

Option< bool >	NoAutoSerializationOption `[get, set]`

Option< bool >	HighEntropyVAOption `[get, set]`

Option< string[]>	ProxyOption `[get, set]`

Option< bool >	AllowNonVirtualCallsOption `[get, set]`

Option< bool >	StaticOption `[get, set]`

Option< bool >	NoJarStubsOption `[get, set]`

Option< FileInfo[]>	AssemblyAttributesOption `[get, set]`

Option< bool >	WarningLevel4Option `[get, set]`

Option< bool >	NoParameterReflectionOption `[get, set]`

Option< bool >?	BootstrapOption `[get, set]`

Option< string >?	LogOption `[get, set]`

Detailed Description

Definition at line 14 of file ImportCommand.cs.

Constructor & Destructor Documentation

◆ ImportCommand()

IKVM.Tools.Importer.ImportCommand.ImportCommand ( bool root = true )

Initializes a new instance.

Parameters

root

Definition at line 23 of file ImportCommand.cs.

        {
            Add(InputsArgument = new Argument<FileInfo[]>(
                name: "classOrJar",
                description: "Path or name of class or JAR file to import.")
                .LegalFilePathsOnly());
 
            Add(OutputOption = new Option<FileInfo?>(
                aliases: ["-out", "-o"],
                description: "Specify the output filename.")
                .LegalFilePathsOnly());
 
            Add(AssemblyNameOption = new Option<string?>(
                name: "-assembly",
                description: "Specify assembly name."));
 
            Add(TargetOption = new Option<string?>(
                name: "-target",
                description: "Specifies the format of the output file.",
                getDefaultValue: () => root ? "library" : null)
                .FromAmong("exe", "winexe", "library", "module"));
 
            Add(PlatformOption = new Option<string?>(
                name: "-platform",
                description: "Limit which platforms this code can run on: x86, x64, arm, anycpu32bitpreferred, or anycpu.\nThe default is anycpu.",
                getDefaultValue: () => root ? "anycpu" : null)
                .FromAmong("x86", "x64", "arm", "arm64", "anycpu32bitpreferred", "anycpu"));
 
            Add(ApartmentOption = new Option<string?>(
                name: "-apartment",
                description: "Apply STAThreadAttribute to main.",
                getDefaultValue: () => root ? "none" : null)
                .FromAmong("sta", "mta", "none"));
 
            Add(NoGlobbingOption = new Option<bool>(
                name: "-noglobbing",
                description: "Don't glob the arguments passed to main."));
 
            Add(PropertiesOption = new Option<string[]>(
                name: "-D",
                description: "Set system property (at runtime)."));
 
            Add(EnableAssertionsOption = new Option<string?>(
                aliases: ["-enableassertions", "-ea"],
                parseArgument: ParseOptionalString,
                isDefault: true,
                description: "Set system property to enable assertions.")
            {
                Arity = ArgumentArity.ZeroOrMore,
                IsRequired = false
            });
 
            Add(DisableAssertionsOption = new Option<string?>(
                aliases: ["-disableassertions", "-da"],
                parseArgument: ParseOptionalString,
                isDefault: true,
                description: "Set system property to disable assertions.")
            {
                Arity = ArgumentArity.ZeroOrMore,
                IsRequired = false
            });
 
            Add(RemoveAssertionsOption = new Option<bool>(
                name: "-removeassertions",
                description: "Remove all assert statements."));
 
            Add(MainClassOption = new Option<string>(
                name: "-main",
                description: "Specify the class containing the main method."));
 
            Add(ReferenceOption = new Option<string[]>(
                aliases: ["-reference", "-r"],
                description: "Reference an assembly."));
 
            Add(RecurseOption = new Option<string[]>(
                name: "-recurse",
                description: "Recurse directory and include matching file."));
 
            Add(ResourceOption = new Option<string[]>(
                 name: "-resource",
                 description: "Include file as Java resource.")
            {
                Arity = ArgumentArity.OneOrMore
            });
 
            Add(ExternalResourceOption = new Option<string[]>(
                aliases: ["-externalresource"],
                description: "Reference file as Java resource.")
            {
                Arity = ArgumentArity.OneOrMore
            });
 
            Add(NoJNIOption = new Option<bool>(
                name: "-nojni",
                description: "Do not generate JNI stub for native methods."));
 
            Add(ExcludeOption = new Option<FileInfo?>(
                name: "-exclude",
                description: "A file containing a list of classes to exclude.")
                .LegalFilePathsOnly());
 
            Add(VersionOption = new Option<string?>(
                name: "-version",
                description: "Specify assembly version."));
 
            Add(FileVersionOption = new Option<string?>(
                name: "-fileversion",
                description: "File version."));
 
            Add(Win32IconOption = new Option<FileInfo?>(
                name: "-win32icon",
                description: "Embed specified icon in output.")
                .LegalFilePathsOnly());
 
            Add(Win32ManifestOption = new Option<FileInfo?>(
                name: "-win32manifest",
                description: "Specify a Win32 manifest file (.xml).")
                .LegalFilePathsOnly());
 
            Add(KeyFileOption = new Option<FileInfo?>(
                aliases: ["-keyfile"],
                description: "Use keyfile to sign the assembly.")
                .LegalFilePathsOnly());
 
            Add(KeyOption = new Option<string?>(
                aliases: ["-key"],
                description: "Use keycontainer to sign the assembly."));
 
            Add(DelaySignOption = new Option<bool>(
                aliases: ["-delaysign"],
                description: "Delay-sign the assembly."));
 
            Add(DebugOption = new Option<string?>(
                aliases: ["-debug"],
                description: "Specify debugging type ('portable' is default)\n'portable' is a cross-platform format,\n'embedded' is a cross-platform format embedded into the target dll or exe.",
                getDefaultValue: () => root ? "portable" : null)
                .FromAmong("none", "portable", "embedded"));
 
            Add(DeterministicOption = new Option<bool>(
                aliases: ["-deterministic"],
                description: "Produce a deterministic assembly (including module version GUID and timestamp)."));
 
            Add(OptimizeOption = new Option<bool>(
                aliases: ["-optimize"],
                description: ""));
 
            Add(SourcePathOption = new Option<DirectoryInfo?>(
                aliases: ["-srcpath"],
                description: "Prepend path and package name to source file.")
                .LegalFilePathsOnly());
 
            Add(RemapOption = new Option<FileInfo?>(
                aliases: ["-remap"],
                description: "Specify a XML map file that rewrites entities.")
                .LegalFilePathsOnly());
 
            Add(NoStackTraceInfoOption = new Option<bool>(
                aliases: ["-nostacktraceinfo"],
                description: "Don't create metadata to emit rich stack traces."));
 
            Add(RemoveUnusedPrivateFieldsOption = new Option<bool>(
                aliases: ["-opt:fields"],
                description: "Remove unused private fields."));
 
            Add(CompressResourcesOption = new Option<bool>(
                aliases: ["-compressresources"],
                description: "Compress resources."));
 
            Add(StrictFinalFieldSemanticsOption = new Option<bool>(
                aliases: ["-strictfinalfieldsemantics"],
                description: " Don't allow final fields to be modified outside of initializer methods."));
 
            Add(PrivatePackageOption = new Option<string[]>(
                aliases: ["-privatepackage"],
                description: "Mark all classes with a package name starting with <prefix> as internal to the assembly."));
 
            Add(PublicPackageOption = new Option<string[]>(
                aliases: ["-publicpackage"],
                description: "Mark all classes with a package name starting with <prefix> as public to the assembly."));
 
            Add(NoWarnOption = new Option<Diagnostic[]>(
                aliases: ["-nowarn"],
                description: "Disable specific warning messages.",
                parseArgument: ParseDiagnosticArray));
 
            Add(WarnAsErrorOption = new Option<Diagnostic[]>(
                aliases: ["-warnaserror"],
                description: "Report all warnings as errors.",
                parseArgument: ParseDiagnosticArray));
 
            if (root)
                Add(RuntimeOption = new Option<FileInfo?>(
                    aliases: ["-runtime"],
                    description: "Path to the IKVM.Runtime assembly.")
                    .LegalFilePathsOnly());
 
            Add(ClassLoaderOption = new Option<string?>(
                aliases: ["-classloader"],
                description: "Set custom class loader class for assembly."));
 
            if (root)
                Add(SharedClassLoaderOption = new Option<bool>(
                    aliases: ["-sharedclassloader"],
                    description: "All targets below this level share a common class loader."));
 
            Add(BaseAddressOption = new Option<string?>(
                aliases: ["-baseaddress"],
                description: "Base address for the library to be built."));
 
            Add(FileAlignOption = new Option<string?>(
                aliases: ["-filealign"],
                description: "Specify the alignment used for output file."));
 
            Add(NoPeerCrossReferenceOption = new Option<bool>(
                aliases: ["-nopeercrossreference"],
                description: "Do not automatically cross reference all peers."));
 
            Add(NoStdLibOption = new Option<bool>(
                aliases: ["-nostdlib"],
                description: "Do not reference standard libraries"));
 
            Add(LibraryOption = new Option<DirectoryInfo[]>(
                aliases: ["-lib"],
                description: "Additional directories to search for references."));
 
            Add(NoAutoSerializationOption = new Option<bool>(
                aliases: ["-noautoserialization"],
                description: "Disable automatic .NET serialization support."));
 
            Add(HighEntropyVAOption = new Option<bool>(
                aliases: ["-highentropyva"],
                description: "Enable high entropy ASLR."));
 
            Add(ProxyOption = new Option<string[]>(
                aliases: ["-proxy"],
                description: "Generate proxies for specified class."));
 
            Add(AllowNonVirtualCallsOption = new Option<bool>(
                aliases: ["-XX:+AllowNonVirtualCalls"],
                description: "Allow non-virtual calls."));
 
            Add(StaticOption = new Option<bool>(
                aliases: ["-static"],
                description: "Disable dynamic binding."));
 
            Add(NoJarStubsOption = new Option<bool>(
                aliases: ["-nojarstubs"],
                description: "undocumented temporary option to mitigate risk."));
 
            Add(AssemblyAttributesOption = new Option<FileInfo[]>(
                aliases: ["-assemblyattributes"],
                description: "Read assembly custom attributes from specified class file.")
                .LegalFilePathsOnly());
 
            Add(WarningLevel4Option = new Option<bool>(
                aliases: ["-w4"],
                description: "Undocumented option to always warn if a class isn't found."));
 
            Add(NoParameterReflectionOption = new Option<bool>(
                aliases: ["-noparameterreflection"],
                description: "Undocumented option to compile core class libraries with, to disable MethodParameter attribute."));
 
            if (root)
                Add(BootstrapOption = new Option<bool>(
                    aliases: ["-bootstrap"],
                    description: "Undocumented option to compile core class libraries with, to allow creation of base class libraries."));
 
            if (root)
                Add(LogOption = new Option<string>(
                    aliases: ["-log"],
                    getDefaultValue: () => "text",
                    description: "Logging options."));
 
            ResourceOption.AddValidator(ValidateResource);
        }

Property Documentation

◆ AllowNonVirtualCallsOption

Option<bool> IKVM.Tools.Importer.ImportCommand.AllowNonVirtualCallsOption

getset

Definition at line 456 of file ImportCommand.cs.

456{ get; set; }

◆ ApartmentOption

Option<string?> IKVM.Tools.Importer.ImportCommand.ApartmentOption

getset

Definition at line 368 of file ImportCommand.cs.

368{ get; set; }

◆ AssemblyAttributesOption

Option<FileInfo[]> IKVM.Tools.Importer.ImportCommand.AssemblyAttributesOption

getset

Definition at line 462 of file ImportCommand.cs.

462{ get; set; }

◆ AssemblyNameOption

Option<string?> IKVM.Tools.Importer.ImportCommand.AssemblyNameOption

getset

Definition at line 362 of file ImportCommand.cs.

362{ get; set; }

◆ BaseAddressOption

Option<string?> IKVM.Tools.Importer.ImportCommand.BaseAddressOption

getset

Definition at line 440 of file ImportCommand.cs.

440{ get; set; }

◆ BootstrapOption

Option<bool>? IKVM.Tools.Importer.ImportCommand.BootstrapOption

getset

Definition at line 468 of file ImportCommand.cs.

468{ get; set; }

◆ ClassLoaderOption

Option<string?> IKVM.Tools.Importer.ImportCommand.ClassLoaderOption

getset

Definition at line 436 of file ImportCommand.cs.

436{ get; set; }

◆ CompressResourcesOption

Option<bool> IKVM.Tools.Importer.ImportCommand.CompressResourcesOption

getset

Definition at line 422 of file ImportCommand.cs.

422{ get; set; }

◆ DebugOption

Option<string?> IKVM.Tools.Importer.ImportCommand.DebugOption

getset

Definition at line 408 of file ImportCommand.cs.

408{ get; set; }

◆ DelaySignOption

Option<bool> IKVM.Tools.Importer.ImportCommand.DelaySignOption

getset

Definition at line 406 of file ImportCommand.cs.

406{ get; set; }

◆ DeterministicOption

Option<bool> IKVM.Tools.Importer.ImportCommand.DeterministicOption

getset

Definition at line 410 of file ImportCommand.cs.

410{ get; set; }

◆ DisableAssertionsOption

Option<string?> IKVM.Tools.Importer.ImportCommand.DisableAssertionsOption

getset

Definition at line 376 of file ImportCommand.cs.

376{ get; set; }

◆ EnableAssertionsOption

Option<string?> IKVM.Tools.Importer.ImportCommand.EnableAssertionsOption

getset

Definition at line 374 of file ImportCommand.cs.

374{ get; set; }

◆ ExcludeOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.ExcludeOption

getset

Definition at line 392 of file ImportCommand.cs.

392{ get; set; }

◆ ExternalResourceOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.ExternalResourceOption

getset

Definition at line 388 of file ImportCommand.cs.

388{ get; set; }

◆ FileAlignOption

Option<string?> IKVM.Tools.Importer.ImportCommand.FileAlignOption

getset

Definition at line 442 of file ImportCommand.cs.

442{ get; set; }

◆ FileVersionOption

Option<string?> IKVM.Tools.Importer.ImportCommand.FileVersionOption

getset

Definition at line 396 of file ImportCommand.cs.

396{ get; set; }

◆ HighEntropyVAOption

Option<bool> IKVM.Tools.Importer.ImportCommand.HighEntropyVAOption

getset

Definition at line 452 of file ImportCommand.cs.

452{ get; set; }

◆ InputsArgument

Argument<FileInfo[]> IKVM.Tools.Importer.ImportCommand.InputsArgument

getset

Definition at line 358 of file ImportCommand.cs.

358{ get; set; }

◆ KeyFileOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.KeyFileOption

getset

Definition at line 402 of file ImportCommand.cs.

402{ get; set; }

◆ KeyOption

Option<string?> IKVM.Tools.Importer.ImportCommand.KeyOption

getset

Definition at line 404 of file ImportCommand.cs.

404{ get; set; }

◆ LibraryOption

Option<DirectoryInfo[]> IKVM.Tools.Importer.ImportCommand.LibraryOption

getset

Definition at line 448 of file ImportCommand.cs.

448{ get; set; }

◆ LogOption

Option<string>? IKVM.Tools.Importer.ImportCommand.LogOption

getset

Definition at line 470 of file ImportCommand.cs.

470{ get; set; }

◆ MainClassOption

Option<string> IKVM.Tools.Importer.ImportCommand.MainClassOption

getset

Definition at line 380 of file ImportCommand.cs.

380{ get; set; }

◆ NoAutoSerializationOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoAutoSerializationOption

getset

Definition at line 450 of file ImportCommand.cs.

450{ get; set; }

◆ NoGlobbingOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoGlobbingOption

getset

Definition at line 370 of file ImportCommand.cs.

370{ get; set; }

◆ NoJarStubsOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoJarStubsOption

getset

Definition at line 460 of file ImportCommand.cs.

460{ get; set; }

◆ NoJNIOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoJNIOption

getset

Definition at line 390 of file ImportCommand.cs.

390{ get; set; }

◆ NoParameterReflectionOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoParameterReflectionOption

getset

Definition at line 466 of file ImportCommand.cs.

466{ get; set; }

◆ NoPeerCrossReferenceOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoPeerCrossReferenceOption

getset

Definition at line 444 of file ImportCommand.cs.

444{ get; set; }

◆ NoStackTraceInfoOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoStackTraceInfoOption

getset

Definition at line 418 of file ImportCommand.cs.

418{ get; set; }

◆ NoStdLibOption

Option<bool> IKVM.Tools.Importer.ImportCommand.NoStdLibOption

getset

Definition at line 446 of file ImportCommand.cs.

446{ get; set; }

◆ NoWarnOption

Option<Diagnostic[]> IKVM.Tools.Importer.ImportCommand.NoWarnOption

getset

Definition at line 430 of file ImportCommand.cs.

430{ get; set; }

◆ OptimizeOption

Option<bool> IKVM.Tools.Importer.ImportCommand.OptimizeOption

getset

Definition at line 412 of file ImportCommand.cs.

412{ get; set; }

◆ OutputOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.OutputOption

getset

Definition at line 360 of file ImportCommand.cs.

360{ get; set; }

◆ PlatformOption

Option<string?> IKVM.Tools.Importer.ImportCommand.PlatformOption

getset

Definition at line 366 of file ImportCommand.cs.

366{ get; set; }

◆ PrivatePackageOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.PrivatePackageOption

getset

Definition at line 426 of file ImportCommand.cs.

426{ get; set; }

◆ PropertiesOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.PropertiesOption

getset

Definition at line 372 of file ImportCommand.cs.

372{ get; set; }

◆ ProxyOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.ProxyOption

getset

Definition at line 454 of file ImportCommand.cs.

454{ get; set; }

◆ PublicPackageOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.PublicPackageOption

getset

Definition at line 428 of file ImportCommand.cs.

428{ get; set; }

◆ RecurseOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.RecurseOption

getset

Definition at line 384 of file ImportCommand.cs.

384{ get; set; }

◆ ReferenceOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.ReferenceOption

getset

Definition at line 382 of file ImportCommand.cs.

382{ get; set; }

◆ RemapOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.RemapOption

getset

Definition at line 416 of file ImportCommand.cs.

416{ get; set; }

◆ RemoveAssertionsOption

Option<bool> IKVM.Tools.Importer.ImportCommand.RemoveAssertionsOption

getset

Definition at line 378 of file ImportCommand.cs.

378{ get; set; }

◆ RemoveUnusedPrivateFieldsOption

Option<bool> IKVM.Tools.Importer.ImportCommand.RemoveUnusedPrivateFieldsOption

getset

Definition at line 420 of file ImportCommand.cs.

420{ get; set; }

◆ ResourceOption

Option<string[]> IKVM.Tools.Importer.ImportCommand.ResourceOption

getset

Definition at line 386 of file ImportCommand.cs.

386{ get; set; }

◆ RuntimeOption

Option<FileInfo?>? IKVM.Tools.Importer.ImportCommand.RuntimeOption

getset

Definition at line 434 of file ImportCommand.cs.

434{ get; set; }

◆ SharedClassLoaderOption

Option<bool>? IKVM.Tools.Importer.ImportCommand.SharedClassLoaderOption

getset

Definition at line 438 of file ImportCommand.cs.

438{ get; set; }

◆ SourcePathOption

Option<DirectoryInfo?> IKVM.Tools.Importer.ImportCommand.SourcePathOption

getset

Definition at line 414 of file ImportCommand.cs.

414{ get; set; }

◆ StaticOption

Option<bool> IKVM.Tools.Importer.ImportCommand.StaticOption

getset

Definition at line 458 of file ImportCommand.cs.

458{ get; set; }

◆ StrictFinalFieldSemanticsOption

Option<bool> IKVM.Tools.Importer.ImportCommand.StrictFinalFieldSemanticsOption

getset

Definition at line 424 of file ImportCommand.cs.

424{ get; set; }

◆ TargetOption

Option<string?> IKVM.Tools.Importer.ImportCommand.TargetOption

getset

Definition at line 364 of file ImportCommand.cs.

364{ get; set; }

◆ VersionOption

Option<string?> IKVM.Tools.Importer.ImportCommand.VersionOption

getset

Definition at line 394 of file ImportCommand.cs.

394{ get; set; }

◆ WarnAsErrorOption

Option<Diagnostic[]> IKVM.Tools.Importer.ImportCommand.WarnAsErrorOption

getset

Definition at line 432 of file ImportCommand.cs.

432{ get; set; }

◆ WarningLevel4Option

Option<bool> IKVM.Tools.Importer.ImportCommand.WarningLevel4Option

getset

Definition at line 464 of file ImportCommand.cs.

464{ get; set; }

◆ Win32IconOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.Win32IconOption

getset

Definition at line 398 of file ImportCommand.cs.

398{ get; set; }

◆ Win32ManifestOption

Option<FileInfo?> IKVM.Tools.Importer.ImportCommand.Win32ManifestOption

getset

Definition at line 400 of file ImportCommand.cs.

400{ get; set; }

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

src/IKVM.Tools.Importer/ImportCommand.cs

Public Member Functions

Properties

Detailed Description

Constructor & Destructor Documentation

◆ ImportCommand()

Property Documentation

◆ AllowNonVirtualCallsOption

◆ ApartmentOption

◆ AssemblyAttributesOption

◆ AssemblyNameOption

◆ BaseAddressOption

◆ BootstrapOption

◆ ClassLoaderOption

◆ CompressResourcesOption

◆ DebugOption

◆ DelaySignOption

◆ DeterministicOption

◆ DisableAssertionsOption

◆ EnableAssertionsOption

◆ ExcludeOption

◆ ExternalResourceOption

◆ FileAlignOption

◆ FileVersionOption

◆ HighEntropyVAOption

◆ InputsArgument

◆ KeyFileOption

◆ KeyOption

◆ LibraryOption

◆ LogOption

◆ MainClassOption

◆ NoAutoSerializationOption

◆ NoGlobbingOption

◆ NoJarStubsOption

◆ NoJNIOption

◆ NoParameterReflectionOption

◆ NoPeerCrossReferenceOption

◆ NoStackTraceInfoOption

◆ NoStdLibOption

◆ NoWarnOption

◆ OptimizeOption

◆ OutputOption

◆ PlatformOption

◆ PrivatePackageOption

◆ PropertiesOption

◆ ProxyOption

◆ PublicPackageOption

◆ RecurseOption

◆ ReferenceOption

◆ RemapOption

◆ RemoveAssertionsOption

◆ RemoveUnusedPrivateFieldsOption

◆ ResourceOption

◆ RuntimeOption

◆ SharedClassLoaderOption

◆ SourcePathOption

◆ StaticOption

◆ StrictFinalFieldSemanticsOption

◆ TargetOption

◆ VersionOption

◆ WarnAsErrorOption

◆ WarningLevel4Option

◆ Win32IconOption

◆ Win32ManifestOption