| 1 | // Licensed to the .NET Foundation under one or more agreements. | 
|---|
| 2 | // The .NET Foundation licenses this file to you under the MIT license. | 
|---|
| 3 | // See the LICENSE file in the project root for more information. | 
|---|
| 4 | // METASIG.H | 
|---|
| 5 | // | 
|---|
| 6 |  | 
|---|
| 7 | // | 
|---|
| 8 | // All literal MetaData signatures should be defined here. | 
|---|
| 9 | // | 
|---|
| 10 |  | 
|---|
| 11 |  | 
|---|
| 12 | // Generic sig's based on types. | 
|---|
| 13 |  | 
|---|
| 14 | // All sigs are alphabetized by the signature string and given a canonical name.  Do not | 
|---|
| 15 | // give them "meaningful" names because we want to share them aggressively.  Do not add | 
|---|
| 16 | // duplicates! | 
|---|
| 17 |  | 
|---|
| 18 | // The canonical form: | 
|---|
| 19 | // | 
|---|
| 20 | //   <what>(<type>*, <name>*) | 
|---|
| 21 | // | 
|---|
| 22 | //   where <what> is: | 
|---|
| 23 | // | 
|---|
| 24 | //         Fld  -- field | 
|---|
| 25 | //         IM   -- instance method (HASTHIS == TRUE) | 
|---|
| 26 | //         SM   -- static method | 
|---|
| 27 | // | 
|---|
| 28 | //   and <name> -- <type> is: | 
|---|
| 29 | // | 
|---|
| 30 | //   a  -- Arr  -- array | 
|---|
| 31 | //   P  -- Ptr  -- a pointer | 
|---|
| 32 | //   r  -- Ref  -- a byref | 
|---|
| 33 | //         Ret  -- indicates function return type | 
|---|
| 34 | // | 
|---|
| 35 | //         Var  -- Variant | 
|---|
| 36 | // | 
|---|
| 37 | //   b  -- Byte -- (unsigned) byte | 
|---|
| 38 | //   u  -- Char -- character (2 byte unsigned unicode) | 
|---|
| 39 | //   d  -- Dbl  -- double | 
|---|
| 40 | //   f  -- Flt  -- float | 
|---|
| 41 | //   i  -- Int  -- integer | 
|---|
| 42 | //   K  -- UInt  -- unsigned integer | 
|---|
| 43 | //   I  -- IntPtr -- agnostic integer | 
|---|
| 44 | //   U  -- UIntPtr -- agnostic unsigned integer | 
|---|
| 45 | //   l  -- Long -- long integer | 
|---|
| 46 | //   L  -- ULong -- unsigned long integer | 
|---|
| 47 | //   h  -- Shrt -- short integer | 
|---|
| 48 | //   H  -- UShrt -- unsigned short integer | 
|---|
| 49 | //   v  -- Void -- Void | 
|---|
| 50 | //   B  -- SByt -- signed byte | 
|---|
| 51 | //   F  -- Bool -- boolean | 
|---|
| 52 | //   j  -- Obj  -- System.Object | 
|---|
| 53 | //   s  -- Str  -- System.String | 
|---|
| 54 | //   C  --      -- class | 
|---|
| 55 | //   g  --      -- struct | 
|---|
| 56 | //   T  -- TypedReference -- TypedReference | 
|---|
| 57 | //   G  --      -- Generic type variable | 
|---|
| 58 | //   M  --      -- Generic method variable | 
|---|
| 59 | //   GI --      -- Generic type instantiation | 
|---|
| 60 | //   Q          -- modreq | 
|---|
| 61 |  | 
|---|
| 62 | //#DEFINE_METASIG | 
|---|
| 63 | // Use DEFINE_METASIG for signatures that does not reference other types | 
|---|
| 64 | // Use DEFINE_METASIG_T for signatures that reference other types (contains C or g) | 
|---|
| 65 |  | 
|---|
| 66 |  | 
|---|
| 67 | // This part of the file is included multiple times with different macro definitions | 
|---|
| 68 | // to generate the hardcoded metasigs. | 
|---|
| 69 |  | 
|---|
| 70 |  | 
|---|
| 71 | // SM, IM and Fld macros have often a very similar definitions. METASIG_BODY is | 
|---|
| 72 | // a helper to avoid these redundant SM, IM and Fld definitions. | 
|---|
| 73 | #ifdef METASIG_BODY | 
|---|
| 74 | #ifndef DEFINE_METASIG | 
|---|
| 75 | // See code:#DEFINE_METASIG | 
|---|
| 76 | #define DEFINE_METASIG(body)            body | 
|---|
| 77 | #endif | 
|---|
| 78 | #define SM(varname, args, retval)       METASIG_BODY( SM_ ## varname, args retval ) | 
|---|
| 79 | #define IM(varname, args, retval)       METASIG_BODY( IM_ ## varname, args retval ) | 
|---|
| 80 | #define GM(varname, n, conv, args, retval) METASIG_BODY( GM_ ## varname, args retval ) | 
|---|
| 81 | #define Fld(varname, val)               METASIG_BODY( Fld_ ## varname, val ) | 
|---|
| 82 | #endif | 
|---|
| 83 |  | 
|---|
| 84 |  | 
|---|
| 85 | #ifdef DEFINE_METASIG | 
|---|
| 86 |  | 
|---|
| 87 | // Use default if undefined | 
|---|
| 88 | // See code:#DEFINE_METASIG | 
|---|
| 89 | #ifndef DEFINE_METASIG_T | 
|---|
| 90 | #define DEFINE_METASIG_T(body) DEFINE_METASIG(body) | 
|---|
| 91 | #endif | 
|---|
| 92 |  | 
|---|
| 93 | // One letter shortcuts are defined for all types that can occur in the signature. | 
|---|
| 94 | // The shortcuts are defined indirectly through METASIG_ATOM. METASIG_ATOM is | 
|---|
| 95 | // designed to control whether to generate the initializer for the signature or | 
|---|
| 96 | // just compute the size of the signature. | 
|---|
| 97 |  | 
|---|
| 98 | #define b METASIG_ATOM(ELEMENT_TYPE_U1) | 
|---|
| 99 | #define u METASIG_ATOM(ELEMENT_TYPE_CHAR) | 
|---|
| 100 | #define d METASIG_ATOM(ELEMENT_TYPE_R8) | 
|---|
| 101 | #define f METASIG_ATOM(ELEMENT_TYPE_R4) | 
|---|
| 102 | #define i METASIG_ATOM(ELEMENT_TYPE_I4) | 
|---|
| 103 | #define K METASIG_ATOM(ELEMENT_TYPE_U4) | 
|---|
| 104 | #define I METASIG_ATOM(ELEMENT_TYPE_I) | 
|---|
| 105 | #define U METASIG_ATOM(ELEMENT_TYPE_U) | 
|---|
| 106 | #define l METASIG_ATOM(ELEMENT_TYPE_I8) | 
|---|
| 107 | #define L METASIG_ATOM(ELEMENT_TYPE_U8) | 
|---|
| 108 | #define h METASIG_ATOM(ELEMENT_TYPE_I2) | 
|---|
| 109 | #define H METASIG_ATOM(ELEMENT_TYPE_U2) | 
|---|
| 110 | #define v METASIG_ATOM(ELEMENT_TYPE_VOID) | 
|---|
| 111 | #define B METASIG_ATOM(ELEMENT_TYPE_I1) | 
|---|
| 112 | #define F METASIG_ATOM(ELEMENT_TYPE_BOOLEAN) | 
|---|
| 113 | #define j METASIG_ATOM(ELEMENT_TYPE_OBJECT) | 
|---|
| 114 | #define s METASIG_ATOM(ELEMENT_TYPE_STRING) | 
|---|
| 115 | #define T METASIG_ATOM(ELEMENT_TYPE_TYPEDBYREF) | 
|---|
| 116 |  | 
|---|
| 117 |  | 
|---|
| 118 | // METASIG_RECURSE controls whether to recurse into the complex types | 
|---|
| 119 | // in the macro expansion. METASIG_RECURSE is designed to control | 
|---|
| 120 | // whether to compute the byte size of the signature or just compute | 
|---|
| 121 | // the number of arguments in the signature. | 
|---|
| 122 |  | 
|---|
| 123 | #if METASIG_RECURSE | 
|---|
| 124 |  | 
|---|
| 125 | #define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY) x | 
|---|
| 126 | #define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR) x | 
|---|
| 127 | #define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF) x | 
|---|
| 128 |  | 
|---|
| 129 | #define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR) METASIG_ATOM(n) | 
|---|
| 130 | #define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR) METASIG_ATOM(n) | 
|---|
| 131 |  | 
|---|
| 132 | #define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST) type METASIG_ATOM(n) x | 
|---|
| 133 |  | 
|---|
| 134 | // The references to other types have special definition in some cases | 
|---|
| 135 | #ifndef C | 
|---|
| 136 | #define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100) | 
|---|
| 137 | #endif | 
|---|
| 138 | #ifndef g | 
|---|
| 139 | #define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100) | 
|---|
| 140 | #endif | 
|---|
| 141 | #ifndef Q | 
|---|
| 142 | #define Q(x) METASIG_ATOM(ELEMENT_TYPE_CMOD_REQD) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100) | 
|---|
| 143 | #endif | 
|---|
| 144 |  | 
|---|
| 145 | #else | 
|---|
| 146 |  | 
|---|
| 147 | #define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY) | 
|---|
| 148 | #define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR) | 
|---|
| 149 | #define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF) | 
|---|
| 150 |  | 
|---|
| 151 | #define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR) | 
|---|
| 152 | #define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR) | 
|---|
| 153 |  | 
|---|
| 154 | #define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST) | 
|---|
| 155 |  | 
|---|
| 156 | // The references to other types have special definition in some cases | 
|---|
| 157 | #ifndef C | 
|---|
| 158 | #define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS) | 
|---|
| 159 | #endif | 
|---|
| 160 | #ifndef g | 
|---|
| 161 | #define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE) | 
|---|
| 162 | #endif | 
|---|
| 163 |  | 
|---|
| 164 | #define Q(x) | 
|---|
| 165 |  | 
|---|
| 166 | #endif | 
|---|
| 167 |  | 
|---|
| 168 |  | 
|---|
| 169 |  | 
|---|
| 170 | // to avoid empty arguments for macros | 
|---|
| 171 | #define _ | 
|---|
| 172 |  | 
|---|
| 173 |  | 
|---|
| 174 | // static methods: | 
|---|
| 175 | DEFINE_METASIG_T(SM(Int_IntPtr_Obj_RetException, i I j, C(EXCEPTION))) | 
|---|
| 176 | DEFINE_METASIG_T(SM(Type_ArrType_IntPtr_int_RetType, C(TYPE) a(C(TYPE)) I i, C(TYPE) )) | 
|---|
| 177 | DEFINE_METASIG_T(SM(Type_RetIntPtr, C(TYPE), I)) | 
|---|
| 178 | DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_Int_RetObj, I I I i, j)) | 
|---|
| 179 | DEFINE_METASIG(SM(Obj_IntPtr_RetIntPtr, j I, I)) | 
|---|
| 180 | DEFINE_METASIG(SM(Obj_IntPtr_RetObj, j I, j)) | 
|---|
| 181 | DEFINE_METASIG(SM(Obj_RefIntPtr_RetVoid, j r(I), v)) | 
|---|
| 182 | DEFINE_METASIG(SM(Obj_IntPtr_RetVoid, j I, v)) | 
|---|
| 183 | DEFINE_METASIG(SM(Obj_IntPtr_RetBool, j I, F)) | 
|---|
| 184 | DEFINE_METASIG(SM(Obj_IntPtr_IntPtr_Int_RetIntPtr, j I I i, I)) | 
|---|
| 185 | DEFINE_METASIG(SM(IntPtr_IntPtr_RefIntPtr_RetObj, I I r(I), j)) | 
|---|
| 186 | #ifdef FEATURE_COMINTEROP | 
|---|
| 187 | DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RefBool_RetIntPtr, j I r(I) r(F), I)) | 
|---|
| 188 | DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RetIntPtr, j I r(I), I)) | 
|---|
| 189 | DEFINE_METASIG_T(SM(Obj_Str_RetICustomProperty, j s, C(ICUSTOMPROPERTY))) | 
|---|
| 190 | DEFINE_METASIG_T(SM(Obj_Str_PtrTypeName_RetICustomProperty, j s P(g(TYPENAMENATIVE)), C(ICUSTOMPROPERTY))) | 
|---|
| 191 | DEFINE_METASIG_T(SM(Obj_PtrTypeName_RetVoid, j P(g(TYPENAMENATIVE)), v)) | 
|---|
| 192 | DEFINE_METASIG_T(SM(Type_PtrTypeName_RetVoid, C(TYPE) P(g(TYPENAMENATIVE)), v)) | 
|---|
| 193 | DEFINE_METASIG_T(SM(PtrTypeName_RefType_RetVoid, P(g(TYPENAMENATIVE)) r(C(TYPE)), v)) | 
|---|
| 194 | DEFINE_METASIG_T(SM(ArrType_PtrTypeName_RetVoid, a(C(TYPE)) P(g(TYPENAMENATIVE)), v)) | 
|---|
| 195 | DEFINE_METASIG_T(SM(PtrTypeName_ArrType_RetVoid, P(g(TYPENAMENATIVE)) a(C(TYPE)), v)) | 
|---|
| 196 | DEFINE_METASIG_T(SM(PtrTypeName_RetVoid, P(g(TYPENAMENATIVE)), v)) | 
|---|
| 197 | DEFINE_METASIG_T(SM(PtrTypeName_Int_RetVoid, P(g(TYPENAMENATIVE)) i, v)) | 
|---|
| 198 | DEFINE_METASIG_T(SM(Exception_IntPtr_RetException, C(EXCEPTION) I, C(EXCEPTION))) | 
|---|
| 199 | #endif // FEATURE_COMINTEROP | 
|---|
| 200 | DEFINE_METASIG(SM(Int_RetVoid, i, v)) | 
|---|
| 201 | DEFINE_METASIG(SM(Int_Int_RetVoid, i i, v)) | 
|---|
| 202 | DEFINE_METASIG(SM(Str_RetIntPtr, s, I)) | 
|---|
| 203 | DEFINE_METASIG(SM(Str_RetBool, s, F)) | 
|---|
| 204 | DEFINE_METASIG(SM(IntPtr_IntPtr_RetVoid, I I, v)) | 
|---|
| 205 | DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetIntPtr, I I j, I)) | 
|---|
| 206 | DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Obj_RetIntPtr, I I i j, I)) | 
|---|
| 207 | DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_RetVoid, I I I, v)) | 
|---|
| 208 | DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_UShrt_RetVoid, I I I H, v)) | 
|---|
| 209 | DEFINE_METASIG(SM(IntPtr_Int_IntPtr_RetIntPtr, I i I, I)) | 
|---|
| 210 | DEFINE_METASIG(SM(IntPtr_IntPtr_Int_IntPtr_RetVoid, I I i I, v)) | 
|---|
| 211 | DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetVoid, I I j, v)) | 
|---|
| 212 | DEFINE_METASIG(SM(Obj_ArrObject_RetVoid, j a(j), v)) | 
|---|
| 213 | DEFINE_METASIG(SM(Obj_IntPtr_Obj_RetVoid, j I j, v)) | 
|---|
| 214 | DEFINE_METASIG(SM(RetUIntPtr, _, U)) | 
|---|
| 215 | DEFINE_METASIG(SM(RetIntPtr, _, I)) | 
|---|
| 216 | DEFINE_METASIG(SM(RetBool, _, F)) | 
|---|
| 217 | DEFINE_METASIG(SM(IntPtr_RetStr, I, s)) | 
|---|
| 218 | DEFINE_METASIG(SM(IntPtr_RetBool, I, F)) | 
|---|
| 219 | DEFINE_METASIG(SM(IntPtrIntPtrIntPtr_RetVoid, I I I, v)) | 
|---|
| 220 | DEFINE_METASIG_T(SM(IntPtrIntPtrIntPtr_RefCleanupWorkListElement_RetVoid, I I I r(C(CLEANUP_WORK_LIST_ELEMENT)), v)) | 
|---|
| 221 | DEFINE_METASIG_T(SM(RuntimeType_RuntimeMethodHandleInternal_RetMethodBase, C(CLASS) g(METHOD_HANDLE_INTERNAL), C(METHOD_BASE) )) | 
|---|
| 222 | DEFINE_METASIG_T(SM(RuntimeType_IRuntimeFieldInfo_RetFieldInfo, C(CLASS) C(I_RT_FIELD_INFO), C(FIELD_INFO) )) | 
|---|
| 223 | DEFINE_METASIG_T(SM(RuntimeType_Int_RetPropertyInfo, C(CLASS) i, C(PROPERTY_INFO) )) | 
|---|
| 224 | DEFINE_METASIG(SM(Char_Bool_Bool_RetByte, u F F, b)) | 
|---|
| 225 | DEFINE_METASIG(SM(Byte_RetChar, b, u)) | 
|---|
| 226 | DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetIntPtr, s F F r(i), I)) | 
|---|
| 227 | DEFINE_METASIG(SM(IntPtr_Int_RetStr, I i, s)) | 
|---|
| 228 | DEFINE_METASIG_T(SM(Obj_PtrByte_RefCleanupWorkListElement_RetVoid, j P(b) r(C(CLEANUP_WORK_LIST_ELEMENT)), v)) | 
|---|
| 229 | DEFINE_METASIG(SM(Obj_PtrByte_RetVoid, j P(b), v)) | 
|---|
| 230 | DEFINE_METASIG(SM(PtrByte_IntPtr_RetVoid, P(b) I, v)) | 
|---|
| 231 | DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetArrByte, s F F r(i), a(b) )) | 
|---|
| 232 | DEFINE_METASIG(SM(ArrByte_Int_PtrByte_Int_Int_RetVoid, a(b) i P(b) i i, v)) | 
|---|
| 233 | DEFINE_METASIG(SM(PtrByte_Int_ArrByte_Int_Int_RetVoid, P(b) i a(b) i i, v)) | 
|---|
| 234 | DEFINE_METASIG(SM(PtrByte_RetInt, P(b), i)) | 
|---|
| 235 | DEFINE_METASIG(SM(PtrSByt_RetInt, P(B), i)) | 
|---|
| 236 | DEFINE_METASIG(SM(IntPtr_RetIntPtr, I, I)) | 
|---|
| 237 | DEFINE_METASIG(SM(UIntPtr_RetIntPtr, U, I)) | 
|---|
| 238 | DEFINE_METASIG(SM(PtrByte_PtrByte_Int_RetVoid, P(b) P(b) i, v)) | 
|---|
| 239 | DEFINE_METASIG(SM(RefObj_IntPtr_RetVoid, r(j) I, v)) | 
|---|
| 240 | DEFINE_METASIG(SM(RefObj_RefIntPtr_RetVoid, r(j) r(I), v)) | 
|---|
| 241 | DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_RetVoid, I r(j) I, v)) | 
|---|
| 242 | DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Int_RetVoid, I r(j) I i,v)) | 
|---|
| 243 | DEFINE_METASIG(SM(IntPtr_Int_IntPtr_Int_Int_Int_RetVoid, I i I i i i, v)) | 
|---|
| 244 | DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Int_RetVoid, I I i i, v)) | 
|---|
| 245 | DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Obj_RetVoid, I r(j) I j, v)) | 
|---|
| 246 | DEFINE_METASIG(SM(Obj_Int_RetVoid, j i,v)) | 
|---|
| 247 |  | 
|---|
| 248 | DEFINE_METASIG(SM(Flt_RetFlt, f, f)) | 
|---|
| 249 | DEFINE_METASIG(SM(Dbl_RetDbl, d, d)) | 
|---|
| 250 | DEFINE_METASIG(SM(RefDbl_Dbl_RetDbl, r(d) d, d)) | 
|---|
| 251 | DEFINE_METASIG(SM(RefDbl_Dbl_Dbl_RetDbl, r(d) d d, d)) | 
|---|
| 252 | DEFINE_METASIG(SM(RefLong_Long_RetLong, r(l) l, l)) | 
|---|
| 253 | DEFINE_METASIG(SM(RefLong_Long_Long_RetLong, r(l) l l, l)) | 
|---|
| 254 | DEFINE_METASIG(SM(RefFlt_Flt_RetFlt, r(f) f, f)) | 
|---|
| 255 | DEFINE_METASIG(SM(RefFlt_Flt_Flt_RetFlt, r(f) f f, f)) | 
|---|
| 256 | DEFINE_METASIG(SM(RefInt_Int_RetInt, r(i) i, i)) | 
|---|
| 257 | DEFINE_METASIG(SM(RefInt_Int_Int_RetInt, r(i) i i, i)) | 
|---|
| 258 | DEFINE_METASIG(SM(RefInt_Int_Int_RefBool_RetInt, r(i) i i r(F), i)) | 
|---|
| 259 | DEFINE_METASIG(SM(RefIntPtr_IntPtr_RetIntPtr, r(I) I, I)) | 
|---|
| 260 | DEFINE_METASIG(SM(RefIntPtr_IntPtr_IntPtr_RetIntPtr, r(I) I I, I)) | 
|---|
| 261 | DEFINE_METASIG(SM(RefObj_Obj_RetObj, r(j) j, j)) | 
|---|
| 262 | DEFINE_METASIG(SM(RefObj_Obj_Obj_RetObj, r(j) j j, j)) | 
|---|
| 263 | DEFINE_METASIG(SM(ObjIntPtr_RetVoid, j I, v)) | 
|---|
| 264 |  | 
|---|
| 265 | DEFINE_METASIG(SM(RefBool_RetBool, r(F), F)) | 
|---|
| 266 | DEFINE_METASIG(SM(RefBool_Bool, r(F) F, v)) | 
|---|
| 267 | DEFINE_METASIG(SM(RefSByt_RetSByt, r(B), B)) | 
|---|
| 268 | DEFINE_METASIG(SM(RefSByt_SByt, r(B) B, v)) | 
|---|
| 269 | DEFINE_METASIG(SM(RefByte_RetByte, r(b), b)) | 
|---|
| 270 | DEFINE_METASIG(SM(RefByte_Byte, r(b) b, v)) | 
|---|
| 271 | DEFINE_METASIG(SM(RefShrt_RetShrt, r(h), h)) | 
|---|
| 272 | DEFINE_METASIG(SM(RefShrt_Shrt, r(h) h, v)) | 
|---|
| 273 | DEFINE_METASIG(SM(RefUShrt_RetUShrt, r(H), H)) | 
|---|
| 274 | DEFINE_METASIG(SM(RefUShrt_UShrt, r(H) H, v)) | 
|---|
| 275 | DEFINE_METASIG(SM(RefInt_RetInt, r(i), i)) | 
|---|
| 276 | DEFINE_METASIG(SM(RefInt_Int, r(i) i, v)) | 
|---|
| 277 | DEFINE_METASIG(SM(RefUInt_RetUInt, r(K), K)) | 
|---|
| 278 | DEFINE_METASIG(SM(RefUInt_UInt, r(K) K, v)) | 
|---|
| 279 | DEFINE_METASIG(SM(RefLong_RetLong, r(l), l)) | 
|---|
| 280 | DEFINE_METASIG(SM(RefLong_Long, r(l) l, v)) | 
|---|
| 281 | DEFINE_METASIG(SM(RefULong_RetULong, r(L), L)) | 
|---|
| 282 | DEFINE_METASIG(SM(RefULong_ULong, r(L) L, v)) | 
|---|
| 283 | DEFINE_METASIG(SM(RefIntPtr_RetIntPtr, r(I), I)) | 
|---|
| 284 | DEFINE_METASIG(SM(RefIntPtr_IntPtr, r(I) I, v)) | 
|---|
| 285 | DEFINE_METASIG(SM(RefUIntPtr_RetUIntPtr, r(U), U)) | 
|---|
| 286 | DEFINE_METASIG(SM(RefUIntPtr_UIntPtr, r(U) U, v)) | 
|---|
| 287 | DEFINE_METASIG(SM(RefFlt_RetFlt, r(f), f)) | 
|---|
| 288 | DEFINE_METASIG(SM(RefFlt_Flt, r(f) f, v)) | 
|---|
| 289 | DEFINE_METASIG(SM(RefDbl_RetDbl, r(d), d)) | 
|---|
| 290 | DEFINE_METASIG(SM(RefDbl_Dbl, r(d) d, v)) | 
|---|
| 291 | DEFINE_METASIG(GM(RefT_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), M(0))) | 
|---|
| 292 | DEFINE_METASIG(GM(RefT_T, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0), v)) | 
|---|
| 293 |  | 
|---|
| 294 | DEFINE_METASIG(GM(RefByte_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b), M(0))) | 
|---|
| 295 | DEFINE_METASIG(GM(RefByte_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b) M(0), v)) | 
|---|
| 296 | DEFINE_METASIG(GM(PtrVoid_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), M(0))) | 
|---|
| 297 | DEFINE_METASIG(GM(PtrVoid_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) M(0), v)) | 
|---|
| 298 |  | 
|---|
| 299 | DEFINE_METASIG(GM(RefT_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), r(M(0)))) | 
|---|
| 300 | DEFINE_METASIG(GM(VoidPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), r(M(0)))) | 
|---|
| 301 | DEFINE_METASIG(GM(RefTFrom_RetRefTTo, IMAGE_CEE_CS_CALLCONV_DEFAULT, 2, r(M(0)), r(M(1)))) | 
|---|
| 302 | DEFINE_METASIG(GM(Obj_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, j, M(0))) | 
|---|
| 303 | DEFINE_METASIG(GM(RefT_Int_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) i, r(M(0)))) | 
|---|
| 304 | DEFINE_METASIG(GM(RefT_IntPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) I, r(M(0)))) | 
|---|
| 305 | DEFINE_METASIG(GM(PtrVoid_Int_RetPtrVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) i, P(v))) | 
|---|
| 306 |  | 
|---|
| 307 | DEFINE_METASIG_T(SM(SafeHandle_RefBool_RetIntPtr, C(SAFE_HANDLE) r(F), I )) | 
|---|
| 308 | DEFINE_METASIG_T(SM(SafeHandle_RetVoid, C(SAFE_HANDLE), v )) | 
|---|
| 309 |  | 
|---|
| 310 | DEFINE_METASIG_T(SM(RetMethodBase, _, C(METHOD_BASE))) | 
|---|
| 311 | DEFINE_METASIG(SM(RetVoid, _, v)) | 
|---|
| 312 | DEFINE_METASIG(SM(Str_IntPtr_Int_RetVoid, s I i, v)) | 
|---|
| 313 | DEFINE_METASIG(SM(Int_RetIntPtr, i, I)) | 
|---|
| 314 |  | 
|---|
| 315 | DEFINE_METASIG_T(SM(DateTime_RetDbl, g(DATE_TIME), d)) | 
|---|
| 316 | DEFINE_METASIG(SM(Dbl_RetLong, d, l)) | 
|---|
| 317 |  | 
|---|
| 318 | DEFINE_METASIG(SM(IntPtr_RetObj, I, j)) | 
|---|
| 319 | DEFINE_METASIG_T(SM(Int_RetException, i, C(EXCEPTION))) | 
|---|
| 320 | DEFINE_METASIG(SM(Int_IntPtr_RetObj, i I, j)) | 
|---|
| 321 | DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetVoid, I I i, v)) | 
|---|
| 322 | DEFINE_METASIG_T(SM(Exception_RetInt, C(EXCEPTION), i)) | 
|---|
| 323 |  | 
|---|
| 324 |  | 
|---|
| 325 | DEFINE_METASIG(SM(IntPtr_RetVoid, I, v)) | 
|---|
| 326 | DEFINE_METASIG(SM(IntPtr_Bool_RetVoid, I F, v)) | 
|---|
| 327 | DEFINE_METASIG(SM(IntPtr_UInt_IntPtr_RetVoid, I K I, v)) | 
|---|
| 328 | DEFINE_METASIG(SM(IntPtr_RetUInt, I, K)) | 
|---|
| 329 | DEFINE_METASIG(SM(PtrChar_RetInt, P(u), i)) | 
|---|
| 330 | DEFINE_METASIG(SM(IntPtr_IntPtr_RetIntPtr, I I, I)) | 
|---|
| 331 | DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetIntPtr, I I i, I)) | 
|---|
| 332 | DEFINE_METASIG(SM(PtrVoid_PtrVoid_RetVoid, P(v) P(v), v)) | 
|---|
| 333 | DEFINE_METASIG(IM(Obj_RetBool, j, F)) | 
|---|
| 334 | DEFINE_METASIG(SM(Obj_RetVoid, j, v)) | 
|---|
| 335 | DEFINE_METASIG(SM(Obj_RetInt, j, i)) | 
|---|
| 336 | DEFINE_METASIG(SM(Obj_RetIntPtr, j, I)) | 
|---|
| 337 | DEFINE_METASIG(SM(Obj_RetObj, j, j)) | 
|---|
| 338 | DEFINE_METASIG(SM(Obj_RetArrByte, j, a(b))) | 
|---|
| 339 | DEFINE_METASIG(SM(Obj_Bool_RetArrByte, j F, a(b))) | 
|---|
| 340 | DEFINE_METASIG(SM(Obj_Obj_RefArrByte_RetArrByte, j j r(a(b)), a(b))) | 
|---|
| 341 |  | 
|---|
| 342 | #ifdef FEATURE_COMINTEROP | 
|---|
| 343 | DEFINE_METASIG_T(SM(Obj_Int_RefVariant_RetVoid, j i r(g(VARIANT)), v)) | 
|---|
| 344 | DEFINE_METASIG_T(SM(Obj_RefVariant_RetVoid, j r(g(VARIANT)), v)) | 
|---|
| 345 | DEFINE_METASIG_T(SM(RefVariant_RetObject, r(g(VARIANT)), j)) | 
|---|
| 346 | DEFINE_METASIG_T(SM(Str_PtrHStringHeader_RetIntPtr, s P(g(HSTRING_HEADER_MANAGED)), I)) | 
|---|
| 347 |  | 
|---|
| 348 | DEFINE_METASIG_T(SM(RefDateTimeOffset_RefDateTimeNative_RetVoid, r(g(DATE_TIME_OFFSET)) r(g(DATETIMENATIVE)), v)) | 
|---|
| 349 |  | 
|---|
| 350 | #endif | 
|---|
| 351 |  | 
|---|
| 352 |  | 
|---|
| 353 | DEFINE_METASIG(SM(Str_RetInt, s, i)) | 
|---|
| 354 | DEFINE_METASIG_T(SM(Str_RetICustomMarshaler, s, C(ICUSTOM_MARSHALER))) | 
|---|
| 355 | DEFINE_METASIG(SM(Int_Str_RetIntPtr, i s, I)) | 
|---|
| 356 | DEFINE_METASIG(SM(Int_Str_IntPtr_RetIntPtr, i s I, I)) | 
|---|
| 357 | DEFINE_METASIG(SM(Str_IntPtr_RetIntPtr, s I, I)) | 
|---|
| 358 | DEFINE_METASIG(SM(Str_Bool_Int_RetV, s F i, v)) | 
|---|
| 359 |  | 
|---|
| 360 | DEFINE_METASIG_T(SM(Type_RetInt, C(TYPE), i)) | 
|---|
| 361 | DEFINE_METASIG(SM(ArrByte_RetObj, a(b), j)) | 
|---|
| 362 | DEFINE_METASIG(SM(ArrByte_Bool_RetObj, a(b) F, j)) | 
|---|
| 363 | DEFINE_METASIG(SM(ArrByte_ArrByte_RefObj_RetObj, a(b) a(b) r(j), j)) | 
|---|
| 364 | DEFINE_METASIG_T(SM(PtrSByt_Int_Int_Encoding_RetStr, P(B) i i C(ENCODING), s)) | 
|---|
| 365 |  | 
|---|
| 366 | DEFINE_METASIG_T(SM(Void_RetRuntimeTypeHandle, _, g(RT_TYPE_HANDLE))) | 
|---|
| 367 | DEFINE_METASIG(SM(Void_RetIntPtr, _, I)) | 
|---|
| 368 |  | 
|---|
| 369 | DEFINE_METASIG_T(SM(UInt_UInt_PtrNativeOverlapped_RetVoid, K K P(g(NATIVEOVERLAPPED)), v)) | 
|---|
| 370 |  | 
|---|
| 371 | DEFINE_METASIG(IM(Long_RetVoid, l, v)) | 
|---|
| 372 | DEFINE_METASIG(IM(IntPtr_Int_RetVoid, I i, v)) | 
|---|
| 373 | DEFINE_METASIG(IM(IntInt_RetArrByte, i i, a(b))) | 
|---|
| 374 | DEFINE_METASIG(IM(RetIntPtr, _, I)) | 
|---|
| 375 | DEFINE_METASIG(IM(RetInt, _, i)) | 
|---|
| 376 | DEFINE_METASIG_T(IM(RetAssemblyName, _, C(ASSEMBLY_NAME))) | 
|---|
| 377 | DEFINE_METASIG_T(IM(RetAssemblyBase, _, C(ASSEMBLYBASE))) | 
|---|
| 378 | DEFINE_METASIG_T(IM(RetModule, _, C(MODULE))) | 
|---|
| 379 | DEFINE_METASIG_T(IM(Str_ArrB_ArrB_Ver_CI_AHA_AVC_Str_ANF_SNKP_RetV, | 
|---|
| 380 | s a(b) a(b) C(VERSION) C(CULTURE_INFO) g(ASSEMBLY_HASH_ALGORITHM) g(ASSEMBLY_VERSION_COMPATIBILITY) s g(ASSEMBLY_NAME_FLAGS) C(STRONG_NAME_KEY_PAIR), v)) | 
|---|
| 381 | DEFINE_METASIG_T(IM(PEK_IFM_RetV, | 
|---|
| 382 | g(PORTABLE_EXECUTABLE_KINDS) g(IMAGE_FILE_MACHINE), v)) | 
|---|
| 383 | DEFINE_METASIG(IM(RetObj, _, j)) | 
|---|
| 384 | DEFINE_METASIG_T(IM(RetIEnumerator, _, C(IENUMERATOR))) | 
|---|
| 385 | DEFINE_METASIG(IM(RetStr, _, s)) | 
|---|
| 386 | DEFINE_METASIG(IM(RetLong, _, l)) | 
|---|
| 387 |  | 
|---|
| 388 | DEFINE_METASIG_T(IM(RetType, _, C(TYPE))) | 
|---|
| 389 | DEFINE_METASIG(IM(RetVoid, _, v)) | 
|---|
| 390 | DEFINE_METASIG(IM(RetBool, _, F)) | 
|---|
| 391 | DEFINE_METASIG(IM(RetArrByte, _, a(b))) | 
|---|
| 392 | DEFINE_METASIG_T(IM(RetArrParameterInfo, _, a(C(PARAMETER)))) | 
|---|
| 393 | DEFINE_METASIG_T(IM(RetCultureInfo, _, C(CULTURE_INFO))) | 
|---|
| 394 | #ifdef FEATURE_COMINTEROP | 
|---|
| 395 | DEFINE_METASIG_T(IM(RetCausalityTraceLevel, _, g(CAUSALITY_TRACE_LEVEL))) | 
|---|
| 396 | #endif // FEATURE_COMINTEROP | 
|---|
| 397 |  | 
|---|
| 398 | DEFINE_METASIG(IM(Bool_RetIntPtr, F, I)) | 
|---|
| 399 | DEFINE_METASIG_T(IM(Bool_RetMethodInfo, F, C(METHOD_INFO))) | 
|---|
| 400 | DEFINE_METASIG(SM(Bool_RetStr, F, s)) | 
|---|
| 401 | DEFINE_METASIG(IM(Bool_Bool_RetStr, F F, s)) | 
|---|
| 402 |  | 
|---|
| 403 | DEFINE_METASIG(IM(PtrChar_RetVoid, P(u), v)) | 
|---|
| 404 | DEFINE_METASIG(IM(PtrChar_Int_Int_RetVoid, P(u) i i, v)) | 
|---|
| 405 | DEFINE_METASIG_T(IM(ReadOnlySpanOfChar_RetVoid, GI(g(READONLY_SPAN), 1, u), v)) | 
|---|
| 406 | DEFINE_METASIG(IM(PtrSByt_RetVoid, P(B), v)) | 
|---|
| 407 | DEFINE_METASIG(IM(PtrSByt_Int_Int_RetVoid, P(B) i i, v)) | 
|---|
| 408 | DEFINE_METASIG_T(IM(PtrSByt_Int_Int_Encoding_RetVoid, P(B) i i C(ENCODING), v)) | 
|---|
| 409 | DEFINE_METASIG(IM(PtrChar_Int_RetVoid, P(u) i, v)) | 
|---|
| 410 | DEFINE_METASIG(IM(PtrSByt_Int_RetVoid, P(B) i, v)) | 
|---|
| 411 |  | 
|---|
| 412 | DEFINE_METASIG(IM(ArrChar_RetStr, a(u), s)) | 
|---|
| 413 | DEFINE_METASIG(IM(ArrChar_Int_Int_RetStr, a(u) i i, s)) | 
|---|
| 414 | DEFINE_METASIG(IM(Char_Int_RetStr, u i, s)) | 
|---|
| 415 | DEFINE_METASIG(IM(PtrChar_RetStr, P(u), s)) | 
|---|
| 416 | DEFINE_METASIG(IM(PtrChar_Int_Int_RetStr, P(u) i i, s)) | 
|---|
| 417 | DEFINE_METASIG_T(IM(ReadOnlySpanOfChar_RetStr, GI(g(READONLY_SPAN), 1, u), s)) | 
|---|
| 418 | DEFINE_METASIG(IM(PtrSByt_RetStr, P(B), s)) | 
|---|
| 419 | DEFINE_METASIG(IM(PtrSByt_Int_Int_RetStr, P(B) i i, s)) | 
|---|
| 420 | DEFINE_METASIG_T(IM(PtrSByt_Int_Int_Encoding_RetStr, P(B) i i C(ENCODING), s)) | 
|---|
| 421 | DEFINE_METASIG(IM(Obj_Int_RetIntPtr, j i, I)) | 
|---|
| 422 |  | 
|---|
| 423 | DEFINE_METASIG(IM(Char_Char_RetStr, u u, s)) | 
|---|
| 424 | DEFINE_METASIG(IM(Char_Int_RetVoid, u i, v)) | 
|---|
| 425 | DEFINE_METASIG_T(SM(RetCultureInfo, _, C(CULTURE_INFO))) | 
|---|
| 426 | DEFINE_METASIG_T(SM(CultureInfo_RetVoid, C(CULTURE_INFO), v)) | 
|---|
| 427 | DEFINE_METASIG(IM(Dbl_RetVoid, d, v)) | 
|---|
| 428 | DEFINE_METASIG(IM(Flt_RetVoid, f, v)) | 
|---|
| 429 | DEFINE_METASIG(IM(Int_RetInt, i, i)) | 
|---|
| 430 | DEFINE_METASIG(IM(Int_RefIntPtr_RefIntPtr_RefIntPtr_RetVoid, i r(I) r(I) r(I), v)) | 
|---|
| 431 | DEFINE_METASIG(IM(Int_RetStr, i, s)) | 
|---|
| 432 | DEFINE_METASIG(IM(Int_RetVoid, i, v)) | 
|---|
| 433 | DEFINE_METASIG(IM(Int_RetBool, i, F)) | 
|---|
| 434 | DEFINE_METASIG(IM(Int_Int_RetVoid, i i, v)) | 
|---|
| 435 | DEFINE_METASIG(IM(Int_Int_Int_RetVoid, i i i, v)) | 
|---|
| 436 | DEFINE_METASIG(IM(Int_Int_Int_Int_RetVoid, i i i i, v)) | 
|---|
| 437 | DEFINE_METASIG_T(IM(Obj_EventArgs_RetVoid, j C(EVENT_ARGS), v)) | 
|---|
| 438 | DEFINE_METASIG_T(IM(Obj_UnhandledExceptionEventArgs_RetVoid, j C(UNHANDLED_EVENTARGS), v)) | 
|---|
| 439 |  | 
|---|
| 440 | DEFINE_METASIG_T(IM(Assembly_RetBool, C(ASSEMBLY), F)) | 
|---|
| 441 | DEFINE_METASIG_T(IM(AssemblyBase_RetBool, C(ASSEMBLYBASE), F)) | 
|---|
| 442 | DEFINE_METASIG_T(IM(Exception_RetVoid, C(EXCEPTION), v)) | 
|---|
| 443 |  | 
|---|
| 444 | DEFINE_METASIG(IM(IntPtr_RetObj, I, j)) | 
|---|
| 445 | DEFINE_METASIG(IM(IntPtr_RetVoid, I, v)) | 
|---|
| 446 | DEFINE_METASIG(IM(IntPtr_PtrVoid_RetVoid, I P(v), v)) | 
|---|
| 447 | DEFINE_METASIG_T(IM(RefGuid_RetIntPtr, r(g(GUID)), I)) | 
|---|
| 448 |  | 
|---|
| 449 | DEFINE_METASIG(IM(Obj_RetInt, j, i)) | 
|---|
| 450 | DEFINE_METASIG(IM(Obj_RetIntPtr, j, I)) | 
|---|
| 451 | DEFINE_METASIG(IM(Obj_RetVoid, j, v)) | 
|---|
| 452 | DEFINE_METASIG(IM(Obj_RetObj, j, j)) | 
|---|
| 453 | DEFINE_METASIG(IM(Obj_IntPtr_RetVoid, j I, v)) | 
|---|
| 454 | DEFINE_METASIG(IM(Obj_UIntPtr_RetVoid, j U, v)) | 
|---|
| 455 | DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_RetVoid, j I I, v)) | 
|---|
| 456 | DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_RetVoid, j I I I, v)) | 
|---|
| 457 | DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_IntPtr_RetVoid, j I I I I, v)) | 
|---|
| 458 | DEFINE_METASIG(IM(IntPtr_UInt_IntPtr_IntPtr_RetVoid, I K I I, v)) | 
|---|
| 459 | DEFINE_METASIG(IM(Obj_Bool_RetVoid, j F, v)) | 
|---|
| 460 | #ifdef FEATURE_COMINTEROP | 
|---|
| 461 | DEFINE_METASIG(SM(Obj_RetStr, j, s)) | 
|---|
| 462 | DEFINE_METASIG_T(IM(Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetObj, s g(BINDING_FLAGS) j a(j) a(F) a(i) a(C(TYPE)) C(TYPE), j)) | 
|---|
| 463 | #endif // FEATURE_COMINTEROP | 
|---|
| 464 | DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) C(CULTURE_INFO), v)) | 
|---|
| 465 | DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), v)) | 
|---|
| 466 | DEFINE_METASIG_T(IM(Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetObj, j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), j)) | 
|---|
| 467 | DEFINE_METASIG_T(IM(Obj_Type_CultureInfo_RetObj, j C(TYPE) C(CULTURE_INFO), j)) | 
|---|
| 468 | DEFINE_METASIG_T(IM(MemberInfo_RetVoid, C(MEMBER), v)) | 
|---|
| 469 | DEFINE_METASIG(IM(IntPtr_ArrObj_Obj_RefArrObj_RetObj, I a(j) j r(a(j)), j)) | 
|---|
| 470 | DEFINE_METASIG(IM(RefObject_RetBool, r(j), F)) | 
|---|
| 471 | DEFINE_METASIG_T(IM(Class_RetObj, C(CLASS), j)) | 
|---|
| 472 | DEFINE_METASIG(IM(Int_VoidPtr_RetVoid, i P(v), v)) | 
|---|
| 473 | DEFINE_METASIG(IM(VoidPtr_RetVoid, P(v), v)) | 
|---|
| 474 |  | 
|---|
| 475 | DEFINE_METASIG_T(IM(Str_RetModule, s, C(MODULE))) | 
|---|
| 476 | DEFINE_METASIG_T(SM(Assembly_Str_RetAssembly, C(ASSEMBLY) s, C(ASSEMBLY))) | 
|---|
| 477 | DEFINE_METASIG_T(SM(Str_Bool_RetAssembly, s F, C(ASSEMBLY))) | 
|---|
| 478 | DEFINE_METASIG(IM(Str_Str_Obj_RetVoid, s s j, v)) | 
|---|
| 479 | DEFINE_METASIG(IM(Str_Str_Str_Obj_RetVoid, s s s j, v)) | 
|---|
| 480 | DEFINE_METASIG(IM(Str_Str_Str_Obj_Bool_RetVoid, s s s j F, v)) | 
|---|
| 481 | DEFINE_METASIG(IM(Str_Str_RefObj_RetVoid, s s r(j), v)) | 
|---|
| 482 | DEFINE_METASIG_T(IM(Str_RetFieldInfo, s, C(FIELD_INFO))) | 
|---|
| 483 | DEFINE_METASIG_T(IM(Str_RetPropertyInfo, s, C(PROPERTY_INFO))) | 
|---|
| 484 | DEFINE_METASIG(SM(Str_RetStr, s, s)) | 
|---|
| 485 | DEFINE_METASIG_T(SM(Str_CultureInfo_RetStr, s C(CULTURE_INFO), s)) | 
|---|
| 486 | DEFINE_METASIG_T(SM(Str_CultureInfo_RefBool_RetStr, s C(CULTURE_INFO) r(F), s)) | 
|---|
| 487 | DEFINE_METASIG(SM(PtrPtrChar_PtrPtrChar_Int_RetVoid, P(P(u)) P(P(u)) i, v)) | 
|---|
| 488 | DEFINE_METASIG(SM(ArrStr_RetVoid, a(s), v)) | 
|---|
| 489 | DEFINE_METASIG(IM(Str_RetVoid, s, v)) | 
|---|
| 490 | DEFINE_METASIG(SM(RefBool_RefBool_RetVoid, r(F) r(F), v)) | 
|---|
| 491 | DEFINE_METASIG_T(IM(Str_Exception_RetVoid, s C(EXCEPTION), v)) | 
|---|
| 492 | DEFINE_METASIG(IM(Str_Obj_RetVoid, s j, v)) | 
|---|
| 493 | DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_ArrType_ArrParameterModifier_RetMethodInfo, \ | 
|---|
| 494 | s g(BINDING_FLAGS) C(BINDER) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(METHOD_INFO))) | 
|---|
| 495 | DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Type_ArrType_ArrParameterModifier_RetPropertyInfo, \ | 
|---|
| 496 | s g(BINDING_FLAGS) C(BINDER) C(TYPE) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(PROPERTY_INFO))) | 
|---|
| 497 | DEFINE_METASIG(IM(Str_Str_RetStr, s s, s)) | 
|---|
| 498 | DEFINE_METASIG(IM(Str_Str_RetVoid, s s, v)) | 
|---|
| 499 | DEFINE_METASIG(IM(Str_Str_Str_RetVoid, s s s, v)) | 
|---|
| 500 | DEFINE_METASIG(IM(Str_Int_RetVoid, s i, v)) | 
|---|
| 501 | DEFINE_METASIG(IM(Str_Str_Int_RetVoid, s s i, v)) | 
|---|
| 502 | DEFINE_METASIG(IM(Str_Str_Str_Int_RetVoid, s s s i, v)) | 
|---|
| 503 | DEFINE_METASIG_T(IM(Str_BindingFlags_RetFieldInfo, s g(BINDING_FLAGS), C(FIELD_INFO))) | 
|---|
| 504 | DEFINE_METASIG_T(IM(Str_BindingFlags_RetMemberInfo, s g(BINDING_FLAGS), a(C(MEMBER)))) | 
|---|
| 505 | DEFINE_METASIG_T(IM(Str_BindingFlags_RetMethodInfo, s g(BINDING_FLAGS), C(METHOD_INFO))) | 
|---|
| 506 | DEFINE_METASIG_T(IM(Str_BindingFlags_RetPropertyInfo, s g(BINDING_FLAGS), C(PROPERTY_INFO))) | 
|---|
| 507 | DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Obj_ArrObj_ArrParameterModifier_CultureInfo_ArrStr_RetObj, \ | 
|---|
| 508 | s g(BINDING_FLAGS) C(BINDER) j a(j) a(g(PARAMETER_MODIFIER)) C(CULTURE_INFO) a(s), j)) | 
|---|
| 509 | DEFINE_METASIG_T(IM(Str_Delegate_RetMethodInfo, s C(DELEGATE), C(METHOD_INFO))) | 
|---|
| 510 | DEFINE_METASIG_T(IM(Str_Type_Str_RetVoid, s C(TYPE) s, v)) | 
|---|
| 511 | DEFINE_METASIG_T(SM(Delegate_RetIntPtr, C(DELEGATE), I)) | 
|---|
| 512 | DEFINE_METASIG_T(SM(Delegate_RefIntPtr_RetIntPtr, C(DELEGATE) r(I), I)) | 
|---|
| 513 | DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetType, g(RT_TYPE_HANDLE), C(TYPE))) | 
|---|
| 514 | DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetIntPtr, g(RT_TYPE_HANDLE), I)) | 
|---|
| 515 | DEFINE_METASIG_T(SM(RuntimeMethodHandle_RetIntPtr, g(METHOD_HANDLE), I)) | 
|---|
| 516 | DEFINE_METASIG_T(SM(IntPtr_Type_RetDelegate, I C(TYPE), C(DELEGATE))) | 
|---|
| 517 |  | 
|---|
| 518 |  | 
|---|
| 519 | DEFINE_METASIG_T(IM(Type_RetArrObj, C(TYPE) F, a(j))) | 
|---|
| 520 | DEFINE_METASIG(IM(Bool_RetVoid, F, v)) | 
|---|
| 521 | DEFINE_METASIG_T(IM(BindingFlags_RetArrFieldInfo, g(BINDING_FLAGS), a(C(FIELD_INFO)))) | 
|---|
| 522 | DEFINE_METASIG_T(IM(BindingFlags_RetArrMemberInfo, g(BINDING_FLAGS), a(C(MEMBER)))) | 
|---|
| 523 | DEFINE_METASIG_T(IM(BindingFlags_RetArrMethodInfo, g(BINDING_FLAGS), a(C(METHOD_INFO)))) | 
|---|
| 524 | DEFINE_METASIG_T(IM(BindingFlags_RetArrPropertyInfo, g(BINDING_FLAGS), a(C(PROPERTY_INFO)))) | 
|---|
| 525 | DEFINE_METASIG(IM(ArrByte_RetVoid, a(b), v)) | 
|---|
| 526 | DEFINE_METASIG(IM(ArrChar_RetVoid, a(u), v)) | 
|---|
| 527 | DEFINE_METASIG(IM(ArrChar_Int_Int_RetVoid, a(u) i i, v)) | 
|---|
| 528 | DEFINE_METASIG_T(IM(ArrType_ArrException_Str_RetVoid, a(C(TYPE)) a(C(EXCEPTION)) s, v)) | 
|---|
| 529 | DEFINE_METASIG(IM(RefInt_RefInt_RefInt_RetArrByte, r(i) r(i) r(i), a(b))) | 
|---|
| 530 | DEFINE_METASIG_T(IM(RefInt_RetRuntimeType, r(i) , C(CLASS))) | 
|---|
| 531 | DEFINE_METASIG_T(IM(RuntimeType_RetVoid, C(CLASS) , v)) | 
|---|
| 532 | DEFINE_METASIG_T(SM(ArrException_PtrInt_RetVoid, a(C(EXCEPTION)) P(i), v)) | 
|---|
| 533 |  | 
|---|
| 534 | DEFINE_METASIG_T(IM(RuntimeArgumentHandle_PtrVoid_RetVoid, g(ARGUMENT_HANDLE) P(v), v)) | 
|---|
| 535 | DEFINE_METASIG_T(IM(LicenseInteropHelper_GetCurrentContextInfo, r(i) r(I) g(RT_TYPE_HANDLE), v)) | 
|---|
| 536 | DEFINE_METASIG(IM(LicenseInteropHelper_SaveKeyInCurrentContext, I, v)) | 
|---|
| 537 | DEFINE_METASIG_T(SM(LicenseInteropHelper_AllocateAndValidateLicense, g(RT_TYPE_HANDLE) I i, j)) | 
|---|
| 538 | DEFINE_METASIG_T(SM(LicenseInteropHelper_RequestLicKey, g(RT_TYPE_HANDLE) r(I), i)) | 
|---|
| 539 | DEFINE_METASIG_T(IM(LicenseInteropHelper_GetLicInfo, g(RT_TYPE_HANDLE) r(i) r(i), v)) | 
|---|
| 540 |  | 
|---|
| 541 | DEFINE_METASIG_T(SM(Assembly_RetVoid, C(ASSEMBLY), v)) | 
|---|
| 542 | DEFINE_METASIG_T(SM(Assembly_Str_RetArrAssembly, C(ASSEMBLY) s, a(C(ASSEMBLY)))) | 
|---|
| 543 | DEFINE_METASIG(SM(Str_RetArrStr, s, a(s))) | 
|---|
| 544 |  | 
|---|
| 545 | // Execution Context | 
|---|
| 546 | DEFINE_METASIG_T(SM(SyncCtx_ArrIntPtr_Bool_Int_RetInt, C(SYNCHRONIZATION_CONTEXT) a(I) F i, i)) | 
|---|
| 547 |  | 
|---|
| 548 | #ifdef FEATURE_COMINTEROP | 
|---|
| 549 | // The signature of the method System.Runtime.InteropServices.ICustomQueryInterface.GetInterface | 
|---|
| 550 | DEFINE_METASIG_T(IM(RefGuid_OutIntPtr_RetCustomQueryInterfaceResult, r(g(GUID)) r(I), g(CUSTOMQUERYINTERFACERESULT))) | 
|---|
| 551 | #endif //FEATURE_COMINTEROP | 
|---|
| 552 |  | 
|---|
| 553 | DEFINE_METASIG_T(SM(IntPtr_AssemblyName_RetAssemblyBase, I C(ASSEMBLY_NAME), C(ASSEMBLYBASE))) | 
|---|
| 554 |  | 
|---|
| 555 | // ThreadPool | 
|---|
| 556 | DEFINE_METASIG(SM(Obj_Bool_RetVoid, j F, v)) | 
|---|
| 557 |  | 
|---|
| 558 | // For FailFast | 
|---|
| 559 | DEFINE_METASIG(SM(Str_RetVoid, s, v)) | 
|---|
| 560 | DEFINE_METASIG(SM(Str_Uint_RetVoid, s K, v)) | 
|---|
| 561 | DEFINE_METASIG_T(SM(Str_Exception_RetVoid, s C(EXCEPTION), v)) | 
|---|
| 562 | DEFINE_METASIG_T(SM(Str_Exception_Str_RetVoid, s C(EXCEPTION) s, v)) | 
|---|
| 563 |  | 
|---|
| 564 | // fields - e.g.: | 
|---|
| 565 | // DEFINE_METASIG(Fld(PtrVoid, P(v))) | 
|---|
| 566 |  | 
|---|
| 567 | // Runtime Helpers | 
|---|
| 568 | DEFINE_METASIG(SM(Obj_Obj_Bool_RetVoid, j j F, v)) | 
|---|
| 569 |  | 
|---|
| 570 | DEFINE_METASIG_T(IM(Dec_RetVoid, g(DECIMAL), v)) | 
|---|
| 571 | DEFINE_METASIG_T(IM(Currency_RetVoid, g(CURRENCY), v)) | 
|---|
| 572 | DEFINE_METASIG_T(SM(RefDec_RetVoid, r(g(DECIMAL)), v)) | 
|---|
| 573 |  | 
|---|
| 574 | DEFINE_METASIG(GM(RefT_T_T_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0) M(0), M(0))) | 
|---|
| 575 | DEFINE_METASIG(SM(RefObject_Object_Object_RetObject, r(j) j j, j)) | 
|---|
| 576 |  | 
|---|
| 577 | DEFINE_METASIG_T(SM(RefCleanupWorkListElement_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)), v)) | 
|---|
| 578 | DEFINE_METASIG_T(SM(RefCleanupWorkListElement_SafeHandle_RetIntPtr, r(C(CLEANUP_WORK_LIST_ELEMENT)) C(SAFE_HANDLE), I)) | 
|---|
| 579 | DEFINE_METASIG_T(SM(RefCleanupWorkListElement_Delegate_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)) C(DELEGATE), v)) | 
|---|
| 580 |  | 
|---|
| 581 | #ifdef FEATURE_ICASTABLE | 
|---|
| 582 | DEFINE_METASIG_T(SM(ICastable_RtType_RefException_RetBool, C(ICASTABLE) C(CLASS) r(C(EXCEPTION)), F)) | 
|---|
| 583 | DEFINE_METASIG_T(SM(ICastable_RtType_RetRtType, C(ICASTABLE) C(CLASS), C(CLASS))) | 
|---|
| 584 | #endif // FEATURE_ICASTABLE | 
|---|
| 585 |  | 
|---|
| 586 | DEFINE_METASIG_T(IM(ArrByte_Int_Int_AsyncCallback_Object_RetIAsyncResult, a(b) i i C(ASYNCCALLBACK) j, C(IASYNCRESULT))) | 
|---|
| 587 | DEFINE_METASIG_T(IM(IAsyncResult_RetInt, C(IASYNCRESULT), i)) | 
|---|
| 588 | DEFINE_METASIG_T(IM(IAsyncResult_RetVoid, C(IASYNCRESULT), v)) | 
|---|
| 589 |  | 
|---|
| 590 | DEFINE_METASIG(IM(Int_RetRefT, i, r(G(0)))) | 
|---|
| 591 | DEFINE_METASIG_T(IM(Int_RetReadOnlyRefT, i, Q(INATTRIBUTE) r(G(0)))) | 
|---|
| 592 |  | 
|---|
| 593 | // Undefine macros in case we include the file again in the compilation unit | 
|---|
| 594 |  | 
|---|
| 595 | #undef  DEFINE_METASIG | 
|---|
| 596 | #undef  DEFINE_METASIG_T | 
|---|
| 597 |  | 
|---|
| 598 | #undef METASIG_BODY | 
|---|
| 599 | #undef METASIG_ATOM | 
|---|
| 600 | #undef METASIG_RECURSE | 
|---|
| 601 |  | 
|---|
| 602 |  | 
|---|
| 603 | #undef SM | 
|---|
| 604 | #undef IM | 
|---|
| 605 | #undef GM | 
|---|
| 606 | #undef Fld | 
|---|
| 607 |  | 
|---|
| 608 | #undef a | 
|---|
| 609 | #undef P | 
|---|
| 610 | #undef r | 
|---|
| 611 | #undef b | 
|---|
| 612 | #undef u | 
|---|
| 613 | #undef d | 
|---|
| 614 | #undef f | 
|---|
| 615 | #undef i | 
|---|
| 616 | #undef K | 
|---|
| 617 | #undef I | 
|---|
| 618 | #undef U | 
|---|
| 619 | #undef l | 
|---|
| 620 | #undef L | 
|---|
| 621 | #undef h | 
|---|
| 622 | #undef H | 
|---|
| 623 | #undef v | 
|---|
| 624 | #undef B | 
|---|
| 625 | #undef F | 
|---|
| 626 | #undef j | 
|---|
| 627 | #undef s | 
|---|
| 628 | #undef C | 
|---|
| 629 | #undef g | 
|---|
| 630 | #undef T | 
|---|
| 631 | #undef G | 
|---|
| 632 | #undef M | 
|---|
| 633 | #undef GI | 
|---|
| 634 | #undef Q | 
|---|
| 635 |  | 
|---|
| 636 | #undef _ | 
|---|
| 637 |  | 
|---|
| 638 |  | 
|---|
| 639 | #endif // DEFINE_METASIG | 
|---|
| 640 |  | 
|---|