Export (0) Print
Expand All
4 out of 16 rated this helpful - Rate this topic

Visual J# Binary Converter Tool (for Java-Language Bytecode to MSIL Conversions) 

Visual Studio 2005

The Visual J# Binary Converter Tool (JbImp.exe) converts certain Java-language bytecode (.class) files to Microsoft® intermediate language (MSIL). This tool enables developers to convert most JDK 1.1.4 level libraries and applications available only as bytecode files to MSIL assemblies. Once converted, these applications can run on the .NET Framework.

You can use this tool only if the Java-language sources for the applications or libraries are not available. If Java-language sources are available, it is recommended that you use the Visual J# compiler (vjc.exe) instead.


JbImp [options] <class_files> [ [options] <class files> ...]

Parameters

Class_files

The names of any .class files to convert. This option lists both directories and files. Directory and file names can contain the asterisk (*) and question mark (?) as wildcards. You can also specify a CAB, ZIP, or JAR file here.

/delaysign

Specifies whether an assembly will be fully or partially signed. Use /delaysign if you want to place only the public key in the assembly.

By default, /delaysign is not in effect.

The /delaysign option has no effect unless used with /keyfile or /keycontainer.

/help/?

Prints a summary of the JbImp.exe options.

/k[eyfile]:file

Signs the generated assembly with the keyfile file. An assembly with a strong name is created with the keypair specified in file. This file is typically generated using the sn.exe utility. Place the string in double quotation marks (" ") if it contains a space.

/keycontainer:string

Specifies a key container name for a key pair to give an assembly a strong name. Place the string in double quotation marks (" ") if it contains a space.

/linkres[ource]:file[,identifier]

Creates a link to a managed resource. Optionally specifies a logical name used to load the resource. The default is the name of the file.

/m[ain]:class

Specifies the entry point for the executable file. The list of .class files is parsed to find the class named class. If such a class exists and has a method with the signature public static void main(String[] args), then this method is set as the entry point. Otherwise, conversion stops.

If this option is not selected, the first class that has a method with the signature public static void main(String[] args) will be the entry point. If no such class exists and the /target:exe option is selected, conversion stops.

The class name specified in the argument can be a simple name or a fully qualified name that includes the package name.

/nologo

Suppresses converter banner information.

/out:file

Specifies the output file name and creates a .NET Framework assembly file with the name file.

/r[eference]:files

Uses the .NET Framework Microsoft intermediate language (MSIL) assembly files to resolve metadata references in the .class files.

/recurse dir

Recurses through subdirectories of the parent directory dir, looking for .class files. This option is meaningful only when class_files include directory names.

/res[ource]:file[,identifier]

Embeds a managed resource in the assembly. Optionally specifies a logical name used to load the resource. The default is the name of the file.

/securescoping

Follows rules for secure scoping. This is an advanced option that can be used to map Java-language package scope to .NET Framework assembly scope. If this option is not specified, package and protected scoped members in the Java-language bytecode are mapped to public scope in the output assembly.

/t[arget]:library

Generates a DLL. Sets no entry point, even if main is present.

/t[arget]:exe

Generates an executable (.exe) file. This is the default setting for the /target option. One of the input .class files must implement main.

/t[arget]:module

Generates an MSIL module. A module cannot be loaded and run by the common language runtime, but a module can be used by the Visual J#, and other, compilers to access the types in the module.

/usestubrefs

Uses stub types, fields, and methods for unresolved references.

If a class is referenced and not present in the input, the CLASSPATH environment variable is automatically searched for the missing class and the first found location is displayed with the error information. If this option is not specified, conversion stops if any of the referenced classes are not present in the input. If this option is specified, stub types are emitted into the created assembly for each of the missing classes. This causes the conversion to succeed, but will cause an exception to be thrown when an attempt is made to access a missing class member at run time.

The Visual J# Binary Converter Tool supports the following operations:

  • Conversion of .class files generated from certain Java-language code. The Visual J# Binary Converter Tool will convert code that uses functionality in most of the JDK 1.1.4 level class libraries.

  • Conversion of .class files containing most Microsoft Visual J++® 6.0 extensions, including delegates and J/Direct®.

  • Recursively search subdirectories for .class files to convert.

  • Import and use existing .NET Framework assembly DLL or EXE code.

  • Create a strong-named assembly that can be installed into the Global Assembly Cache (GAC).

The Visual J# Binary Converter Tool does not support the following:

  • Code that uses Java-language/COM interop technology.

  • Code that uses functionality in class libraries above the JDK 1.1.4 level.

  • Code that uses certain functionality in the JDK 1.1.4 level class libraries, including RMI, RNI, JNI, and applets.

Other Resources

J# Operators

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

Show:
© 2014 Microsoft. All rights reserved.