Method and system of custom marshaling of inter-language parameters

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.

Claims

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.

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
    ______________________________________
    COM Prototype        Java Prototype
    ______________________________________
    Foo ([in] COMTYPE)   Foo (JAVATYPE)
    Foo ([out,retval] COMTYPE*)
                         JAVATYPE Foo( )
    Foo ([in] COMTYPE*)  Foo (JAVATYPE)
    Foo ([out] COMTYPE*) Foo (JAVATYPE)*
    Foo ([in,out] COMTYPE*)
                         Foo (JAVATYPE)*
    Foo ([out,retval] COMTYPE**)
                         JAVATYPE Foo ( )
    Foo ([in] COMTYPE**) Foo (JAVATYPE[ ])
    Foo ([out] COMTYPE**)
                         Foo (JAVATYPE[ ])
    Foo ([in,out] COMTYPE**)
                         Foo (JAVATYPE[ ])
    ______________________________________
     *If the JAVATYPE is immutable, then the JAVATYPE is passed as an array so
     that a value can be returned. Immutability of a parameter type can be
     specified when the custom marshaling code is identified to the custom
     marshaling system.

                  TABLE 2
    ______________________________________
    C prototype         Java prototype
    Foo(COMTYPE*)       foo(JAVATYPE)
    Direction    Preferred      Alternate
    ______________________________________
    Java invokes COM
    [IN]         copyToExternal toExternal
                 Foo            Foo
                 releaseByValExternal
                                releaseExternal
    [OUT]        Foo            toUninitExternal
                 copyToJava     Foo
                 releaseByValExternal
                                copyToJava
                                releaseExternal
    [IN,OUT]     copyToExternal toExternal
                 Foo            Foo
                 copyToJava     copyToJava
                 releaseByValExternal
                                releaseExternal
    [OUT,RETVAL] Foo
                 toJava
                 releaseExternal
    COM invokes Java
    [IN]         toJava
                 foo
    [OUT]        toUninitJava
                 foo
                 copyToExternal
    [IN,OUT]     toJava
                 releaseByValExternal
                 foo
                 copyToExternal
    [OUT,RETVAL] Foo
                 toExternal
    ______________________________________

                  TABLE 3
    ______________________________________
    C prototype         Java prototype
    Foo(COMTYPE*)       foo(JAVATYPE[])
    Marshaling
    Direction   Preferred       Alternate
    ______________________________________
    Java invokes COM
    [IN]        copyToExternal  toExternal
                Foo             Foo
                releaseByValExternal
                                releaseExternal
    [OUT]       Foo             toUninitExternal
                toJava          Foo
                releaseByValExternal
                                toJava
                                releaseExternal
    [IN,OUT]    copyToExternal  toExternal
                Foo             Foo
                toJava          toJava
                releaseByValExternal
                                releaseExternal
    COM invokes Java
    [IN]        toJava
                foo
    [OUT]       foo
                copyToExternal
    [IN,OUT]    toJava
                releaseByValExternal
                foo
                copyToExternal
    ______________________________________

                  TABLE 4
    ______________________________________
    C prototype         Java prototype
    Foo(COMTYPE)        foo(JAVATYPE)
    Marshaling
    Direction     Preferred       Alternate
    ______________________________________
    Java invokes COM
    [IN]          copyToExternal
                  Foo
                  releaseByValExternal
    [OUT,RETVAL]  Foo
                  toJava
                  releaseByValExternal
    COM invokes Java
    [IN]          toJava
                  foo
    [OUT,RETVAL]  foo
                  copyToExternal
    ______________________________________

                  TABLE 5
    ______________________________________
    C prototype         Java prototype
    Foo(COMTYPE**)      foo(JAVATYPE[])
    Marshaling
    Direction      Preferred     Alternate
    ______________________________________
    Java invokes COM
    [IN]           toExternal
                   Foo
                   releaseExternal
    [OUT]          Foo
                   toJava
                   releaseExternal
    [IN,OUT]       toExternal
                   Foo
                   toJava
                   releaseExternal
    COM invokes Java
    [IN]           toJava
                   Foo
    [OUT]          Foo
                   toExternal
    [IN,OUT]       toJava
                   releaseExternal
                   Foo
                   toExternal
    ______________________________________

    ______________________________________
    CODE TABLE 1
    ______________________________________
    struct FIXED {
    WORD        fract;
    short       value;
    } FIXED;
    public FixedPtMarshaler {
     public static int cbByValSize; // set of sizeof(FIXED) = 8
     public static double toJava(int ppFIXED, int flags)
     {
     // convert **ppFIXED to a double
     // return the double
     }
     public static void copyToExternal(double javaval,
                 int   ppFIXED,
                 int   Flags)
     {
     // convert double to a FIXED
     // copy the FIXED to **ppFIXED
     }
    ______________________________________

    ______________________________________
    CODE TABLE 2
    ______________________________________
    struct {
     short vt;
              // Always VT.sub.-- BSTR for this example
     short unused;
     short unused1;
     short unused2;
     BSTR bstrVal;
              // Points to characters in BSTR
     long unused3;
              // never used in this example.
    } VARIANT;
    public VarStrMarshaler {
     public static int cbByValSize;  // set of sizeof(VARIANT) = 16
     public static String toJava(int ppVARIANT, int flags)
     {
      // convert **ppVARIANT to a String
      // return the String
     }
     public static void copyToExternal(String javaval,
                 int   ppVARIANT,
                 int   Flags)
     {
      // convert String to a VARIANT
      // copy the VARIANT to **ppVARIANT
     }
     public static void releaseByValExternal(int ppVARIANT, int Flags)
     {
      SysStringFree( (*ppVARIANT) - >bstrVal );
     }
    ______________________________________

    ______________________________________
    CODE TABLE 3
    ______________________________________
                //JAVATYPE
     double ad1[ ] = {0};
     double ad2[ ] = {0};
     func(ad1, ad2);
     System.out.println("func gave back: " + ad1[0] + ", " + ad1[1]);
    }
    public PointMarshaler {
     public static int cbByValSize; // set of sizedof(POINT) = 8
     public static Point toJava(int ppPOINT, int flags)
     {
      // convert **ppPOINT to a Point
      // return the Point
     }
     public static void copyToExternal(Point javaval,
                 int    ppPOINT,
                 int    Flags)
     {
      // convert Point to a POINT
      // copy the POINT to **ppPOINT
     }
     public static void copyToJava(Point javaval, int ppPOINT, int Flags)
     {
      // modify "javaval" in place so it is "equivalent" to **ppPOINT;
     }
     public static Point toUninitJava(int ppPOINT, int flags)
     {
      // create a new Point with arbitrary x and y values.
      // the contents of **ppPOINT are completely undefined and
      // should be ignored for fixed-size hook classes.
     }
    }
    ______________________________________

    ______________________________________
    CODE TABLE 4
    ______________________________________
    public RectMarshaler {
     public static int cbByValSize; // set of sizeof(RECT) = 8
     public static Rect toJava(int ppRECT, int flags)
     {
      .backslash..backslash. convert **ppRECT to a Rect
      .backslash..backslash. return the Rect
     }
     public static void copyToExternal(Rect javaval,
                 int    ppRECT,
                 int    Flags)
     {
      .backslash..backslash. convert Rect to a RECT
      .backslash..backslash. copy the RECT to **ppRECT
     }
     public static void toExternal(Rect javaval, int ppRECT, int Flags)
     {
      .backslash..backslash. allocate a new RECT, initialize it using
    javaval,
      .backslash..backslash. store pointer in *ppRECT
     }
     public static void releaseExternal(int ppRECT, int Flags)
     {
      .backslash..backslash. release *ppRECT. If RECT required a
    releaseByValExternal
      .backslash..backslash. (which it doesn't), this routine must do that
    work as well.
     }
    ______________________________________

    ______________________________________
    CODE TABLE 5
    ______________________________________
    public AnsiMarshaler {
     public static String toJava(int ppCHAR, int flags)
     {
      // convert **ppCHAR to a String
      // return the String
     }
     public static void toExternal(String javaval, int ppCHAR, int Flags)
     {
      // allocate a new LPSTR, initialize it using javaval,
      // store pointer in *ppCHAR
     }
     public static void releaseExternal(int ppCHAR, int Flags)
     {
      // release *ppCHAR. If LPSTR required a
      // releaseByValExternal (which it doesn't), this routine
      // must do that work as well.
     }
    ______________________________________

• Inventors
  Kanamori, Atsushi;
• Assignee
  Microsoft Corporation (Redmond, WA)
• Published
  Dec-26-2000
• Current US Classes:
  707/103R
  709/201
  709/203
  717/114
  717/146
  718/1
  719/315
  719/330
• Application #
  004219
• International Classes
  G06F 009/44
• Field of Search
  709/1 709/300 709/304 709/303 709/203 707/103 717/5
• Examiner
  Teska; Kevin J.
• Agent
  Klarquist Sparkman Campbell Leigh & Whinston, LLP
• US Patent References:
  5377350
  5511197
  5524253
  5566302
  5577251
  5737607
  5758186
  5761499
  5875335
  5881230
  5887172
  5911069
  5920720
  5960200
  5991823
  5995974
  5999986
  5999988
  6006235
  6009464
  6016489