US 6,167,565 AGrant
Method and System of Custom Marshaling of Inter-Language Parameters
Issue Date:2000-12-26
•19 Claims
•5 Drawing Sheets
Abstract
A computer-based custom marshaling method and system for custom marshaling of parameters during invocation of functions implemented in a second language by computer programs implemented in an first language. The parameter to be custom marshaled has a first type in the first language and a second type in the second language. The custom marshaling system receives code for converting a parameter of the first type to a parameter of the second type and for converting a parameter of the second type to a parameter of the first type. The custom marshaling system monitors the execution of a computer program implemented in the first language that invokes a function implemented in the second language. The invocation passes a parameter of the first type, and the function expects a parameter of the second type. The custom marshaling system intercepts the invocation of the function implemented in the second language. After intercepting the invocation, the custom marshaling system executes the received code for converting the passed parameter of the first type to a parameter of the second type. The custom marshaling system then invokes the function implemented in the second language passing the parameter converted to the second type. The invoked function returns a parameter of the second type. After invocation of the function, the custom marshaling system executes the received code for converting the returned parameter of the second type to a parameter of the first type and returns the converted parameter of the first type when returning from the intercepted invocation of the function.
Metadata
Assignee
- Microsoft Corporation
Inventor
- Atsushi Kanamori
Application Information
Application Number:US 0042196
Filing Date:1998-01-08
Priority Date:1998-01-08
Art Unit:273
Classifications
IPC:
G06F 944
Field of Search:
7097077171;300;304;303;2031035
Patent Drawings (5 sheets)
Description
Technical Field
This invention relates generally to a computer system and method for passing data and, more specifically, for a method and system for passing parameters when invoking a function.
Background of the Invention
Computer software systems can be very complex systems in which the same sequence of instructions may be executed multiple times. For example, a computer program may provide a window area that contains the contents of a bitmap. As the computer program executes, it may enter various states in which contents of different bitmaps should be displayed. Thus, the computer program may repeatedly execute the same sequence of instructions needed to redisplay the contents of a bitmap. A computer program could simply contain a copy of this sequence of instructions in various places throughout the computer program at the point at which the contents of different bitmaps are to be displayed. However, such copies of the same instructions have problems in that computer program memory needs memory to store the copies and a programmer may need to develop and debug each copy separately.
Most programming languages and computer instruction sets support the concept of a function (i.e., subroutine) to help alleviate these problems. A function is a sequence of instructions that can be executed at various times throughout execution of the computer program. However, rather than copying the sequence of instructions at various places throughout the computer program, wherever the sequence instructions should be copied a function invocation instruction is placed instead. The execution of the invocation instruction causes the instructions of the function to be executed, and after completing the execution of those instructions, the instructions after the invocation instruction are executed. The net effect is that the instructions are executed in the same sequence as if they had been copied in place of the invocation instruction. Since the invoking program may want to execute the same sequence of instructions but operate on different data (e.g., different bitmaps), parameters can be passed to functions. For example, in the case of a function that displays a bitmap, one parameter could be the bitmap that is to be displayed. Thus, at various points of the computer program the display bitmap function can be invoked, passing the particular bitmap that is to be displayed at that point during the execution of the computer program.
When a programmer develops functions, the programmer defines the number, types, and order of parameters that are to be passed to the function when invoked. For example, the function to display a bitmap may be passed three parameters: a pointer to the bitmap, an integer indicating the number of columns in the bitmap, and an integer indicating the number of rows in the is bitmap. The definition of the number, type, and order of parameters to be passed to a function is provided by the "prototype" of the function. The following statement is an example prototype for the function to display a bitmap.
DisplayBitmap (bitmap*ptr, int rows, int columns)
The invoking program needs the same number, type, and order of parameters as specified in the prototype. To pass the parameters, the invoking program needs to store the parameters at a location where the invoked function can retrieve the parameters. For example, the parameters may be stored on the top of stack by the invoking program. The function can then use the stack pointer to locate and retrieve the parameters. For this example prototype, the invoking program stores a pointer to the bitmap to be displayed onto the stack, followed by integers indicating the number of rows and columns. Translators (e.g., compilers or interpreters) for a programming language generally use a predefined convention for storing parameters to be passed to a function. For example, one convention is that all parameters are passed via the stack in the same order as they appear in the prototype. The use of a passing convention allows a program compiled by one compiler to invoke a function compiled by another compiler, and the parameters will be correctly passed.
Parameters can be passed either by "value" or by "reference." When a parameter is passed by value, the value of the actual parameter is stored in the stack. (The term "formal" parameter refers to the parameter name that is used in the prototype (e.g., "ptr") and that name is used to reference the parameter in the function. The term "actual" parameter refers to the variable that is actually passed when the function is invoked.) When a parameter is passed by reference, the address of the actual parameter is stored in the stack. The prototype for the DisplayBitmap function indicates that the bitmap is passed by reference and that the number of rows and columns are passed by value. The prototype for a function needs to specify (explicitly or implicitly) whether each parameter is passed by value or reference. In the C++ programming language, an asterisk ("*") appended to the name of a type in the declaration of a parameter indicates that the parameter is a reference to a value of that type, rather than the value of that type. For example, the declaration "bitmap* ptr" indicates that the parameter "ptr" is a reference to a bitmap, whereas the declaration "bitmap bm" would indicate that the parameter "bm" is a bitmap. When a parameter is passed by value, the function cannot modify the actual argument itself Conversely, when a parameter is passed by reference, then the functions can use the address to modify the actual argument itself Thus, parameters are typically passed by value when the function does not modify the parameter and by reference when the function modifies the parameter.
Certain programming languages have been developed which are well suited to implementing software systems in certain application domains. For example, the Java programming language was developed explicitly to support the implementation of computer programs that are hardware independent. The Java programming language also defines a set of primitive data types (e.g., integers), object data types, and a convention for passing parameters. In particular, all parameters that have a primitive type are passed by value and that are objects are passed by reference. Although virtually any computer program can be developed using the Java programming language, it may be easier to develop certain portions of the computer program using another programming language (e.g., the C++ programming language). In general, it may be desirable to intermix the programming languages used to develop a computer program for several reasons. First, it may be more efficient to implement a portion of the computer program using one programming language rather than another. Second, it may be that various functions have already been implemented in one programming language, and it would be costly to reimplement the function in another programming language. However, the programming languages may not support the same primitive data types and thus, the types of the parameters may not be fully compatible. For example, a date type in one programming language may be defined in a MM/DD/YY format, while the date type in another programming language may be defined in a YY/MM/DD format.
Some programming language translators have been developed to map the data types of one programming language to the data types of another programming language when a function implemented in one programming language is invoked by a computer program implemented in another programming language. The converting and passing of a parameter is referred to as "marshaling" the parameter. For example, the translator may detect that a function developed in another programming language is to be invoked and that the date types are not compatible. The translator may convert the date parameter to the format expected by the function before invoking the function and convert the date parameter to the format expected by the invoking program upon return from the function. However, the translator can only convert between types for which it happens to have predefined marshaling code. If a programmer defines a complex data type, then the translator is unlikely to be able to perform the needed conversions automatically.
Summary of the Invention
An embodiment of the present invention provides a method and system for custom marshaling of parameters for inter-language invocation of functions between a first language and a second language. The parameters to be custom marshaled have a first type in the first language and a second type in the second language. The custom marshaling system receives code (e.g., methods of a custom marshaling object) for converting a parameter of the first type to a parameter of the second type and for converting a parameter of the second type to a parameter of the first type. When a computer program implemented in the first language invokes a function implemented in the second language, the custom marshaling system executes the received code for converting the passed parameter of the first type to a parameter of the second type. The custom marshaling system then invokes the function implemented in the second language passing the parameter converted to the second type. After invocation of the function, the custom marshaling system executes the received code for converting the parameter of the second type to a parameter of the first type.
Brief Description of the Drawings
FIG. 1 is a block diagram illustrating components of a computer system upon which the custom marshaling system may be implemented.
FIG. 2 is a flow diagram illustrating the processing of the Java VM when it encounters an invocation to a COM function.
FIG. 3 is a flow diagram of the routine to custom marshal the parameters.
FIG. 4 is a flow diagram of a subroutine that creates the in stub and the out stub.
FIG. 5 is a flow diagram of a COM wrapper function for a Java function.
Detailed Description of the Invention
An embodiment of the present invention provides a method and system for custom marshaling of parameters during the invocations of functions implemented in one programming language by programs implemented in another programming language. Such invocations are referred to as "inter-language" invocations. The custom marshaling system permits a programmer to provide to the translator a mapping from a data type in one programming language to a corresponding data type in another programming language. This mapping specifies custom marshaling code (i.e., a set of instructions) that can be used for converting parameters of that data type to a parameter of the corresponding data type, and vice versa. The custom marshaling system maps the prototype of the function to be invoked into a prototype that is usable by the invoking program. During execution of the computer program, when the inter-language invocation is encountered, the translator retrieves the specified custom marshaling code for the parameter and executes that code to convert the actual parameter into the data type of the formal parameter. The translator then invokes the function. Upon returning from the function, the translator invokes the custom marshaling code to convert the formal parameter back into the data type of the actual parameter. In this way, a programmer can provide to the translator custom marshaling code to support marshaling of parameters of any data type, and marshaling is thus not limited to only those data types for which the translator happens to have predefined marshaling code.
In one embodiment, the custom marshaling system of the present invention allows programs developed in the Java programming language to invoke programs developed in the C++ programming language that conform with the Component Object Model ("COM"). COM is a specification that describes a standard interface that allows objects developed in conformance with the specification to interoperate. COM is defined in "Inside OLE: Second Edition," by Kraig Brockschmidt and published by Microsoft Press in 1995, which is hereby incorporated by reference. Java programs are translated by an interpreter referred to as a Java Virtual Machine ("Java VM"). The custom marshaling system automatically generates Java prototypes from the COM prototypes and vice versa. The mappings from COM prototypes to Java prototypes are described below in detail. The Java VM inputs statements of a Java program and performs the behavior associated with the statements. When the Java VM encounters an inter-language invocation (i.e., from the Java program to a COM function, that is, a function implemented in the C++ programming language that conforms with COM), the Java VM determines whether custom marshaling has been defined for any of the parameters. If custom marshaling code has been defined for a parameter, then the Java VM loads and executes the marshaling code before and after invoking the function.
Table 1 illustrates the mapping of the COM prototypes to the Java prototype. The custom marshaling system generates Java prototypes based on the direction in which the parameter is to be passed (e.g., [in] and [out]), whether the parameter is passed in by single or double indirection. In the following, "JAVATYPE" refers to the type of the Java parameter, "COMTYPE" refers to the type of the COM parameter, and "Foo" refers to the function to be invoked. Unless specified otherwise, JAVATYPE is the type of an object, and the object is passed by reference. As shown in Table 1, when the COMTYPE specifies double indirection, then the JAVATYPE is an array to effect the double indirection.
FIG. 1 is a block diagram illustrating components of a computer system upon which the custom marshaling system may be implemented. The computer system 100 includes a central processing unit 101, memory 102, and I/O devices 103. The memory contains a Java VM 104, a custom marshaling map 105, Java code 106, COM functions 107, marshaling classes 108, and Java functions 109. The custom marshaling map contains a mapping from the Java data types to COM data types, identifies the marshal classes that defines the marshaling code, and indicates whether the JAVATYPE is immutable. The marshaling classes are provided by a programmer and define the custom marshaling code. The Java VM loads and executes the Java program, which invokes a COM function. A COM function in turn may invoke a Java function. The parameters passed by the COM function may also need to be converted. Therefore, the marshal classes define various methods for converting to and from JAVATYPE and COMTYPE. The methods of the marshaling classes perform appropriate converting of data types and allocating and deallocating of memory as needed. The following lists various methods of the marshaling classes and description of the behavior of each method. The methods toJava, toUninitJava, toExtemal, and toUninitExternal create new instances of the parameters. The methods copyToJava and copyToExternal propagate their converted values to existing instances.
JAVATYPE toJava (COMTYPE ppCOMPTYPE)
This method creates an instance of JAVATYPE, converts the COMTYPE parameter pointed to by ppCOMTYPE to a JAVATYPE and returns the JAVATYPE instance set to the converted value as the return value of the method. This method is used when a COM program is passing an [in] parameter to invoke a Java function or when a COM function is returning a [retval] parameter to a Java program. This method creates an initialized JAVATYPE instance that is passed to a Java program or function.
VOID copyToJava (JAVATYPE valueJAVATYPE, COMPTYPE ppCOMTYPE)
This method converts the COMTYPE parameter pointed to by ppCOMTYPE to a JAVATYPE and stores the converted value in the parameter valueJAVATYPE. This method is used when returning an [out] parameter to a Java program from an invoked COM function. This method is used to change the value of an existing actual parameter in the Java program; this method does not create a new instance of JAVATYPE.
JAVATYPE toUninitJava (COMPTYPE ppCOMTYPE)
This method creates an uninitialized JAVATYPE instance and returns it as the return parameter. This method is used when a COM program is passing an [out] parameter to a Java function. The unitialized JAVATYPE instance is passed to the Java function.
VOID copyToExternal (JAVATYPE valueJAVATYPE, COMTYPE ppCOMTYPE)
This method converts the JAVATYPE parameter to a COMTYPE and stores the converted value in ppCOMTYPE. This method is used when a Java program passes a parameter to a COM function or when a Java function returns an [out] parameter to a COM program. This method is used to change the value of an existing actual parameter; this method does not create a new instance of a COMTYPE. This method is invoked, for example, when an instance of the COMTYPE parameter is allocated in the stack.
VOID relcascByValExternal (COMTYPE ppCOMTYPE)
This method releases resources used by the COMTYPE parameter, but this method does not release the instance. This method is invoked, for example, when the instance is allocated on the stack. This method is used when a COM function returns to a Java program and the COM parameter had a size designated by the marshaling code.
VOID toExternal (JAVATYPE valueJAVATYPE, COMTYPE ppCOMTYPE)
This method creates a new instance of COMTYPE, converts the valueJAVATYPE to a COMTYPE, and stores the converted value as the new COMTYPE instance. This method is used when a Java function returns a return value to a COM program.
VOID releaseExternal (COMTYPE ppCOMTYPE)
This method releases resources used by the COMTYPE parameter and releases the instance of the parameter. The method is used when a Java program invokes a COM function and the COM function expects an [out] parameter. This method is used in conjunction with the toExternal and toUninitExternal methods.
VOID toUninitExternal (JAVATYPE value JAVATYPE)
This method creates a new instance of COMTYPE. This method is used when a JAVA program invokes a COM function that has an [out] parameter.
Tables 2-5 contain various marshaling sequences used with custom marshaling of paraneters. Each table contains two subtables. The first subtable indicates the sequence when a Java program invokes a COM function, and the second subtable indicates the sequence when a COM program invokes a Java function.
Table 2 lists marshaling sequences when the COMTYPE is passed by reference and the JAVATYPE is mutable. Each subtable contains four rows indicating the code execution sequences for the direction (i.e., [in], [out], [in,out], and [out,retval]) that the parameter passed to the COM function. Also, the subtables contain "preferred" and "alternate" sequences. In this table, if the marshaling class exports a "ByValSize" variable and a copyToExternal method, then the preferred sequence is used. If the "ByValSize" variable is exported, then custom marshaling system can allocate the variable of that size on the stack. The example COM finction is named "Foo," and the example Java function is named "foo." For example, the preferred marshaling sequence when a Java Program invokes a COM function and passes an [in,out] parameter is
copyToExternal
Foo
copyToJava
releaseByValExternal
When this Java VM detects such an invocation, the Java VM allocates space on the stack for the parameter (i.e., "ByValSize" number of bytes) and then invokes the copyToExternal method. This method converts the JAVATYPE to a COMTYPE and copies the converted value to the allocated space on the stack. The Java VM then invokes the COM function Foo. On return, the Java VM invokes the copyToJava method to convert the COMTYPE returned on the stack to a JAVATYPE and stores the converted value in the JAVATYPE parameter passed by the Java program. The Java VM then invokes the releaseByValExternal method to perform any cleanup needed by the COMTYPE. The Java VM then deallocates the space on the stack and returns the Java program.
When a COM program invokes a Java function and passes an [in,out] parameter, the marshaling sequence as indicated by Table 2 is
toJava
releaseByValExternal
foo
copyToExternal
The Java function has a COM wrapper function which the COM program invokes. When the COM wrapper function is invoked, it performs this marshaling sequence. The COM wrapper function first calls the toJava method to convert the COMTYPE to a JAVATYPE and return the JAVATYPE as the return value of the function. The COM wrapper function then invokes the releaseByValExternal method to perform any clean up for the COMTYPE parameter. The COM wrapper function then invokes the Java function foo passing the JAVATYPE parameter. When the Java function returns, the COM wrapper function invokes the copyToExternal method to convert the JAVATYPE to a COMTYPE and to store the converted value as the [out] parameter on the stack. The COM wrapper function then returns to the COM function.
Table 3 lists marshaling sequences when the COMTYPE is passed by reference and the JAVATYPE is immutable. In such a situation, the JAVATYPE parameter is passed as an array, so that it can be modified. The preferred marshaling sequence for an [in,out] parameter when a Java program invokes a COM program is
copyToExternal
Foo
toJava
releaseByValExternal.
The sequence is similar to the corresponding sequence of Table 2, except that the toJava method is invoked rather than the copyToJava method. The toJava method creates a new JAVATYPE instance, rather than modifying an existing JAVATYPE instance. This allows the newly created variable to be returned through the array mechanism.
Table 4 lists marshaling sequences when the COM parameters are passed by value. The marshaling sequence when a Java program invokes a COM function passing an [in] parameter is
copyToExternal
Foo
releaseByValExternal
The COMTYPE parameter that is passed to the copyToExtemal method is allocated in the stack.
Table 5 lists marshaling sequences used when the parameter is designated as being passed by reference via double indirection. The marshaling sequence when a Java program invokes a COM function passing an [in] parameter is
copyToExternal
Foo
releaseByValExternal.
FIG. 2 is a flow diagram illustrating the processing of the Java VM when it encounters an invocation to a COM function. In step 201, if the Java instruction currently being processed indicates to invoke a COM function, then the Java VM continues at step 202, else the Java VM continues with its normal processing. In step 202, if custom marshaling has been defined for a parameter, then the Java VM continues at step 203, else the Java VM continues at step 204. In step 203, the Java VM invokes a routine to perform custom marshaling of the parameters and then the Java VM continues its normal processing. In step 204, the Java VM invokes a routine to perform standard marshaling of the parameters and then the Java VM continues its normal processing.
FIG. 3 is a flow diagram of the routine to custom marshal the parameters. In step 301, the routine retrieves information from the parameter to be custom marshaled. In step 302, if stubs have already been created for this parameter, then the routine continues at step 304, else the routine continues at step 303. In step 303, the routine invokes a subroutine to create the stubs (an in stub and an out stub) to control the marshaling. In step 304, the routine executes the in stub for the parameters. In step 305, the routine invokes the COM function. In step 306, the routine executes the out stub for this COM function and returns.
FIG. 4 is a flow diagram of a subroutine that creates the in stub and the out stub. In steps 401-407, the subroutine loops selecting each of the parameters that are to be passed. In step 401, the routine selects the next parameter starting with the first. In step 402, if all the parameters have already been selected, then the subroutine returns, else the subroutine continues at step 403. In step 403, if the selected parameter is to be custom marshaled, then the subroutine continues at step 404, else the subroutine continues at step 406. In step 404, the routine adds the custom marshaling code to marshal the selected parameter to the in stub. In step 405, the routine adds the custom code to marshal back the selected parameter to the out stub and loops to step 401 to select the next parameter. In step 406, the routine adds code to pass the parameter to the in stub. In step 407, the routine adds code to return the parameter to the out stub and loops to step 401 to select the next parameter.
FIG. 5 is a flow diagram of a COM wrapper function for a Java function. When code implemented in COM invokes a Java function, this COM stub is invoked. In step 501, the wrapper function marshals the parameter from the COM to the Java and returns.
The following lists sample pseudocode implementation of marshaling classes. Code Table 1 lists the methods of a marshaling class for marshaling a JAVATYPE of double to a COMTYPE of "Fixed." The JAVATYPE of double is a primitive type in Java and is therefore immutable.
Code table 2 lists the pseudocode methods of a marshaling class for marshaling a JAVATYPE of string to a COMTYPE of "variant." The lo JAVATYPE of string is a primitive type in Java and is therefore immutable. The releaseByValExternal allows deallocation of resources for a parameter that was allocated in the stack.
Code Table 3 lists pseudocode for methods of a marshaling class for marshaling a JAVATYPE of point object to a COMTYPE of point. The point object is mutable in Java. The copyToJava and to Uninitjava methods allows mutable objects to be passed using the non-array form.
Code Table 4 lists pseudocode for methods of a marshaling class for marshaling when a COMTYPE needs to allocate and deallocate memory other than on the stack.
Code Table 5 lists pseudocode for methods of a marshaling class for marshaling when the COMTYPE is of variable size.
From the foregoing it will be appreciated that, although specific embodiments of the invention have been described herein for purposes of illustration, various modifications may be made without deviating from the spirit and scope of the invention. For example, one skilled in the art would appreciate that the techniques of the present invention can be used to interface with programs developed in any programming language that conforms with COM. Moreover, the techniques may be generally applicable to the marshaling of parameters between programs developed in various programming languages. Accordingly, the invention is not limited except as by the appended claims.
Claims
Certificate of Correction present
The claims shown below may not include correction changes. Use the corrected PDF for authoritative text.
What is claimed is:
1. A method in a computer system for marshaling of parameters during invocation of functions implemented in a second language by computer programs implemented in an first language, a parameter to be marshaled having a first type in the first language and a second type in the second language, the method comprising: executing a computer program implemented in the first language that invokes a function implemented in the second language, the invocation passing a parameter of the first type and the function expecting a parameter of the second type; intercepting the invocation of the function implemented in the second language; and after intercepting the invocation, determnining that the passed parameter requires custom marshaling; creating for the invoked function an in stub that invokes custom marshaling code for converting the passed parameter of the first type to a parameter of the second type and an out stub that invokes custom marshaling code for converting a returned parameter of the second type to a parameter of the first type; executing the in stub, thereby converting the passed parameter of the first type to a parameter of the second type; invoking the function implemented in the second language and passing the parameter converted to the second type, the invoked function returning a parameter of the second type; after invocation of the function, executing the out stub, thereby converting the returned parameter of the second type to a parameter of the first type; and returning the converted parameter of the first type when returning from the intercepted invocation of the function.
2. The method of claim 1 wherein the custom marshaling code is a custom marshaling class with member functions for converting the parameters.
3. The method of claim 1 wherein the first language is a Java-based language and the second language is a C-based language.
4. The method of claim 1 wherein the custom marshaling code may be for converting any arbitrary first and second types.
5. A method in a computer system for marshaling of a parameter for inter-language invocation of functions between a first language and a second language, the parameter to be marshaled having a first type in the first language and a second type in the second language, the method comprising: when a computer program implemented in the first language invokes a function implemented in the second language, determining that a parameter being passed to the function requires custom marshaling; creating for the invoked function an in stub that invokes custom marshaling code for converting the passed parameter of the first type to a parameter of the second type and an out stub that invokes custom marshaling code for converting a returned parameter of the second type to a parameter of the first type; executing the in stub, thereby converting the passed parameter of the first type to a parameter of the second type; invoking the function implemented in the second language and passing the parameter converted to the second type; and after invocation of the function, executing the out stub, thereby converting the parameter of the second type to a parameter of the first type.
6. The method of claim 5 wherein the first language is the Java programming language.
7. The method of claim 5 wherein the first language is the C++ programming language.
8. The method of claim 5 wherein the custom marshaling code is implemented as member functions of a class.
9. The method of claim 5 wherein the custom marshaling code includes an indication of the size of a parameter of the second type.
10. The method of claim 5 wherein before invoking the function implemented in the second language, the parameter of the second type is allocated on a stack.
11. The method of claim 5 wherein the custom marshaling code for converting includes code for releasing allocated memory.
12. The method of claim 5 wherein the custom marshaling code is capable of converting arbitrary types of data.
13. A computer system for marshaling of a parameter for inter-language invocation of functions between a first language and a second language, the parameter to be marshaled having a type in the first language and another type in the second language, comprising: a storage component containing custom marshaling code for converting parameters of certain types to parameters of other types and for converting the parameters of the other types to parameters of the certain types; a component for receiving custom marshaling code and adding the received code to the storage component; and a marshaling component that when a computer program implemented in the first language invokes a function implemented in the second language, creates an in stub and an out stub; retrieves the custom marshaling code for converting the parameter based on the type of the parameter in the first and second languages and includes the code within the in stub and the out stub, executes the in stub, thereby converting the passed parameter of a first type to a parameter of a second type, invokes the function implemented in the second language passing the parameter converted to the second type, and after invocation of the function, executes the out stub, thereby converting the parameter of the second type to a parameter of the first type.
14. The system of claim 13 wherein the first language is the Java programming language.
15. The system of claim 13 wherein the first language is the C++ programming language.
16. The system of claim 13 wherein the received code is implemented as member functions of a class.
17. A computer-readable medium containing instructions for causing a computer system to marshal a parameter for inter-language invocation of functions between a first language and a second language, the parameter to be marshaled having a first type in the first language and a second type in the second language, by: when a computer program implemented in the first language invokes a function implemented in the second language, determining that a parameter being passed to the function requires custom marshaling; creating for the invoked function an in stub that invokes custom marshaling code for converting the passed parameter of the first type to a parameter of the second type and an out stub that invokes custom marshaling code for converting a returned parameter of the second type to a parameter of the first type; executing the in stub, thereby converting the passed parameter of the first type to a parameter of the second type; and invoking the function implemented in the second language and passing the parameter converted to the second type.
18. The computer-readable medium of claim 17 wherein the first language is the Java programming language.
19. The computer-readable medium of claim 17 wherein the first language is the C++ programming language.
Patent Citations (21)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US5377350 | 1994-12-01 | Skinner | |
| US5511197 | 1996-04-01 | Hill et al. | |
| US5524253 | 1996-06-01 | Pham et al. | |
| US5566302 | 1996-10-01 | Khalidi et al. | |
| US5577251 | 1996-11-01 | Hamilton et al. | |
| US5737607 | 1998-04-01 | Hamilton et al. | |
| US5758186 | 1998-05-01 | Hamilton et al. | |
| US5761499 | 1998-06-01 | Sonderegger | |
| US5875335 | 1999-02-01 | Beard | |
| US5881230 | 1999-03-01 | Christensen et al. | |
| US5887172 | 1999-03-01 | Vasudevan et al. | |
| US5911069 | 1999-06-01 | Beard | |
| US5920720 | 1999-07-01 | Toutonghi et al. | |
| US5960200 | 1999-09-01 | Eager et al. | |
| US5991823 | 1999-11-01 | Cavanaugh, III et al. | |
| US5995974 | 1999-11-01 | Anton et al. | |
| US5999986 | 1999-12-01 | McCauley, III et al. | |
| US5999988 | 1999-12-01 | Pelegri-Llopart et al. | |
| US6006235 | 1999-12-01 | Macdonald et al. | |
| US6009464 | 1999-12-01 | Hamilton et al. | |
| US6016489 | 2000-01-01 | Cavanaugh et al. |
Non-Patent Literature (2)
- "Type Mappings Between Java and COM . . . " http://www.microsoft.comjava/sdk/20/jnativeType.sub.-- Mappings.sub.-- Between.sub.-- Java.sub.-- and.sub.-- COM.htm.
- "Introduction to Java/COM Custom Marshaling for User-Defined Data Types." http://www.mirosoft.com/java/sdk/20/tools/marshal.htm.