I8
`
`* pu1RetVal,
`** ppuserfixceptionsl;
`
`[out] CORBA_TypeCodeExceptions ** ppflsernxceptions);
`KRESULT member_eount(
`* pu1R8tVa1,
`[out] unsigned long
`[out] CORBA_TypeCodeExeeptions ** ppflserkxceptionsl;
`HRESULT member_name(
`ullndexl
`[in]
`unsigned long
`* pszRetVa1,
`[out] Identifier
`[out] CORBA_TypeCodeBxceptions ** ppvaerflxceptions );
`HRESULT member_type(
`u1Index,
`[in]
`unsigned long
`** ppRBtVa1.
`[out]
`ICORBA_TypeCode
`[out] CORBA_TypeCodeExceptions ** ppUserExeeptions );
`HRBSULT member_1abel(
`u1Index,
`[in]
`unsigned long
`‘* ppRetVa1.
`[out]
`ICORBA_Any
`[out] CORBA_TypeCodeExceptions ** ppUserExeeptions )7
`HRESULT discriminator_type(
`** ppketval,
`[out]
`ICORBA_TypeCode
`[out] CoRBA_'ry-pecodexxceptions ** ppUserExceptions );
`HRESULT default_index(
`* plRetVal,
`[out]
`long
`[out] CORBA_TypeCodeExceptions ** ppUserExceptions);
`HRESULT length(
`[out] unsigned long
`[out] CORBA_TypeCodeExeeptions
`_ HRESULT eontent_type( -
`** ppRetVal,
`[out]
`ICORBA_TypeCode
`[out] CORBA_TypeCodeExceptions ** ppflserxxceptionsl;
`HRESULT param_count(
`* plRetVa1,
`[out]
`long
`[out] CORBA_TypeCodeExeeptions ** ppUserExceptions);
`HRESULT parameter(
`[in]
`long
`[out]
`ICORBA_Any
`[out] CORBA_TypeCodeExeeptions
`
`);
`
`llndex,
`** ppRetVa1,
`** ppflserfixeeptions
`
`Note — Use of the methods param_count ()
`
`and parameter () is deprecated.
`
`18.2.12.2 Mappingfor contextpseudo-object
`
`This specification provides no mapping for CORBA’s Context pseudo-object into
`COM. Implementations that choose to provide support for Context could do so in the
`following way. Context pseudo-objects should be accessed through the ICORBA
`Context interface. This would allow clients (if they are aware that the object they
`are dealing with is a CORBA object) to set a single Context pseudo-object to be used
`for all subsequent invocations on the CORBA object from the client process space until
`such time as the ICORBA_Context interface is released.
`
`// Microsoft IDL and ODL
`typedef struct:
`
`December 200l
`
`CORBA, V2.6: CORBA to COM Data Type Mapping
`
`18-31
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex.1102,p.994of1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 994 of 1442
`
`

`
`18
`
`{ u
`
`nsigned long cbnaxsize;
`unsigned long cbLengthUaed;
`[size_is(cbMaxSize) , 1ength_is(cbLengthUsed) , unique]
`LPTSTR * pszvalue;
`
`} Context:PropertyVa1ue;
`
`[ object, uuid(74105F51-3C68-11cf«9588-AAOO04004A09).
`pointer_defau1t(unique) 1
`interface ICORBA_Context:
`{
`
`Itlnknown
`
`HRESULT GetProperty(
`
`I-{RESULT SetProperty(
`
`[in] LPTSTR Name,
`[out] ContextPropertyVa1ue
`** pvalues );
`[in] LPTSTR,
`[in] ContextPropertyVa1ue
`* pvaluesl ;
`
`};
`
`If a COM client application knows it is using a CORBA object, the client application
`can use QueryInter face to obtain an interface pointer to the
`
`ICORBA_Context interface. Obtaining the interface pointer results in a CORBA
`context pseudo-object being created in the View, which is used with any CORBA
`request operation that requires a reference to a CORBA context object. The context
`pseudo-object should be destroyed when the reference count on the
`ICORBA_Context interface reaches zero.
`
`This interface should only be generated for CORBA interfaces that have operations
`defined with the context clause.
`
`18.2. 12. 3 Mappingforprincipalpseudo-object
`
`The CORBA Principal is not currently mapped into COM. As both the COM and
`CORBA security mechanisms solidify, security interworking will need to be defined
`between the two object models.
`
`18.2.13 Interface Repository Mapping
`
`Name spaces within the CORBA interface repository are conceptually similar to COM
`type libraries. However, the CORBA interface repository looks, to the client, to be one
`unified service. Type libraries, on the other hand, are each stored in a separate file.
`Clients do not have a unified, hierarchical interface to type libraries.
`
`Table l8-6 defines the mapping between equivalent CORBA and COM interface
`description concepts. Where there is no equivalent, the field is left bla.nk.
`
`18-32
`
`Common Object Request Brrtker/irclzilecture (CORBA), v2.6
`
`December 2001
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 995 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 995 of 1442
`
`

`
`
`
`
`
`I8
`
`Table 18-6 CORBA Interface Repository to OLE Type Library Mappings
`
`TypeCode
`
`
`
`TYPEDESC
`
`
`
`_ M
`
`oduleDef
`
`lTypeLib
`
`lnterfaceDef
`
`lTypelnfo
`
`
`
`
`
`
`
`
`
`
`
`
`— U
`
`sing this mapping, implementations must provide the ability to call
`object: :get_interface on CORBA object references to COM objects to
`retrieve an lnterfaceDef. When CORBA objects are accessed from COM,
`implementations may provide the ability to retrieve the lTypelnfo for a CORBA object
`interface using the lProvideC1asslnfo COM interface.
`
`
`
`
`18.3 COMt0 CORBA Data Type_Mapping
`
`18.3.1 Mappingfor Basic Data Types
`
`The basic data types available in Microsoft IDL and ODL map to the corresponding
`data types available in OMG lDL as shown in Table 18-7.
`
`Table 18-7 Microsoft IDL and ODL to OMG IDL Intrinsic Data Type Mappings
`
`Microsoft
`IDL
`
`Microsoft
`ODL
`
`OMG IDL
`
` Signed integer with a range of -23'...23l -l
`Unsigned integer with a range of 0...216 -1
`
`%%
`
`
`
`
`
`
`
`
`
`
`
`MM
`
`December 2001
`
`CORBA, V2.6: COM In CORBA Data 7:vpe Mapping
`
`18-33
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 996 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 996 of 1442
`
`

`
`18
`
`Table 18-7 Microsoft IDL and ODL to OMG IDL Intrinsic Data Type Mappings (Continued)
`
`
`
`8-bit quantity limited to the ISO Latin-l character
`set
`
`8-bit opaque data type, guaranteed to not undergo
`any conversion during transfer between systems
`
`
`
`
`
`18.3.2 Mapping for Constants
`
`The mapping of the Microsoft IDL keyword const to OMG IDL const is almost exactly
`the same. The following Microsoft IDL definitions for constants:
`
`// Microsoft IDL
`.;
`const short S
`const long L = ...;
`const unsigned short Us =
`const unsigned long UL = ...;
`const float F = ...;
`const double D = ...;
`const char C = ..
`;
`const boolean B = ...;
`const string STR = “...";
`
`7
`
`map to the following OMG IDL definitions for constants.
`
`ll OMG IDL
`const short S =
`const long L = ...;
`const unsigned short US = ...;
`const unsigned long UL = ...;
`const float F = ...;
`const double D_=
`const char C = ...;
`const boolean B = ...;
`const string STR = “...";
`
`18.3.3 Mapping for Enumerators
`
`COM enumerations can have enumerators explicitly tagged with values. When COM
`enumerations are mapped into CORBA, the enumerators are presented in CORBA in
`increasing order according to their tagged values.
`
`The Microsoft IDL or ODL specification:
`
`18-34
`
`Common Object Request Broker A rch itecture (CORBA), v2.6
`
`December 200]
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 997 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 997 of 1442
`
`

`
`18
`
`IDL or ODL
`// Microsoft
`typedef
`[v1_enum]
`enum t:agA_or_B_orC {
`A_o r_B_o r_C ;
`’
`
`A = 0. B. C }
`
`would be represented as the following statements in OMG lDL:
`
`/I OMG IDL
`
`enum A_or_B_or_C (B, C, A};
`
`In this manner, the precedence relationship is maintained in the OMG system such that
`B is less than C is less than A.
`
`OMG lDL does not support enumerators defined with explicit tagged values. The
`CORBA view of a COM object, therefore, is responsible for maintaining the correct
`tagged value of the mapped enumerators as they cross the view.
`
`18.3.4 Mapping for String Types
`
`COM support for strings includes the concepts of bounded and unbounded strings.
`Bounded strings are defined as strings that have a maximum length specified, whereas
`unbounded strings do not have a maximum length specified. COM also supports
`Unicode strings where the characters are wider than 8 bits. As in OMG lDL, non-
`Unicode strings in COM are NULL-terminated. The mapping of COM definitions for
`bounded and unbounded strings differs from that specified in OMG lDL.
`
`Table 18-8 illustrates how to map the string data types in OMG lDL to their
`corresponding data types in both Microsoft lDL and ODL.
`
`Table 18-8 Microsoft IDL/ODL to OMG IDL String Mappings
`
`'
`
`Microsoft IDL
`
`Microsoft ODL
`
`OMGIDL
`
`
`LPWSTR
`LPWSTR
`Null-terminated Unicode string
`
`Null-terminated 8-bitcharacterstring
`
`Null-terminated 16-bit character string
`
`
`
`
`
`LPSTR,
`
`BSTR
`
`
`
`LPSTR
`
`[string,unique]
`char *
`
`BSTR
`
`[string,unique]
`char *
`
`
`
`lf a COM Server returns a BSTR containing embedded nulls to a CORBA client, a
`E_DATA_CONVERSlON exception will be raised.
`
`18.3.4.1 Mappingfor unbounded string types
`
`The definition of an unbounded string in Microsoft lDL and ODL denotes the
`unbounded string as a stringified unique pointer to a character. The following
`Microsoft lDL statement
`
`December 2001
`
`CORE/1. v2.6: COM In CORBA Data Yjvpe Mapping
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 998 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 998 of 1442
`
`

`
`I8
`
`// Microsoft IDL
`typedef [string, unique] char * UNBOUNDED_STRING;
`
`is mapped to the following syntax in OMG IDL.
`
`ll OMG IDL
`
`typedef string UNBOUNDED_STR|NG;
`
`In other words, a value of type UNBOUNDED__STR|NG is a non-NULL pointer to a
`one-dimensional null-terminated character array whose extent and number of valid
`elements can vary at run-time.
`
`18.3.4.2 Mappingfor bounded string types
`
`Bounded strings have a slightly different mapping between OMG IDL and Microsoft
`IDL. Bounded strings are expressed in Microsoft IDL as a “stringified nonconformant
`array.” The following Microsoft IDL and ODL definition for a bounded string:
`
`// Microsoft IDL and ODL
`const long N = ...;
`typedef Istring, unique] char
`
`maps to the following syntax in OMG lDL.
`
`/I OMG IDL
`
`_
`const long N = ...;
`typedef string<N> BOUNDED_STR|NG;
`
`(* BOUNDED_S'1‘RING)
`
`[N];
`
`ln other words, the encoding for a value of type BOUNDED_STR|NG is that of a
`null-terminated array of characters whose extent is known at compile time, and whose
`number of valid characters can vary at run-time.
`
`18.3.4.3 Mappingfor Unicode Unbounded String Types
`
`The mapping for a Unicode unbounded string type in Microsoft IDL or ODL is no
`different from that used for ANSI string types. The following Microsoft IDL and ODL
`statement
`
`// Microsoft IDL arid ODL
`typedef [string, unique] LPWSTR
`UNBOUNDED_UNICODE_S TRING;
`
`is mapped to the following syntax in OMG lDL.
`
`II OMG IDL
`
`typedef wstring UNBOUNDED_UN|CODE_STR|NG;
`
`It is the responsibility of the mapping implementation to perform the conversions
`between ANSI and Unicode formats when dealing with strings.
`
`18-36
`
`Common Object Request BmkerArchiIecture (CORBA), v2.6
`
`December 200]
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 999 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 999 of 1442
`
`

`
`18
`
`18.3.4.4 Mappingfor unicode bound string types
`
`The mapping for a Unicode bounded string type in Microsoft lDL or ODL is no
`different from that used for ANSI string types. The following Microsoft IDL and ODL
`statements
`
`// Microsoft IDL and ODL
`const long N = ...;
`typedef
`lstring, unique] wchar t(*
`BOUNDED_UNICODE_STRING)
`[N];
`
`map to the following syntax in OMG lDL.
`
`/I OMG IDL
`
`const long N = ...;
`typedef wstring<N> BOUNDED_UNlCODE_STRlNG;
`
`It is the responsibility of the mapping implementation to perform the conversions
`between AN S1 and Unicode formats when dealing with strings.
`
`18.3.5 Mapping for Structure Ijzpes
`
`Support for structures in Microsoft lDL and ODL maps bidirectionally to OMG IDL.
`Each structure member is mapped according to the mapping rules for that data type.
`The structure definition in Microsoft lDL or ODL is as follows.
`
`// Microsoft IDL and ODL
`typedef .
`.
`. T0;
`typedef .
`. . T1;
`
`. .TN;
`typedef .
`typedef struct
`
`{T
`
`0 m0;
`T1 ml;
`
`TN m.N;
`
`} STRUCTURE;
`
`The structure has an equivalent mapping in OMG IDL, as follows:
`
`December 2001
`
`CORBA. V2.6.‘ COM m comm Data rype Mapping
`
`13-37
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1000 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1000 of 1442
`
`

`
`18
`
`// OMG IDL
`
`typedef
`typedef
`
`T0
`T1;
`
`TN;
`t-yiipedef
`struct STRUCTURE
`
`{ T
`
`0 m0;
`T1 ml;
`
`Tn mm;
`};
`
`18.3.6 Mapping for Union Types
`
`ODL unions are not discriminated unions and must be custom marshaled in any
`interfaces that use them. For this reason, this specification does not provide any
`mapping for ODL unions to CORBA unions.
`
`MIDL unions, while always discriminated, are not required to be encapsulated. The
`discriminator for a nonencapsulated MIDL union could, for example, be another
`argument to the operation. The discriminants for MIDI. unions are not required to be
`constant expressions.
`
`18.3.6.1 Mappingfor Encapsulated Unions
`
`When mapping from Microsoft IDL to OMG IDL, Microsoft IDL encapsulated unions
`having constant discriminators are mapped to OMG IDL unions as shown next.
`
`// Microsoft IDL
`typedef enum
`
`{d
`
`char,
`dshort,
`dLong,
`dF1oat,
`dnouble
`
`} UNION_DI SCRIMINATOR;
`
`typedef union switch (UNION_DISCRIMINA'1‘OR _d)
`
`{c
`
`ase dChar: char c;
`case dshort: short 3;
`case dLong:
`long 1;
`case dF1oat: float f;
`case dDoub1e: double d;
`
`default: byte v[8];
`}UNION_OF_CHAR_AND_ARITHME'1'IC ;
`
`The OMG IDL definition is as follows.
`
`13-33
`
`Common Object Request BmkerArchiIecture (CORBA). V2.6
`
`December 2001
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex.1102,p.1001of1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1001 of 1442
`
`

`
`I8
`
`ll OMG IDL
`
`enum UN|0N_D|SCRlM|NATOR
`
`( d
`
`chan
`dshort,
`dLong,
`dF|oat,
`dDoub|e
`
`};
`
`union UNION_OF_CHAR_AND_ARlTHMETlC
`switch(UN|ON_D|SCR|MINATOR)
`
`{ c
`
`ase dChar: char c;
`case dShort: short s;
`case dLong: long I;
`case dFloat:. float f;
`case dDouble:. double d;
`default: octet v[8];
`
`};
`
`18.3.6.2 Mappingfor nonencapsulated unions
`
`Microsoft IDL nonencapsulated unions and Microsoft IDL encapsulated unions with
`nonconstant discriminators are mapped to an any in OMG IDL. The type of the any is
`determined at run-time during conversion of the Microsofi IDL union.
`
`// Microsoft IDL
`
`[switch_type( short )1 union
`typedef
`tagUNIoN_oF_cHAR_ANn_ARI'rmn:'r1c
`
`{[
`
`case(0)] char c;
`[case(1)] short 3;
`[case(2)]
`long 1;
`[case(3)] float f;
`[case(4)] double d;
`[default] byte v[8];
`
`} UNION_0F_CHAR_AND_ARI'1'H.ME'1‘IC;
`
`The corresponding OMG IDL syntax is as follows.
`
`/I OMG IDL
`
`typedef any UN|ON_0F_CHAR_AND_AR|THMET|C;
`
`December 2001
`
`CORBA, v2.6: COM to CORBA Data Type Mapping
`
`18-39
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex.1102,p.1002of1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1002 of 1442
`
`

`
`18
`
`18.3. 7 Mappingfor Array Types
`
`COM supports fixed-length arrays, just as in CORBA. As in the mapping from OMG
`IDL to Microsoft lDL, the arrays can be mapped bidirectionally. The type of the array
`elements is mapped according to the data type mapping rules. The following
`statements in Microsoft IDL and ODL describe a nonconformant and nonvarying array
`of U.
`
`// Microsoft IDL for T
`const long N =. ...;
`typedef
`. .
`. U;
`
`typedef U ARRAY_OF_N [N];
`typedef float D’l'.‘YPE[O..l0];
`
`// Equivalent to [11]
`
`The value N can be of any integral type, and const means (as in OMG lDL) that the
`value of N is fixed and known at compilation time. The generalization to
`multidimensional arrays follows the obvious trivial mapping of syntax.
`
`The corresponding OMG IDL syntax is as follows.
`
`// OMG IDL for T
`
`const long N = ...;
`typedef
`T;
`typedef T ARRAY_OF_N[N];
`typedef float DTYPE[11];
`
`18.3.7.1
`
`Mappingfor nonfixed arrays
`
`ln addition to fixed length arrays, as well as conformant arrays, COM supports varying
`arrays, and conformant varying arrays. These are arrays whose bounds and size can be
`determined at run-time. Nonfixed length arrays in Microsofi lDL and ODL are mapped
`to sequence in OMG IDL, as shown in the following-statements.
`
`// Microsoft IDL
`typedef short BTYPEU;
`typedef char C'I‘YPE["'] ;
`
`The corresponding OMG IDL syntax is as follows.
`
`ll OMG IDL
`
`typedef sequence<short> BTYPE;
`typedef sequence<char> CTYPE;
`
`// Equivalent
`
`to [i];
`
`18.3.7.2
`
`Mappingfor SAFEARRAY
`
`Microsoft ODL also defines SAFEARRAY as a variable length, variable dimension
`array. Both the number of dimensions and the bounds of the dimensions are determined
`at run-time. Only the element type is predefined. A SAFEARRAY in Microsoft ODL is
`mapped to a CORBA sequence, as shown in the following statements.
`
`18-40
`
`Cnmmnn Object Request Broker A rchitecture (CORBA). v2. 6
`
`December 2001
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1003 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1003 of 1442
`
`

`
`I8
`
`// Microsoft ODL
`SAFEARRAY (el ement - type)
`
`* Arrayname ;
`
`ll OMG IDL
`
`typedef sequence<eIement-type> SequenceName;
`
`If a COM server returns a multidimensional SAFEARRAY to a CORBA client, an
`
`E_DATA_CONVERSlON exception will be raised.
`
`18.3.8 Mapping for VARIANT
`
`The COM VARIANT provides semantically similar functionality to the CORBA any.
`However, its allowable set of data types are currently limited to the data types
`_
`supported by Automation. VARTYPE is an enumeration type used in the VARIANT
`structure. The structure member vt is defined using the data type VARTYPE. Its value
`acts as the discriminator for the embedded union and governs the interpretation of the
`union. The list of valid values for the data type VARTYPE are listed in Table 18-9,
`along with a description of how to use them to represent the OMG IDL any data type.
`
`Table 18-9 Valid OLE VARIANT Data Types
`
`VT_EMPTY
`
`No value was specified. If an argument is left blank, you should not
`
`return VT_EMPTY for the argument. Instead, you should return the
`VT_ERROR value: DISP_E_MEMBERNOTl-“OUND.
`
`
`
`g
`
`
`
`
`
`
`
`VT_EMPTY |
`VT_BYREF
`
`Illegal.
`
`VT_Ull
`
`An unsigned l-byte character is stored in bVaI.
`
`VT_Ull I
`VT_BYREF
`
`A reference to an unsigned l-byte character was passed; a pointer to
`the value is in pb Val.
`
`VT_l2
`
`‘A 2-byte integer value is stored in iVaI.
`
`I VT 12 I VT_BYREF
`
`A reference to a 2-byte integer was passed a pointer to the value IS
`in [)1 Val
`
`VT_I4
`
`A 4-byte integer value is stored in [Val
`
`VT_l4 | VT BYREF
`
`A reference to a 4 byte integer was passed; a pointer to the value is
`in pl Val
`
`VT R4
`
`An IEEE 4-byte real value IS stored in fltVal
`
`VT_R4 |
`VT_BYREF
`
`VT_R8 |
`VT_BYREF
`
`
`
`A reference to an IEEE 4 byte real was passed; a pointer to the
`value is in pflt Val
`An 8-byte IEEE real value IS stored in dbIVal
`A reference to an 8-byte IEEE real was passed, a pointer to its value
`is in pdbIVaI.
`
`
`
`
`
`December 2001
`
`CORBA. V2.6.‘ COM In CORBA Data Type Mapping
`
`18-41
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1004 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1004 of 1442
`
`

`
`I8
`
`Table 18-9 Valid OLE VARIANT Data Types (Continued)
`
`
`
`A currency value was specified. A currency number is stored as an
`8-byte, two’s complement integer, scaled by 10,000 to give a fixed-
`point number with 15 digits to the left of the decimal point and 4
`digits to the right. The value is in cyVal.
`
`
`
`A reference to a currency value was passed; a pointer to the value is
`in pcyVa1.
`
`A string was passed; it is stored in bstrVal. This pointer must be
`obtained and freed via the BSTR functions.
`
`A reference to a string was passed. A BSTR‘, which points to a
`BSTR, is in pbstrVaI. The referenced pointer must be obtained or
`freed via the BSTR functions.
`
`A propagating NULL value was specified. This should not be
`confused with the NULL pointer. The NULL value is used for tri-
`state logic as with SQL.
`
`lllegal.
`
`
`
`VT_CY
`
`VT_CY |
`VT_BYREF
`
`VT_BSTR
`
`VT_BSTR |
`VT_BYREF
`
`VT_NULL
`
`VT_NULL [
`V'1‘_BYREF
`
`\/T_ERROR'
`
`
`
`
`
`
`VT_ERROR I
`VT_BYREF
`
`VT_BOOL
`
`
`
`
`
`
`
`
`
`
`
`An SCODE was specified. The type of error is specified in code.
`Generally, operations on error values should raise an exception or
`propagate the error to the return value, as appropriate.
`
`A reference to an SCODE was passed. A pointer to the value is in
`pscode.
`.
`‘
`
`' A Boolean (True/False) value was specified. A value of 0xFFFF (all
`bits one) indicates True; a value of 0 (all bits zero) indicates False.
`No other values are legal.
`
`
`
`
`
`VT_BOOL 1
`VT_BYREF
`
`A reference to a Boolean value. A pointer to the Boolean value is in
`pbool.
`
`
`VT_DATE
`
`
`
`
`A value denoting a date and time was specified. Dates are
`represented as double-precision numbers, where midnight, January
`1, 1900 is 2.0, January 2, 1900 is 3.0, and so on. The value is passed
`in date.
`
`
`
`
`This is the same numbering system used by most spreadsheet
`programs, although some incorrectly believe that February 29, 1900
`
`existed, and thus set January 1, 1900 to 1.0. The date can be
`convened to and from an MS-DOS representation using
`
`VariantTimcToDosDateTime.
`
`A reference to a date was passed. A pointer to the value is in pdate.
`
`
`
`VT_DATE I
`VT_BYREF
`
`l8—42
`
`Common Object Request Broker /1 rch [lecture (CORE/1). v2. 6
`
`December 200]
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1005 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1005 of 1442
`
`

`
`18
`
`Table 18-9 Valid OLE VARIANT Data Types (Continued)
`
`VT_DlSPATCl-l
`
`A pointer to an object was specified. The pointer is in pdispVaI. This
`object is only known to implement lDispatch; the object can be
`queried as to whether it supports any other desired interface by
`calling Querylnterface on the object. Objects that do not implement
`lDispatch should be passed using VT_UNl(NOWN.
`
`VT_DlSPATCH |
`VT_BYREF
`
`A pointer to a pointer to an object was specified. The pointer to the
`object is stored in the location referred to by ppdisp Val.
`
`VT_VARlANT
`
`lllegal. VARIANTARGS must be passed by reference.
`
`VT_VARlANT I
`VT_BYREF
`
`A pointer to another VARJANTARG is passed in pvarVaI. This
`referenced VARIANTARG will never have the VT_BYREF bit set
`in vt, so only one level of indirection can ever be present. This value
`can be used to support languages that allow functions to change the
`types of variables passed by reference.
`
`VT_UNl(NOWN
`
`A pointer to an object that implements the lUnknown interface is
`passed in punkVal.
`
`VT_UNl(NOWN |
`VT_BYREF
`
`A pointer to a pointer to the lUnknown interface is passed in
`ppunkVaI. The pointer to the interface is stored in the location
`referred to by ppunkVa1.
`
`VT_ARRAY |
`<anything>
`
`An array of data type <anything> was passed. (VT_EMPTY and
`VT_NULL are illegal types to combine with VT_ARRAY.) The
`pointer in pByrejVaI points to an array descriptor, which describes
`the dimensions, size, and in-memory location of the array. The array
`descriptor is never accessed directly, but instead is readand
`modified using functions.
`
`A COM VARIANT is mapped to the CORBA any without loss. lf at run-time a
`CORBA client passes an inconvertible any to a COM server, a
`DATA_CONVE RSION exception is raised.
`
`18.3.9 Mappingfor Pointers
`
`MIDL supports three types of pointers:
`
`' Reference pointer; a non-null pointer to a single item. The pointer cannot represent
`a data stmcture with cycles or aliasing (two pointers to the same address).
`
`Unique pointer; a (possibly null) pointer to a single item. The pointer cannot
`represent a data structure with cycles or aliasing.
`
`Full pointer; a (possibly null) pointer to a single item. Full pointers can be used for
`data structures, which form cycles or have aliases.
`
`December 2001
`
`CORBA, v2.6: COM to COREA Data Type Mapping
`
`18.43
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1006 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1006 of 1442
`
`

`
`I8
`
`A reference pointer is mapped to a CORBA sequence containing one element. Unique
`pointers and full pointers with no aliases or cycles are mapped to a CORBA sequence
`containing zero or one elements. If at run-time a COM client passes a full pointer
`containing aliases or cycles to a CORBA server, E_DATA_CONVERSlON is returned
`to the COM client. lf a COM server attempts to return a full pointer containing aliases
`or cycles to a CORBA client, a DATA_CONVERS|ON exception is raised.
`
`18.3.10 Interface Mapping
`
`COM is a binary standard based upon standard machine calling conventions. Although
`interfaces can be expressed in Microsoft lDL, Microsoft ODL, or C++, the following
`interface mappings between COM and CORBA will use Microsoft ODL as the
`language of expression for COM constructs.
`
`COM interface pointers bidirectionally map to CORBA Object references with the
`appropriate mapping of Microsoft lDL and ODL interfaces to OMG lDL interfaces.
`
`18.3.I0.1
`
`Mappingfor Interface Identifiers
`
`Interface identifiers are used in both CORBA and COM to uniquely identify interfaces.
`These allow the client code to retrieve information about, or to inquire about other
`interfaces of an object.
`
`COM identifies interfaces using a structure similar to the DCE UUID (in fact, identical
`to a DCE UUlD on Win32) known as an llD. As with CORBA, COM specifies that the
`textual names of interfaces are only for convenience and need not be globally unique.
`
`The COM interface identifier (llD and CLSID) are bidirectionally mapped to the
`CORBA Repositoryld.
`
`I8.3.10.2
`
`Mappingfor COM Errors
`
`COM will provide error information to clients only if an operation uses a return result
`of type HRESULT. The COM HRESULT, if zero, indicates success. The HRESULT, if
`nonzero, can be converted into an SCODE (the SCODE is explicitly specified as being
`the same as the HRESULT on Win32). The SCODE can then be examined to
`determine whether the call succeeded or failed. The error or success code, also
`contained within the SCODE, is composed of a “facility” major code (13 bits on
`Win32 and 4 bits on Win16) and a 16-bit minor code.
`
`COM object developers are expected to use one of the predefined SCODE values, or
`use the facility FAClLlTY_lTF and an interface-specific minor code. SCODE values
`can indicate either success codes or error codes. A typical use is to overload the
`SCODE with a boolean value, using S_OK and S_FALSE success codes to indicate a
`true or false return. If the COM server returns S_OK or S_FALSE, a CORBA
`exception will not be raised and the value of the SCODE will be mapped as the return
`value. This is because COM operations, which are defined to return an HRESULT, are
`mapped to CORBA as returning an HRESULT.
`
`18-44
`
`Commnn Object Request Bmker A rcli ilecture (CORBA). v2. 6
`
`December 2001
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1007 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1007 of 1442
`
`

`
`C18
`
`Unlike CORBA, COM provides no standard way to return user-defined exception data
`to the client. Also, there is no standard mechanism in COM to specify the completion
`status of an invocation. In addition, it is not possible to predeterrnine what set of errors
`a COM interface might return. Although the set of success codes that can be returned
`from a COM operation must be fixed when the operation is defined, there is currently
`no machine-readable way to discover what the set of valid success codes are.
`
`COM exceptions have a straightforward mapping into CORBA. COM system error
`codes are mapped to the CORBA standard exceptions. COM user-defined error codes
`are mapped to CORBA user exceptions.
`
`COM system error codes are defined with the FAClLlTY_NULL and FAClLlTY_RPC
`facility codes. All FAClLlTY_NULL and FAClLlTY_RPC COM errors are mapped to
`CORBA standard exceptions. Table 18-10 lists the mapping from COM
`FAClLlTY_NULL exceptions to CORBA standard exceptions.
`
`Table 18-10Mapping from COM FACILITY_NULL Error Codes to
`CORBA Standard (System) Exceptions
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`a
`
`
`
`
`
`Table l8-ll lists the mapping from COM FAClLlTY_RPC exceptions to CORBA
`standard exceptions. All FAClLlTY_RPC exceptions not listed in this table are mapped
`to the new CORBA standard exception COM.
`
`Table 18-] 1 Mapping from COM FAClLlTY_RPC Error Codes to CORBA Standard
`(System) Exceptions
`
`
`
`
`
`
`
`
`
`December 200]
`
`CORBA. V2.6: COM In CORBA Data Tjvpe Mapping
`
`18.45
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1008 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1008 of 1442
`
`

`
`18
`
`Table 18-11 Mapping fiom COM FAClLI'I'Y_RPC Error Codes to CORBA Standard
`(System) Exceptions (Continued)
`
`
`
`
`
`
`
`COM SCODES, other than those previously listed, are mapped into CORBA user
`exceptions and will require the use of the raises clause in OMG IDL. Since the OMG
`IDL mapping from the Microsoft IDL and ODL is likely to be generated, this is not a
`burden to the average programmer. The following OMG lDL illustrates such a user
`exception.
`
`// OMG IDL
`
`exception COM_ERROREX
`(
`.
`
`long hresult;
`Any info;
`'
`
`l:
`
`The COM_ERROREX extension is designed to allow exposure of exceptions passed
`using the per-thread ErrorObjcct. The Any contained in the COM_ERROREX is
`defined to hold a CORBA object reference that supports the OMG IDL mapping for
`the lError|nfo interface.
`‘
`
`l8-46
`
`Common Object Request Broker Architecture (CORBA), V2. 6
`
`December 2001
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1009 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1009 of 1442
`
`

`
`I8
`
`18. 3. 10. 3 Mapping 0fNested Data Types
`
`Microsoft MIDL (and ODL) consider all definitions to be at global (or library) scope
`regardless of position in the file. This can lead to name collisions in datatypes across
`interfaces. Operations or types later in the file can refer to a datatype without fully
`qualifying the name even if the type is nested within another interface.
`
`For purposes of mapping MlDL/ODL to OMG lDL, we treat nested datatypes as if
`they had been prepended with the name of the scoping level. Thus:
`
`interface IA :
`
`IUnknown
`
`{
`
`typedef enum {ONE, TWO, THREE} Count;
`HRESULT f( [in] Count val);
`
`} i
`
`s mapped as if it were defined as:
`
`typedef enum {A_ONE, A_TWO, A_THREE} A_Count;
`interface IA :
`Iunknown
`
`HRESULT f( [in] A_Count val);
`
`{ }
`
`18.3. 10. 4 Mapping 0fNames
`
`Microsoft MIDI. and ODL support prefixing types/names with leading underscores.
`When mapping from Microsoft MIDL or ODL to OMG lDL, the leading underscores .
`are re moved.
`
`Note — This simple rule is not sufficient to avoid all name collisions (such as MIDL
`types that clash with OMG lDL reserved names or situations where two operation
`names differ only in the leading underscore). However, this rule will cover many
`common cases and leads to a more natural mapping than prepending a character before
`the underscore.
`'
`
`18. 3. 10. 5 Mappingfor Operations
`
`Operations defined for an interface are defined in Microsoft lDL and ODL within
`interface definitions. The definition of an operation constitutes the operations
`signature. An operation signature consists of the operation’s name, parameters (if any),
`and return value. Unlike OMG lDL, Microsoft lDL and ODL does not allow the
`operation definition to indicate the error information that can be returned.
`
`Microsoft IDL and ODL parameter directional attributes (|in|, loutl, lin, out:|) map
`directly to OMG lDL (in, out, inout). Operation request parameters are represented as
`the values of [in] or |inout| parameters in Microsoft lDL, and operation response
`parameters are represented as the values of |inout| or |out] parameters. An
`
`December 2001
`
`CORBA, v2. 6: COM 10 CORR/1 Data Yype Mapping
`
`18-47
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1010 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 1010 of 1442
`
`

`
`I8
`
`operation return result can be any type that can be defined in Microsoft lDL/ODL, or
`void if a result is not returned. By convention, most operations are defined to retum an
`HRESULT. This provides a consistent way to return operation status information.
`
`When Microsoft ODL methods are mapped to OMG lDL, they undergo the following
`transformations. First, if the last parameter is tagged with the Microsoft ODL keyword
`retval, that argument will be used as the return type of the operation. If the last
`parameter is not tagged with retval, then the signature is mapped directly to OMG lDL
`following the mapping rules for the data types of the arguments. Some example
`mappings from COM methods to OMG lDL operations are shown in the following
`code.
`
`[in] VARIANT value,
`[out, retvall LPSTR * pszVa1ue) ;
`
`// Microsoft ODL
`interface IFoo:
`
`IUnknown
`
`{H
`
`RESULT st:ringi£y(
`
`HRESULT permute(
`
`[inout] short
`
`* value);
`
`HRESUL'I‘.tryPermute( [inout] short * value,
`[out]
`long newvaluel;
`
`};
`
`ln OMG