# add the executable
add_library (MarshalBoolArrayNative SHARED ${SOURCES})
-target_link_libraries(MarshalBoolArrayNative ${LINK_LIBRARIES_ADDITIONAL})
+target_link_libraries(MarshalBoolArrayNative ${LINK_LIBRARIES_ADDITIONAL})
# add the install targets
install (TARGETS MarshalBoolArrayNative DESTINATION bin)
//Reverse PInvoke
//Pass by value
-typedef BOOL (CALLBACK *CallBackIn)(int size,bool arr[]);
+typedef BOOL (STDMETHODCALLTYPE *CallBackIn)(int size,bool arr[]);
extern "C" DLL_EXPORT BOOL DoCallBackIn(CallBackIn callback)
{
//Init
- bool * arr = (bool*)CoTaskMemAlloc(ArraySIZE);
+ bool * arr = (bool*)CoreClrAlloc(ArraySIZE);
for(int i = 0;i < ArraySIZE; i++ )
{
if( 0 == i%2)
if((0 == (i%2)) && !arr[i]) //expect true
{
printf("Native Side:Error in DoCallBackIn.The Item is %d\n",i+1);
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return false;
}
else if((1 == (i%2))&&arr[i]) //expect false
{
printf("Native Side:Error in DoCallBackIn.The Item is %d\n",i+1);
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return false;
}
}
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return true;
}
-typedef BOOL (CALLBACK *CallBackOut)(int size,bool arr[]);
+typedef BOOL (STDMETHODCALLTYPE *CallBackOut)(int size,bool arr[]);
extern "C" DLL_EXPORT BOOL DoCallBackOut(CallBackOut callback)
{
- bool * arr =(bool *)CoTaskMemAlloc(ArraySIZE);
+ bool * arr =(bool *)CoreClrAlloc(ArraySIZE);
if(!callback(ArraySIZE,arr))
{
if(!arr[i]) //expect true
{
printf("Native Side:Error in DoCallBackOut.The Item is %d\n",i+1);
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return false;
}
}
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return true;
}
-typedef BOOL (CALLBACK *CallBackInOut)(int size,bool arr[]);
+typedef BOOL (STDMETHODCALLTYPE *CallBackInOut)(int size,bool arr[]);
extern "C" DLL_EXPORT BOOL DoCallBackInOut(CallBackInOut callback)
{
//Init
- bool * arr =(bool *)CoTaskMemAlloc(ArraySIZE);
+ bool * arr =(bool *)CoreClrAlloc(ArraySIZE);
for(int i = 0;i < ArraySIZE; i++ )
{
if( 0 == i%2)
if(!arr[i]) //expect true
{
printf("Native Side:Error in DoCallBackInOut.The Item is %d\n",i+1);
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return false;
}
}
- CoTaskMemFree(arr);
+ CoreClrFree(arr);
return true;
}
//Reverse PInvoke
//Pass by reference
-typedef BOOL (CALLBACK *CallBackRefIn)(int size,bool ** arr);
+typedef BOOL (STDMETHODCALLTYPE *CallBackRefIn)(int size,bool ** arr);
extern "C" DLL_EXPORT BOOL DoCallBackRefIn(CallBackRefIn callback)
{
//Init:true,false,true,false,true
- bool *parr = (bool *)CoTaskMemAlloc(ArraySIZE);
+ bool *parr = (bool *)CoreClrAlloc(ArraySIZE);
for(int i = 0;i < ArraySIZE;++i)
{
if((0==(i%2)) && !parr[i]) //expect true
{
printf("Native Side:Error in DoCallBackInOut.The Item is %d\n",i+1);
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return false;
}
else if((1==(i%2))&&parr[i]) //expect false
{
printf("Native Side:Error in DoCallBackInOut.The Item is %d\n",i+1);
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return false;
}
}
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return true;
}
-typedef BOOL (CALLBACK *CallBackRefOut)(int size,bool ** arr);
+typedef BOOL (STDMETHODCALLTYPE *CallBackRefOut)(int size,bool ** arr);
extern "C" DLL_EXPORT BOOL DoCallBackRefOut(CallBackRefOut callback)
{
if(!(*(parr + i))) //expect true
{
printf("Native Side:Error in DoCallBackRefOut.The Item is %d\n",i+1);
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return false;
}
}
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return true;
}
-typedef BOOL (CALLBACK *CallBackRefInOut)(int size,bool ** arr);
+typedef BOOL (STDMETHODCALLTYPE *CallBackRefInOut)(int size,bool ** arr);
extern "C" DLL_EXPORT BOOL DoCallBackRefInOut(CallBackRefInOut callback)
{
//Init,true,false,true,false
- bool* parr = (bool*)CoTaskMemAlloc(ArraySIZE);
+ bool* parr = (bool*)CoreClrAlloc(ArraySIZE);
for(int i = 0;i<ArraySIZE;++i)
{
if( 0 == i%2)
if(!(parr[i])) //expect true
{
printf("Native Side:Error in DoCallBackRefOut.The Item is %d\n",i+1);
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return false;
}
}
- CoTaskMemFree(parr);
+ CoreClrFree(parr);
return true;
}
expected[i] = (__type)i
#define INIT_EXPECTED_STRUCT(__type, __size, __array_type) \
- __type *expected = (__type *)::CoTaskMemAlloc( sizeof(__type) ); \
+ __type *expected = (__type *)CoreClrAlloc( sizeof(__type) ); \
for ( size_t i = 0; i < (__size); ++i) \
expected->arr[i] = (__array_type)i
LPSTR ToString(int i)
{
- CHAR *pBuffer = (CHAR *)::CoTaskMemAlloc(10 * sizeof(CHAR)); // 10 is enough for our case, WCHAR for BSTR
+ CHAR *pBuffer = (CHAR *)CoreClrAlloc(10 * sizeof(CHAR)); // 10 is enough for our case, WCHAR for BSTR
snprintf(pBuffer, 10, "%d", i);
return pBuffer;
}
TestStruct* InitTestStruct()
{
- TestStruct *expected = (TestStruct *)CoTaskMemAlloc( sizeof(TestStruct) * ARRAY_SIZE );
+ TestStruct *expected = (TestStruct *)CoreClrAlloc( sizeof(TestStruct) * ARRAY_SIZE );
for ( int i = 0; i < ARRAY_SIZE; i++)
{
/*----------------------------------------------------------------------------
marshal sequential strut
----------------------------------------------------------------------------*/
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeIntArraySeqStructByVal( S_INTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeIntArraySeqStructByVal( S_INTArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( INT, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeUIntArraySeqStructByVal( S_UINTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeUIntArraySeqStructByVal( S_UINTArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( UINT, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeShortArraySeqStructByVal( S_SHORTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeShortArraySeqStructByVal( S_SHORTArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( SHORT, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeWordArraySeqStructByVal( S_WORDArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeWordArraySeqStructByVal( S_WORDArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( WORD, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLong64ArraySeqStructByVal( S_LONG64Array s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLong64ArraySeqStructByVal( S_LONG64Array s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( LONG64, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeULong64ArraySeqStructByVal( S_ULONG64Array s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeULong64ArraySeqStructByVal( S_ULONG64Array s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( ULONG64, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeDoubleArraySeqStructByVal( S_DOUBLEArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeDoubleArraySeqStructByVal( S_DOUBLEArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( DOUBLE, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeFloatArraySeqStructByVal( S_FLOATArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeFloatArraySeqStructByVal( S_FLOATArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( FLOAT, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeByteArraySeqStructByVal( S_BYTEArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeByteArraySeqStructByVal( S_BYTEArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( BYTE, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeCharArraySeqStructByVal( S_CHARArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeCharArraySeqStructByVal( S_CHARArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
INIT_EXPECTED( CHAR, ARRAY_SIZE );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeIntPtrArraySeqStructByVal(S_DWORD_PTRArray s, int size)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeIntPtrArraySeqStructByVal(S_DWORD_PTRArray s, int size)
{
CHECK_PARAM_NOT_EMPTY(s.arr);
INIT_EXPECTED( DWORD_PTR, ARRAY_SIZE);
return Equals(s.arr, size, expected, ARRAY_SIZE);
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPSTRArraySeqStructByVal( S_LPSTRArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPSTRArraySeqStructByVal( S_LPSTRArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
return Equals( s.arr, size, expected, ARRAY_SIZE );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPCSTRArraySeqStructByVal( S_LPCSTRArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPCSTRArraySeqStructByVal( S_LPCSTRArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeStructArraySeqStructByVal( S_StructArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeStructArraySeqStructByVal( S_StructArray s, int size )
{
CHECK_PARAM_NOT_EMPTY( s.arr );
/*----------------------------------------------------------------------------
marshal sequential class
----------------------------------------------------------------------------*/
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeIntArraySeqClassByVal( S_INTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeIntArraySeqClassByVal( S_INTArray *s, int size )
{
return TakeIntArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeUIntArraySeqClassByVal( S_UINTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeUIntArraySeqClassByVal( S_UINTArray *s, int size )
{
return TakeUIntArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeShortArraySeqClassByVal( S_SHORTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeShortArraySeqClassByVal( S_SHORTArray *s, int size )
{
return TakeShortArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeWordArraySeqClassByVal( S_WORDArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeWordArraySeqClassByVal( S_WORDArray *s, int size )
{
return TakeWordArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLong64ArraySeqClassByVal( S_LONG64Array *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLong64ArraySeqClassByVal( S_LONG64Array *s, int size )
{
return TakeLong64ArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeULong64ArraySeqClassByVal( S_ULONG64Array *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeULong64ArraySeqClassByVal( S_ULONG64Array *s, int size )
{
return TakeULong64ArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeDoubleArraySeqClassByVal( S_DOUBLEArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeDoubleArraySeqClassByVal( S_DOUBLEArray *s, int size )
{
return TakeDoubleArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeFloatArraySeqClassByVal( S_FLOATArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeFloatArraySeqClassByVal( S_FLOATArray *s, int size )
{
return TakeFloatArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeByteArraySeqClassByVal( S_BYTEArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeByteArraySeqClassByVal( S_BYTEArray *s, int size )
{
return TakeByteArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeCharArraySeqClassByVal( S_CHARArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeCharArraySeqClassByVal( S_CHARArray *s, int size )
{
return TakeCharArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPSTRArraySeqClassByVal( S_LPSTRArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPSTRArraySeqClassByVal( S_LPSTRArray *s, int size )
{
return TakeLPSTRArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPCSTRArraySeqClassByVal( S_LPCSTRArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPCSTRArraySeqClassByVal( S_LPCSTRArray *s, int size )
{
return TakeLPCSTRArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeStructArraySeqClassByVal( S_StructArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeStructArraySeqClassByVal( S_StructArray *s, int size )
{
return TakeStructArraySeqStructByVal( *s, size );
}
/*----------------------------------------------------------------------------
marshal explicit struct
----------------------------------------------------------------------------*/
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeIntArrayExpStructByVal( S_INTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeIntArrayExpStructByVal( S_INTArray s, int size )
{
return TakeIntArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeUIntArrayExpStructByVal( S_UINTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeUIntArrayExpStructByVal( S_UINTArray s, int size )
{
return TakeUIntArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeShortArrayExpStructByVal( S_SHORTArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeShortArrayExpStructByVal( S_SHORTArray s, int size )
{
return TakeShortArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeWordArrayExpStructByVal( S_WORDArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeWordArrayExpStructByVal( S_WORDArray s, int size )
{
return TakeWordArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLong64ArrayExpStructByVal( S_LONG64Array s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLong64ArrayExpStructByVal( S_LONG64Array s, int size )
{
return TakeLong64ArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeULong64ArrayExpStructByVal( S_ULONG64Array s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeULong64ArrayExpStructByVal( S_ULONG64Array s, int size )
{
return TakeULong64ArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeDoubleArrayExpStructByVal( S_DOUBLEArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeDoubleArrayExpStructByVal( S_DOUBLEArray s, int size )
{
return TakeDoubleArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeFloatArrayExpStructByVal( S_FLOATArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeFloatArrayExpStructByVal( S_FLOATArray s, int size )
{
return TakeFloatArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeByteArrayExpStructByVal( S_BYTEArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeByteArrayExpStructByVal( S_BYTEArray s, int size )
{
return TakeByteArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeCharArrayExpStructByVal( S_CHARArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeCharArrayExpStructByVal( S_CHARArray s, int size )
{
return TakeCharArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPSTRArrayExpStructByVal( S_LPSTRArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPSTRArrayExpStructByVal( S_LPSTRArray s, int size )
{
return TakeLPSTRArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPCSTRArrayExpStructByVal( S_LPCSTRArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPCSTRArrayExpStructByVal( S_LPCSTRArray s, int size )
{
return TakeLPCSTRArraySeqStructByVal( s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeStructArrayExpStructByVal( S_StructArray s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeStructArrayExpStructByVal( S_StructArray s, int size )
{
return TakeStructArraySeqStructByVal( s, size );
}
/*----------------------------------------------------------------------------
marshal explicit class
----------------------------------------------------------------------------*/
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeIntArrayExpClassByVal( S_INTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeIntArrayExpClassByVal( S_INTArray *s, int size )
{
return TakeIntArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeUIntArrayExpClassByVal( S_UINTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeUIntArrayExpClassByVal( S_UINTArray *s, int size )
{
return TakeUIntArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeShortArrayExpClassByVal( S_SHORTArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeShortArrayExpClassByVal( S_SHORTArray *s, int size )
{
return TakeShortArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeWordArrayExpClassByVal( S_WORDArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeWordArrayExpClassByVal( S_WORDArray *s, int size )
{
return TakeWordArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLong64ArrayExpClassByVal( S_LONG64Array *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLong64ArrayExpClassByVal( S_LONG64Array *s, int size )
{
return TakeLong64ArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeULong64ArrayExpClassByVal( S_ULONG64Array *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeULong64ArrayExpClassByVal( S_ULONG64Array *s, int size )
{
return TakeULong64ArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeDoubleArrayExpClassByVal( S_DOUBLEArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeDoubleArrayExpClassByVal( S_DOUBLEArray *s, int size )
{
return TakeDoubleArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeFloatArrayExpClassByVal( S_FLOATArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeFloatArrayExpClassByVal( S_FLOATArray *s, int size )
{
return TakeFloatArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeByteArrayExpClassByVal( S_BYTEArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeByteArrayExpClassByVal( S_BYTEArray *s, int size )
{
return TakeByteArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeCharArrayExpClassByVal( S_CHARArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeCharArrayExpClassByVal( S_CHARArray *s, int size )
{
return TakeCharArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPSTRArrayExpClassByVal( S_LPSTRArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPSTRArrayExpClassByVal( S_LPSTRArray *s, int size )
{
return TakeLPSTRArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeLPCSTRArrayExpClassByVal( S_LPCSTRArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeLPCSTRArrayExpClassByVal( S_LPCSTRArray *s, int size )
{
return TakeLPCSTRArraySeqStructByVal( *s, size );
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI TakeStructArrayExpClassByVal( S_StructArray *s, int size )
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE TakeStructArrayExpClassByVal( S_StructArray *s, int size )
{
return TakeStructArraySeqStructByVal( *s, size );
}
/*----------------------------------------------------------------------------
return a struct including a C array
----------------------------------------------------------------------------*/
-extern "C" DLL_EXPORT S_INTArray* NATIVEAPI S_INTArray_Ret()
+extern "C" DLL_EXPORT S_INTArray* STDMETHODCALLTYPE S_INTArray_Ret()
{
INIT_EXPECTED_STRUCT( S_INTArray, ARRAY_SIZE, INT );
return expected;
}
-extern "C" DLL_EXPORT S_UINTArray* NATIVEAPI S_UINTArray_Ret()
+extern "C" DLL_EXPORT S_UINTArray* STDMETHODCALLTYPE S_UINTArray_Ret()
{
INIT_EXPECTED_STRUCT( S_UINTArray, ARRAY_SIZE, UINT );
return expected;
}
-extern "C" DLL_EXPORT S_SHORTArray* NATIVEAPI S_SHORTArray_Ret()
+extern "C" DLL_EXPORT S_SHORTArray* STDMETHODCALLTYPE S_SHORTArray_Ret()
{
INIT_EXPECTED_STRUCT( S_SHORTArray, ARRAY_SIZE, SHORT );
return expected;
}
-extern "C" DLL_EXPORT S_WORDArray* NATIVEAPI S_WORDArray_Ret()
+extern "C" DLL_EXPORT S_WORDArray* STDMETHODCALLTYPE S_WORDArray_Ret()
{
INIT_EXPECTED_STRUCT( S_WORDArray, ARRAY_SIZE, WORD );
return expected;
}
-extern "C" DLL_EXPORT S_LONG64Array* NATIVEAPI S_LONG64Array_Ret()
+extern "C" DLL_EXPORT S_LONG64Array* STDMETHODCALLTYPE S_LONG64Array_Ret()
{
INIT_EXPECTED_STRUCT( S_LONG64Array, ARRAY_SIZE, LONG64 );
return expected;
}
-extern "C" DLL_EXPORT S_ULONG64Array* NATIVEAPI S_ULONG64Array_Ret()
+extern "C" DLL_EXPORT S_ULONG64Array* STDMETHODCALLTYPE S_ULONG64Array_Ret()
{
INIT_EXPECTED_STRUCT( S_ULONG64Array, ARRAY_SIZE, ULONG64 );
return expected;
}
-extern "C" DLL_EXPORT S_DOUBLEArray* NATIVEAPI S_DOUBLEArray_Ret()
+extern "C" DLL_EXPORT S_DOUBLEArray* STDMETHODCALLTYPE S_DOUBLEArray_Ret()
{
INIT_EXPECTED_STRUCT( S_DOUBLEArray, ARRAY_SIZE, DOUBLE );
return expected;
}
-extern "C" DLL_EXPORT S_FLOATArray* NATIVEAPI S_FLOATArray_Ret()
+extern "C" DLL_EXPORT S_FLOATArray* STDMETHODCALLTYPE S_FLOATArray_Ret()
{
INIT_EXPECTED_STRUCT( S_FLOATArray, ARRAY_SIZE, FLOAT );
return expected;
}
-extern "C" DLL_EXPORT S_BYTEArray* NATIVEAPI S_BYTEArray_Ret()
+extern "C" DLL_EXPORT S_BYTEArray* STDMETHODCALLTYPE S_BYTEArray_Ret()
{
INIT_EXPECTED_STRUCT( S_BYTEArray, ARRAY_SIZE, BYTE );
return expected;
}
-extern "C" DLL_EXPORT S_CHARArray* NATIVEAPI S_CHARArray_Ret()
+extern "C" DLL_EXPORT S_CHARArray* STDMETHODCALLTYPE S_CHARArray_Ret()
{
INIT_EXPECTED_STRUCT( S_CHARArray, ARRAY_SIZE, CHAR );
return expected;
}
-extern "C" DLL_EXPORT S_LPSTRArray* NATIVEAPI S_LPSTRArray_Ret()
+extern "C" DLL_EXPORT S_LPSTRArray* STDMETHODCALLTYPE S_LPSTRArray_Ret()
{
- S_LPSTRArray *expected = (S_LPSTRArray *)::CoTaskMemAlloc( sizeof(S_LPSTRArray) );
+ S_LPSTRArray *expected = (S_LPSTRArray *)CoreClrAlloc( sizeof(S_LPSTRArray) );
for ( int i = 0; i < ARRAY_SIZE; ++i )
expected->arr[i] = ToString(i);
}
-extern "C" DLL_EXPORT S_StructArray* NATIVEAPI S_StructArray_Ret()
+extern "C" DLL_EXPORT S_StructArray* STDMETHODCALLTYPE S_StructArray_Ret()
{
- S_StructArray *expected = (S_StructArray *)::CoTaskMemAlloc( sizeof(S_StructArray) );
+ S_StructArray *expected = (S_StructArray *)CoreClrAlloc( sizeof(S_StructArray) );
for ( int i = 0; i < ARRAY_SIZE; ++i )
{
expected->arr[i].x = i;
return (++fails);
}
-extern "C" DLL_EXPORT int _cdecl GetResult()
+extern "C" DLL_EXPORT int __cdecl GetResult()
{
return fails;
}
//This method is used on Windows Only
-extern "C" DLL_EXPORT char _cdecl GetByteForWideChar()
+extern "C" DLL_EXPORT char __cdecl GetByteForWideChar()
{
#ifdef WINDOWS
char * p = new char[3];
p[2] = (char)0xbc;
p[3] = (char)0;
#endif
- if (0 != _tcsncmp(str, p, 4))
+ if (0 != strncmp(str, p, 4))
{
printf("CheckInput:Expected:%s,Actual:%d\n", p, str[0]);
delete[]p;
}
//C Call,In attribute,LPstr
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_In(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_In(LPSTR pStr)
{
//Check the Input
if (!CheckInput(pStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(pStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(pBack, pStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_Out(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_Out(LPSTR pStr)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(pBack, pTemp, strlen(pTemp) + 1);
strncpy(pStr, pTemp, strlen(pTemp) + 1);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_InOut(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_InOut(LPSTR pStr)
{
//Check the Input
if (!CheckInput(pStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(pStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, pStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_InByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_InByRef(LPSTR* ppStr)
{
//Check the Input
if (!CheckInput(*ppStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(*ppStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, *ppStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_OutByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_OutByRef(LPSTR* ppStr)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(pBack, pTemp, strlen(pTemp) + 1);
- *ppStr = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ *ppStr = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(*ppStr, pTemp, strlen(pTemp) + 1);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR _cdecl CLPStr_InOutByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR __cdecl CLPStr_InOutByRef(LPSTR* ppStr)
{
//Check the Input
if (!CheckInput(*ppStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(*ppStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, *ppStr, len);
return pBack;
}
-typedef LPSTR (_cdecl* delegate_cdecl)(LPSTR* ppstr);
-extern "C" DLL_EXPORT delegate_cdecl _cdecl CLPStr_DelegatePInvoke()
+typedef LPSTR (__cdecl* delegate_cdecl)(LPSTR* ppstr);
+extern "C" DLL_EXPORT delegate_cdecl __cdecl CLPStr_DelegatePInvoke()
{
return CLPStr_InOutByRef;
}
//stdcall
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_In(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_In(LPSTR pStr)
{
//Check the Input
if (!CheckInput(pStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(pStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, pStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_Out(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_Out(LPSTR pStr)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(pBack, pTemp, strlen(pTemp) + 1);
strncpy(pStr, pTemp, strlen(pTemp) + 1);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_InOut(LPSTR pStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_InOut(LPSTR pStr)
{
//Check the Input
if (!CheckInput(pStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(pStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, pStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_InByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_InByRef(LPSTR* ppStr)
{
//Check the Input
if (!CheckInput(*ppStr))
}
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(*ppStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, *ppStr, len);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_OutByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_OutByRef(LPSTR* ppStr)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(pBack, pTemp, strlen(pTemp) + 1);
- *ppStr = (LPSTR)CoTaskMemAlloc(sizeof(char) * len);
+ *ppStr = (LPSTR)CoreClrAlloc(sizeof(char) * len);
strncpy(*ppStr, pTemp, strlen(pTemp) + 1);
return pBack;
}
-extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_InOutByRef(LPSTR* ppStr)
+extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_InOutByRef(LPSTR* ppStr)
{
//Check the Input
if (!CheckInput(*ppStr))
//alloc,copy, since we cannot depend the Marshaler's activity.
size_t len = strlen(*ppStr) + 1; //+1, Include the NULL Character.
- LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pBack = (LPSTR)CoreClrAlloc(len);
strncpy(pBack, *ppStr, len);
return pBack;
}
-typedef LPSTR (__stdcall *delegate_stdcall)(LPSTR* ppstr);
+typedef LPSTR (STDMETHODCALLTYPE *delegate_stdcall)(LPSTR* ppstr);
extern "C" DLL_EXPORT delegate_stdcall SLPStr_DelegatePInvoke()
{
return SLPStr_InOutByRef;
///Cdecl, Reverse PInvoke
-typedef LPSTR (_cdecl *CCallBackIn)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_In(CCallBackIn callback)
+typedef LPSTR (__cdecl *CCallBackIn)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_In(CCallBackIn callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp)+1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr,pTemp,len);
if(!CheckInput(callback(pStr)))
{
ReportFailure("DoCCallBack_LPSTR_In:NativeSide");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (_cdecl *CCallBackOut)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_Out(CCallBackOut callback)
+typedef LPSTR (__cdecl *CCallBackOut)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_Out(CCallBackOut callback)
{
size_t len = 10;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
//Check the return value
if (!CheckInput(callback(pStr)))
{
ReportFailure("DoCCallBack_LPSTR_Out:NativeSide,the Second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (_cdecl *CCallBackInOut)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_InOut(CCallBackInOut callback)
+typedef LPSTR (__cdecl *CCallBackInOut)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_InOut(CCallBackInOut callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(pStr)))
{
ReportFailure("DoCCallBack_LPSTR_InOut:NativeSide,the Second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (_cdecl *CallBackInByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_InByRef(CallBackInByRef callback)
+typedef LPSTR (__cdecl *CallBackInByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_InByRef(CallBackInByRef callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(&pStr)))
{
ReportFailure("DoCCallBack_LPSTR_InByRef:NativeSide");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (_cdecl *CCallBackOutByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_OutByRef(CCallBackOutByRef callback)
+typedef LPSTR (__cdecl *CCallBackOutByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_OutByRef(CCallBackOutByRef callback)
{
size_t len = 10;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
if (!CheckInput(callback(&pStr)))
{
{
ReportFailure("DoCCallBack_LPSTR_OutByRef:NativeSide,the Second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (_cdecl *CCallBackInOutByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoCCallBack_LPSTR_InOutByRef(CCallBackInOutByRef callback)
+typedef LPSTR (__cdecl *CCallBackInOutByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_InOutByRef(CCallBackInOutByRef callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(&pStr)))
{
ReportFailure("DoCCallBack_LPSTR_InOutByRef:NativeSide,the Second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
///STDCALL Reverse PInvoke
-typedef LPSTR (__stdcall *SCallBackIn)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_In(SCallBackIn callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackIn)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_In(SCallBackIn callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(pStr)))
{
ReportFailure("DoSCallBack_LPSTR_In:NativeSide");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (__stdcall *SCallBackOut)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_Out(SCallBackOut callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackOut)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_Out(SCallBackOut callback)
{
size_t len = 10;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
if (!CheckInput(callback(pStr)))
{
{
ReportFailure("DoSCallBack_LPSTR_Out:NativeSide,the Second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (__stdcall *SCallBackInOut)(LPSTR pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_InOut(SCallBackInOut callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackInOut)(LPSTR pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_InOut(SCallBackInOut callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(pStr)))
{
ReportFailure("DoSCallBack_LPSTR_InOut:NativeSide,the second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (__stdcall *SCallBackInByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_InByRef(SCallBackInByRef callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackInByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_InByRef(SCallBackInByRef callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(&pStr)))
{
ReportFailure("DoSCallBack_LPSTR_InByRef:NativeSide");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (__stdcall *SCallBackOutByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_OutByRef(SCallBackOutByRef callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackOutByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_OutByRef(SCallBackOutByRef callback)
{
size_t len = 10;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
if (!CheckInput(callback(&pStr)))
{
{
ReportFailure("DoSCallBack_LPSTR_OutByRef:NativeSide,the second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
-typedef LPSTR (__stdcall *SCallBackInOutByRef)(LPSTR* pstr);
-extern "C" DLL_EXPORT void _cdecl DoSCallBack_LPSTR_InOutByRef(SCallBackInOutByRef callback)
+typedef LPSTR (STDMETHODCALLTYPE *SCallBackInOutByRef)(LPSTR* pstr);
+extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_InOutByRef(SCallBackInOutByRef callback)
{
const char* pTemp = "AAAA";
size_t len = strlen(pTemp) + 1;
- LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);
+ LPSTR pStr = (LPSTR)CoreClrAlloc(len);
strncpy(pStr, pTemp, len);
if (!CheckInput(callback(&pStr)))
{
ReportFailure("DoSCallBack_LPSTR_InOutByRef:NativeSide,the second Check");
}
- CoTaskMemFree(pStr);
+ CoreClrFree(pStr);
}
#pragma warning( pop )
\ No newline at end of file
{
return HRESULT{ hresultToReturn };
}
- long __stdcall Return_As_HResult(
+ long STDMETHODCALLTYPE Return_As_HResult(
/*[in]*/ long hresultToReturn)
{
return hresultToReturn;
// Raw methods provided by interface
//
- virtual HRESULT __stdcall raw_Add_Byte (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Byte (
/*[in]*/ unsigned char a,
/*[in]*/ unsigned char b,
/*[out,retval]*/ unsigned char * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Short (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Short (
/*[in]*/ short a,
/*[in]*/ short b,
/*[out,retval]*/ short * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_UShort (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UShort (
/*[in]*/ unsigned short a,
/*[in]*/ unsigned short b,
/*[out,retval]*/ unsigned short * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Int (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Int (
/*[in]*/ long a,
/*[in]*/ long b,
/*[out,retval]*/ long * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_UInt (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UInt (
/*[in]*/ unsigned long a,
/*[in]*/ unsigned long b,
/*[out,retval]*/ unsigned long * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Long (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Long (
/*[in]*/ __int64 a,
/*[in]*/ __int64 b,
/*[out,retval]*/ __int64 * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_ULong (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_ULong (
/*[in]*/ unsigned __int64 a,
/*[in]*/ unsigned __int64 b,
/*[out,retval]*/ unsigned __int64 * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Float (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Float (
/*[in]*/ float a,
/*[in]*/ float b,
/*[out,retval]*/ float * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Double (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Double (
/*[in]*/ double a,
/*[in]*/ double b,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_Byte_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Byte_Ref (
/*[in]*/ unsigned char a,
/*[in]*/ unsigned char b,
/*[in,out]*/ unsigned char * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Short_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Short_Ref (
/*[in]*/ short a,
/*[in]*/ short b,
/*[in,out]*/ short * c ) = 0;
- virtual HRESULT __stdcall raw_Add_UShort_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UShort_Ref (
/*[in]*/ unsigned short a,
/*[in]*/ unsigned short b,
/*[in,out]*/ unsigned short * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Int_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Int_Ref (
/*[in]*/ long a,
/*[in]*/ long b,
/*[in,out]*/ long * c ) = 0;
- virtual HRESULT __stdcall raw_Add_UInt_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UInt_Ref (
/*[in]*/ unsigned long a,
/*[in]*/ unsigned long b,
/*[in,out]*/ unsigned long * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Long_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Long_Ref (
/*[in]*/ __int64 a,
/*[in]*/ __int64 b,
/*[in,out]*/ __int64 * c ) = 0;
- virtual HRESULT __stdcall raw_Add_ULong_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_ULong_Ref (
/*[in]*/ unsigned __int64 a,
/*[in]*/ unsigned __int64 b,
/*[in,out]*/ unsigned __int64 * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Float_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Float_Ref (
/*[in]*/ float a,
/*[in]*/ float b,
/*[in,out]*/ float * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Double_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Double_Ref (
/*[in]*/ double a,
/*[in]*/ double b,
/*[in,out]*/ double * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Byte_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Byte_Out (
/*[in]*/ unsigned char a,
/*[in]*/ unsigned char b,
/*[out]*/ unsigned char * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Short_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Short_Out (
/*[in]*/ short a,
/*[in]*/ short b,
/*[out]*/ short * c ) = 0;
- virtual HRESULT __stdcall raw_Add_UShort_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UShort_Out (
/*[in]*/ unsigned short a,
/*[in]*/ unsigned short b,
/*[out]*/ unsigned short * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Int_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Int_Out (
/*[in]*/ long a,
/*[in]*/ long b,
/*[out]*/ long * c ) = 0;
- virtual HRESULT __stdcall raw_Add_UInt_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_UInt_Out (
/*[in]*/ unsigned long a,
/*[in]*/ unsigned long b,
/*[out]*/ unsigned long * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Long_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Long_Out (
/*[in]*/ __int64 a,
/*[in]*/ __int64 b,
/*[out]*/ __int64 * c ) = 0;
- virtual HRESULT __stdcall raw_Add_ULong_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_ULong_Out (
/*[in]*/ unsigned __int64 a,
/*[in]*/ unsigned __int64 b,
/*[out]*/ unsigned __int64 * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Float_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Float_Out (
/*[in]*/ float a,
/*[in]*/ float b,
/*[out]*/ float * c ) = 0;
- virtual HRESULT __stdcall raw_Add_Double_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_Double_Out (
/*[in]*/ double a,
/*[in]*/ double b,
/*[out]*/ double * c ) = 0;
// Raw methods provided by interface
//
- virtual HRESULT __stdcall raw_Mean_Byte_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Byte_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ unsigned char * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Short_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Short_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ short * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UShort_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UShort_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ unsigned short * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Int_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Int_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ long * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UInt_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UInt_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ unsigned long * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Long_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Long_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ __int64 * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_ULong_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_ULong_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ unsigned __int64 * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Float_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Float_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ float * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Double_LP_PreLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Double_LP_PreLen (
/*[in]*/ long len,
/*[in]*/ double * d,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Byte_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Byte_LP_PostLen (
/*[in]*/ unsigned char * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Short_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Short_LP_PostLen (
/*[in]*/ short * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UShort_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UShort_LP_PostLen (
/*[in]*/ unsigned short * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Int_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Int_LP_PostLen (
/*[in]*/ long * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UInt_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UInt_LP_PostLen (
/*[in]*/ unsigned long * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Long_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Long_LP_PostLen (
/*[in]*/ __int64 * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_ULong_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_ULong_LP_PostLen (
/*[in]*/ unsigned __int64 * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Float_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Float_LP_PostLen (
/*[in]*/ float * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Double_LP_PostLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Double_LP_PostLen (
/*[in]*/ double * d,
/*[in]*/ long len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Byte_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Byte_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Short_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Short_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UShort_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UShort_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Int_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Int_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_UInt_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_UInt_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Long_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Long_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_ULong_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_ULong_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Float_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Float_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Mean_Double_SafeArray_OutLen (
+ virtual HRESULT STDMETHODCALLTYPE raw_Mean_Double_SafeArray_OutLen (
/*[in]*/ SAFEARRAY * d,
/*[out]*/ long * len,
/*[out,retval]*/ double * pRetVal ) = 0;
// Raw methods provided by interface
//
- virtual HRESULT __stdcall raw_Add_LPStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_LPStr (
/*[in]*/ LPSTR a,
/*[in]*/ LPSTR b,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_LPWStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_LPWStr (
/*[in]*/ LPWSTR a,
/*[in]*/ LPWSTR b,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Add_BStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Add_BStr (
/*[in]*/ BSTR a,
/*[in]*/ BSTR b,
/*[out,retval]*/ BSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPStr (
/*[in]*/ LPSTR a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPStr_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPStr_Ref (
/*[in,out]*/ LPSTR * a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPStr_InRef (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPStr_InRef (
/*[in]*/ LPSTR * a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPStr_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPStr_Out (
/*[in]*/ LPSTR a,
/*[out]*/ LPSTR * b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPStr_OutAttr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPStr_OutAttr (
/*[in]*/ LPSTR a,
/*[out]*/ LPSTR b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPStr (
/*[in,out]*/ LPSTR a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPStr_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPStr_Ref (
/*[in,out]*/ LPSTR * a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPStr_InRef (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPStr_InRef (
/*[in]*/ LPSTR * a,
/*[out,retval]*/ LPSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPStr_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPStr_Out (
/*[in,out]*/ LPSTR a,
/*[out]*/ LPSTR * b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPStr_OutAttr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPStr_OutAttr (
/*[in,out]*/ LPSTR a,
/*[out]*/ LPSTR b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPWStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPWStr (
/*[in]*/ LPWSTR a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPWStr_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPWStr_Ref (
/*[in,out]*/ LPWSTR * a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPWStr_InRef (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPWStr_InRef (
/*[in]*/ LPWSTR * a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPWStr_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPWStr_Out (
/*[in]*/ LPWSTR a,
/*[out]*/ LPWSTR * b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_LPWStr_OutAttr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_LPWStr_OutAttr (
/*[in]*/ LPWSTR a,
/*[out]*/ LPWSTR b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPWStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPWStr (
/*[in,out]*/ LPWSTR a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPWStr_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPWStr_Ref (
/*[in,out]*/ LPWSTR * a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPWStr_InRef (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPWStr_InRef (
/*[in]*/ LPWSTR * a,
/*[out,retval]*/ LPWSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPWStr_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPWStr_Out (
/*[in,out]*/ LPWSTR a,
/*[out]*/ LPWSTR * b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_SB_LPWStr_OutAttr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_SB_LPWStr_OutAttr (
/*[in,out]*/ LPWSTR a,
/*[out]*/ LPWSTR b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_BStr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_BStr (
/*[in]*/ BSTR a,
/*[out,retval]*/ BSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_BStr_Ref (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_BStr_Ref (
/*[in,out]*/ BSTR * a,
/*[out,retval]*/ BSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_BStr_InRef (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_BStr_InRef (
/*[in]*/ BSTR * a,
/*[out,retval]*/ BSTR * pRetVal ) = 0;
- virtual HRESULT __stdcall raw_Reverse_BStr_Out (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_BStr_Out (
/*[in]*/ BSTR a,
/*[out]*/ BSTR * b ) = 0;
- virtual HRESULT __stdcall raw_Reverse_BStr_OutAttr (
+ virtual HRESULT STDMETHODCALLTYPE raw_Reverse_BStr_OutAttr (
/*[in]*/ BSTR a,
/*[out]*/ BSTR b ) = 0;
};
// Raw methods provided by interface
//
- virtual HRESULT __stdcall raw_Throw_HResult (
+ virtual HRESULT STDMETHODCALLTYPE raw_Throw_HResult (
/*[in]*/ long hresultToReturn ) = 0;
- virtual long __stdcall Return_As_HResult (
+ virtual long STDMETHODCALLTYPE Return_As_HResult (
/*[in]*/ long hresultToReturn ) = 0;
};
#pragma warning( push )
#pragma warning( disable : 4996)
-extern "C" DLL_EXPORT int _cdecl Sum(int a, int b)
+extern "C" DLL_EXPORT int __cdecl Sum(int a, int b)
{
return a + b;
}
-extern "C" int _cdecl main(int argc, char **argv)
+extern "C" int __cdecl main(int argc, char **argv)
{
return 0;
}
#pragma warning( push )
#pragma warning( disable : 4996)
-extern "C" DLL_EXPORT int _cdecl Sum(int a, int b)
+extern "C" DLL_EXPORT int __cdecl Sum(int a, int b)
{
return a + b;
}
\ No newline at end of file
#pragma warning( push )
#pragma warning( disable : 4996)
-extern "C" DLL_EXPORT int _cdecl Sum(int a, int b)
+extern "C" DLL_EXPORT int __cdecl Sum(int a, int b)
{
return a + b;
}
\ No newline at end of file
//Cdecl -1 678
-int _cdecl CdeTest()
+int __cdecl CdeTest()
{
return -1;
}
-typedef int (_cdecl *pFunc)();
-typedef int (_cdecl *Cdeclcaller)(pFunc);
-extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_Cdecl(Cdeclcaller caller)
+typedef int (__cdecl *pFunc)();
+typedef int (__cdecl *Cdeclcaller)(pFunc);
+extern "C" DLL_EXPORT BOOL __cdecl DoCallBack_Cdecl(Cdeclcaller caller)
{
printf("DoCallBack_Cdecl\n");
# add the executable
add_library (FunctionPointerNative SHARED ${SOURCES})
+target_link_libraries(FunctionPointerNative ${LINK_LIBRARIES_ADDITIONAL})
# add the install targets
install (TARGETS FunctionPointerNative DESTINATION bin)
#include <stdio.h>
#include <xplatform.h>
-extern "C" DLL_EXPORT bool __cdecl CheckFcnPtr(bool(CALLBACK *fcnptr)(__int64))
+extern "C" DLL_EXPORT bool __cdecl CheckFcnPtr(bool(STDMETHODCALLTYPE *fcnptr)(__int64))
{
if (fcnptr == 0)
{
# add the executable
add_library (IUnknownNative SHARED ${SOURCES})
+target_link_libraries(IUnknownNative ${LINK_LIBRARIES_ADDITIONAL})
# add the install targets
install (TARGETS IUnknownNative DESTINATION bin)
#include <stdio.h>
#include <xplatform.h>
-extern "C" DLL_EXPORT BOOL _cdecl Marshal_IUnknown(/*[in]*/IUnknown *o)
+extern "C" DLL_EXPORT BOOL __cdecl Marshal_IUnknown(/*[in]*/IUnknown *o)
{
//Call AddRef and Release on the passed IUnknown
//test if the ref counts get updated as expected
#include <xplatform.h>
-typedef int (NATIVEAPI *CALLBACKPROC)(int n);
+typedef int (STDMETHODCALLTYPE *CALLBACKPROC)(int n);
-extern "C" DLL_EXPORT int NATIVEAPI CallManagedProc(CALLBACKPROC pCallbackProc, int n)
+extern "C" DLL_EXPORT int STDMETHODCALLTYPE CallManagedProc(CALLBACKPROC pCallbackProc, int n)
{
return pCallbackProc(n);
}
BOOL boolManaged = true;
BOOL boolNative = false;
-extern "C" DLL_EXPORT BOOL __stdcall Marshal_In(/*[in]*/BOOL boolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Marshal_In(/*[in]*/BOOL boolValue)
{
//Check the input
if(boolValue != boolManaged)
return true;
}
-extern "C" DLL_EXPORT BOOL __stdcall Marshal_InOut(/*[In,Out]*/BOOL boolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Marshal_InOut(/*[In,Out]*/BOOL boolValue)
{
//Check the input
if(boolValue != boolManaged)
return true;
}
-extern "C" DLL_EXPORT BOOL __stdcall Marshal_Out(/*[Out]*/BOOL boolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Marshal_Out(/*[Out]*/BOOL boolValue)
{
//In-Place Change
boolValue = boolNative;
return true;
}
-extern "C" DLL_EXPORT BOOL __stdcall MarshalPointer_In(/*[in]*/BOOL *pboolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalPointer_In(/*[in]*/BOOL *pboolValue)
{
//Check the input
if(*pboolValue != boolManaged)
return true;
}
-extern "C" DLL_EXPORT BOOL __stdcall MarshalPointer_InOut(/*[in,out]*/BOOL *pboolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalPointer_InOut(/*[in,out]*/BOOL *pboolValue)
{
//Check the input
if(*pboolValue != boolManaged)
return true;
}
-extern "C" DLL_EXPORT BOOL __stdcall MarshalPointer_Out(/*[out]*/ BOOL *pboolValue)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalPointer_Out(/*[out]*/ BOOL *pboolValue)
{
//In-Place Change
*pboolValue = boolNative;
#pragma warning(disable: 4800)
#endif
-extern "C" DLL_EXPORT bool __stdcall Marshal_As_In(/*[in]*/bool boolValue)
+extern "C" DLL_EXPORT bool STDMETHODCALLTYPE Marshal_As_In(/*[in]*/bool boolValue)
{
//Check the input
if(boolValue != (bool)boolManaged)
return true;
}
-extern "C" DLL_EXPORT bool __stdcall Marshal_As_InOut(/*[In,Out]*/bool boolValue)
+extern "C" DLL_EXPORT bool STDMETHODCALLTYPE Marshal_As_InOut(/*[In,Out]*/bool boolValue)
{
//Check the input
if(boolValue != (bool)boolManaged)
return true;
}
-extern "C" DLL_EXPORT bool __stdcall Marshal_As_Out(/*[Out]*/bool boolValue)
+extern "C" DLL_EXPORT bool STDMETHODCALLTYPE Marshal_As_Out(/*[Out]*/bool boolValue)
{
//In-Place Change
boolValue = (bool)boolNative;
typedef void *voidPtr;
-extern "C" DLL_EXPORT long _cdecl CdeclEnum(int r,BOOL *result)
+extern "C" DLL_EXPORT long __cdecl CdeclEnum(int r,BOOL *result)
{
if(r != 3)
{
}
-extern "C" DLL_EXPORT voidPtr _cdecl GetFptr(int i)
+extern "C" DLL_EXPORT voidPtr __cdecl GetFptr(int i)
{
return (voidPtr) &CdeclEnum;
}
//
// PInvokeUIntPtrTest.cs declares that all of these APIs use STDCALL.
//
-extern "C" DLL_EXPORT UINT_PTR __stdcall Marshal_In(/*[in]*/UINT_PTR uintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE Marshal_In(/*[in]*/UINT_PTR uintPtr)
{
//Check the input
if(uintPtr != uintPtrManaged)
return uintPtrReturn;
}
-extern "C" DLL_EXPORT UINT_PTR __stdcall Marshal_InOut(/*[In,Out]*/UINT_PTR uintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE Marshal_InOut(/*[In,Out]*/UINT_PTR uintPtr)
{
//Check the input
if(uintPtr != uintPtrManaged)
return uintPtrReturn;
}
-extern "C" DLL_EXPORT UINT_PTR __stdcall Marshal_Out(/*[Out]*/UINT_PTR uintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE Marshal_Out(/*[Out]*/UINT_PTR uintPtr)
{
uintPtr = uintPtrNative;
return uintPtrReturn;
}
-extern "C" DLL_EXPORT UINT_PTR __stdcall MarshalPointer_In(/*[in]*/UINT_PTR *puintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE MarshalPointer_In(/*[in]*/UINT_PTR *puintPtr)
{
//Check the input
if(*puintPtr != uintPtrManaged)
return uintPtrReturn;
}
-extern "C" DLL_EXPORT UINT_PTR __stdcall MarshalPointer_InOut(/*[in,out]*/UINT_PTR *puintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE MarshalPointer_InOut(/*[in,out]*/UINT_PTR *puintPtr)
{
//Check the input
if(*puintPtr != uintPtrManaged)
return uintPtrReturn;
}
-extern "C" DLL_EXPORT UINT_PTR __stdcall MarshalPointer_Out(/*[out]*/ UINT_PTR *puintPtr)
+extern "C" DLL_EXPORT UINT_PTR STDMETHODCALLTYPE MarshalPointer_Out(/*[out]*/ UINT_PTR *puintPtr)
{
*puintPtr = uintPtrNative;
#include <stdlib.h>
const int LEN = 10;
-extern "C" BOOL DLL_EXPORT _cdecl MarshalRefCharArray_Cdecl(char ** pstr)
+extern "C" BOOL DLL_EXPORT __cdecl MarshalRefCharArray_Cdecl(char ** pstr)
{
//Check the Input
for(int i = 0; i < LEN; i++)
return TRUE;
}
-typedef BOOL(_cdecl *CdeclCallBack)(char ** pstr);
-extern "C" BOOL DLL_EXPORT _cdecl DoCallBack_MarshalRefCharArray_Cdecl(CdeclCallBack caller)
+typedef BOOL(__cdecl *CdeclCallBack)(char ** pstr);
+extern "C" BOOL DLL_EXPORT __cdecl DoCallBack_MarshalRefCharArray_Cdecl(CdeclCallBack caller)
{
- char * str = (char*)CoTaskMemAlloc(LEN);
+ char * str = (char*)CoreClrAlloc(LEN);
for(int i = 0;i<LEN;i++)
{
str[i] = 'z';
}
if(str[0]!='a')
{
- CoTaskMemFree(str);
+ CoreClrFree(str);
return FALSE;
}
return TRUE;
typedef BOOL(__stdcall *StdCallBack)(char ** pstr);
extern "C" BOOL DLL_EXPORT __stdcall DoCallBack_MarshalRefCharArray_Stdcall(StdCallBack caller)
{
- char * str = (char*)CoTaskMemAlloc(LEN);
+ char * str = (char*)CoreClrAlloc(LEN);
for(int i = 0;i<LEN;i++)
{
str[i] = 'z';
if(str[0]!='a')
{
- CoTaskMemFree(str);
+ CoreClrFree(str);
return FALSE;
}
return TRUE;
}
-typedef BOOL (_cdecl * DelegatePInvoke_Cdecl)(char **pstr);
-extern "C" DLL_EXPORT DelegatePInvoke_Cdecl _cdecl DelegatePinvoke_Cdecl()
+typedef BOOL (__cdecl * DelegatePInvoke_Cdecl)(char **pstr);
+extern "C" DLL_EXPORT DelegatePInvoke_Cdecl __cdecl DelegatePinvoke_Cdecl()
{
return MarshalRefCharArray_Cdecl;
}
set(SOURCES RefIntNative.cpp )
# add the executable
-add_library (RefIntNative SHARED ${SOURCES})
-
-#get_cmake_property(_variableNames VARIABLES)
-#foreach (_variableName ${_variableNames})
-# message(STATUS "${_variableName}=${${_variableName}}")
-#endforeach()
-
-
-#SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
+add_library(RefIntNative SHARED ${SOURCES})
+target_link_libraries(RefIntNative ${LINK_LIBRARIES_ADDITIONAL})
# add the install targets
install (TARGETS RefIntNative DESTINATION bin)
\ No newline at end of file
const int iNative = 11;
-extern "C" BOOL DLL_EXPORT _cdecl MarshalRefInt_Cdcel(int * pint)
+extern "C" BOOL DLL_EXPORT __cdecl MarshalRefInt_Cdcel(int * pint)
{
//Check the Input
if(iManaged != *pint)
return TRUE;
}
-typedef BOOL (_cdecl *Cdeclcaller)(int* pint);
-extern "C" BOOL DLL_EXPORT _cdecl DoCallBack_MarshalRefInt_Cdecl(Cdeclcaller caller)
+typedef BOOL (__cdecl *Cdeclcaller)(int* pint);
+extern "C" BOOL DLL_EXPORT __cdecl DoCallBack_MarshalRefInt_Cdecl(Cdeclcaller caller)
{
//Check the Input
int itemp = iNative;
return TRUE;
}
-typedef BOOL (_cdecl * DelegatePInvokeCdecl)(int * pint);
-extern "C" DLL_EXPORT DelegatePInvokeCdecl _cdecl MarshalRefInt_DelegatePInvoke_Cdecl()
+typedef BOOL (__cdecl * DelegatePInvokeCdecl)(int * pint);
+extern "C" DLL_EXPORT DelegatePInvokeCdecl __cdecl MarshalRefInt_DelegatePInvoke_Cdecl()
{
return MarshalRefInt_Cdcel;
}
}ExplStruct;
extern "C"
-DLL_EXPORT BOOL _cdecl CdeclSimpleStructByRef(Sstr *p)
+DLL_EXPORT BOOL __cdecl CdeclSimpleStructByRef(Sstr *p)
{
p->a = 100;
p->b=1;
}
extern "C"
-DLL_EXPORT BOOL _cdecl CdeclSimpleExplStructByRef(ExplStruct *p)
+DLL_EXPORT BOOL __cdecl CdeclSimpleExplStructByRef(ExplStruct *p)
{
if((p->a != 0) || (p->udata.i != 10))
{
}
extern "C"
-DLL_EXPORT Sstr_simple* _cdecl CdeclSimpleStruct(Sstr_simple p,BOOL *result)
+DLL_EXPORT Sstr_simple* __cdecl CdeclSimpleStruct(Sstr_simple p,BOOL *result)
{
Sstr_simple *pSimpleStruct;
if((p.a !=100) || (p.b != FALSE) || (p.c != 3.142))
*(result)= FALSE;
return NULL;
}
- pSimpleStruct = (Sstr_simple*) TP_CoTaskMemAlloc(sizeof(Sstr_simple) * 1);
+ pSimpleStruct = (Sstr_simple*) CoreClrAlloc(sizeof(Sstr_simple) * 1);
pSimpleStruct->a = 101;
pSimpleStruct->b = TRUE;
pSimpleStruct->c = 10.11;
}
extern "C"
-DLL_EXPORT ExplStruct* _cdecl CdeclSimpleExplStruct(ExplStruct p,BOOL *result)
+DLL_EXPORT ExplStruct* __cdecl CdeclSimpleExplStruct(ExplStruct p,BOOL *result)
{
ExplStruct *pExplStruct;
if((p.a !=1) || (p.udata.b != FALSE))
*(result)= FALSE;
return NULL;
}
- pExplStruct = (ExplStruct*) TP_CoTaskMemAlloc(sizeof(ExplStruct) * 1);
+ pExplStruct = (ExplStruct*) CoreClrAlloc(sizeof(ExplStruct) * 1);
pExplStruct->a = 2;
pExplStruct->udata.d = 3.142;
*(result)= TRUE;
}
extern "C"
-DLL_EXPORT voidPtr NATIVEAPI GetFptr(int i)
+DLL_EXPORT voidPtr STDMETHODCALLTYPE GetFptr(int i)
{
switch(i)
{
# add the executable
add_library (SizeConstNative SHARED ${SOURCES})
+target_link_libraries(SizeConstNative ${LINK_LIBRARIES_ADDITIONAL})
# add the install targets
install (TARGETS SizeConstNative DESTINATION bin)
const int ARRAY_SIZE = 100;
typedef struct { char arr[ARRAY_SIZE]; } S_CHARByValArray;
-extern "C" DLL_EXPORT BOOL _cdecl TakeByValTStr(S_CHARByValArray s, int size)
+extern "C" DLL_EXPORT BOOL __cdecl TakeByValTStr(S_CHARByValArray s, int size)
{
return true;
}
extern "C" LPSTR ReturnString()
{
size_t strLength = strlen(strReturn);
- LPSTR ret = (LPSTR)(CoTaskMemAlloc(sizeof(char)* (strLength +1)));
+ LPSTR ret = (LPSTR)(CoreClrAlloc(sizeof(char)* (strLength +1)));
memset(ret,'\0',strLength+1);
strncpy_s(ret,strLength + 1, strReturn, strLength);
return ret;
extern "C" LPSTR ReturnErrorString()
{
size_t strLength = strlen(strerrReturn);
- LPSTR ret = (LPSTR)(CoTaskMemAlloc(sizeof(char)*(strLength + 1)));
+ LPSTR ret = (LPSTR)(CoreClrAlloc(sizeof(char)*(strLength + 1)));
memset(ret,'\0',strLength + 1);
strncpy_s(ret,strLength + 1,strerrReturn,strLength);
return ret;
extern "C" DLL_EXPORT LPSTR Marshal_Out(/*[Out]*/LPSTR s)
{
- s = (LPSTR)(CoTaskMemAlloc(sizeof(char)*(lenstrNative+1)));
+ s = (LPSTR)(CoreClrAlloc(sizeof(char)*(lenstrNative+1)));
memset(s,0,lenstrNative+1);
//In-Place Change
}
//Allocate New
- CoTaskMemFree(*s);
- *s = (LPSTR)CoTaskMemAlloc(sizeof(char)*(lenstrNative+1));
+ CoreClrFree(*s);
+ *s = (LPSTR)CoreClrAlloc(sizeof(char)*(lenstrNative+1));
memset(*s,0,lenstrNative+1);
strncpy_s(*s,len + 1,strNative,lenstrNative);
extern "C" DLL_EXPORT LPSTR MarshalPointer_Out(/*[out]*/ LPSTR *s)
{
- *s = (LPSTR)CoTaskMemAlloc(sizeof(char)*(lenstrNative+1));
+ *s = (LPSTR)CoreClrAlloc(sizeof(char)*(lenstrNative+1));
memset(*s,0,lenstrNative+1);
strncpy_s(*s,lenstrNative+1,strNative,lenstrNative);
return FALSE;
}
- CoTaskMemFree((LPVOID)str);
+ CoreClrFree((LPVOID)str);
return TRUE;
}
extern "C" LPWSTR ReturnString()
{
size_t length = wcslen(strReturn)+1;
- LPWSTR ret = (LPWSTR)CoTaskMemAlloc(sizeof(WCHAR)*length);
+ LPWSTR ret = (LPWSTR)CoreClrAlloc(sizeof(WCHAR)*length);
memset(ret,'\0', sizeof(WCHAR)*length);
wcsncpy_s(ret,length,strReturn,length-1);
return ret;
extern "C" LPWSTR ReturnErrString()
{
size_t length = wcslen(strErrReturn)+1;
- LPWSTR ret = (LPWSTR)CoTaskMemAlloc(sizeof(WCHAR)*length);
+ LPWSTR ret = (LPWSTR)CoreClrAlloc(sizeof(WCHAR)*length);
memset(ret,'\0', sizeof(WCHAR)*length);
wcsncpy_s(ret,length,strErrReturn,length-1);
return ret;
extern "C" DLL_EXPORT LPWSTR Marshal_Out(/*[Out]*/LPWSTR s)
{
- s = (LPWSTR)CoTaskMemAlloc(sizeof(WCHAR)*(lenstrNative+1));;
+ s = (LPWSTR)CoreClrAlloc(sizeof(WCHAR)*(lenstrNative+1));;
memset(s,0, sizeof(WCHAR)*(lenstrNative + 1));
//In-Place Change
}
//Allocate New
- CoTaskMemFree(*s);
+ CoreClrFree(*s);
//Alloc New
size_t length = lenstrNative + 1;
- *s = (LPWSTR)CoTaskMemAlloc(length * sizeof(WCHAR));
+ *s = (LPWSTR)CoreClrAlloc(length * sizeof(WCHAR));
memset(*s,'\0',length * sizeof(WCHAR));
wcsncpy_s(*s,length,strNative,lenstrNative);
extern "C" DLL_EXPORT LPWSTR MarshalPointer_Out(/*[out]*/ LPWSTR *s)
{
size_t length = lenstrNative+1;
- *s = (LPWSTR)CoTaskMemAlloc(sizeof(WCHAR)*length);
+ *s = (LPWSTR)CoreClrAlloc(sizeof(WCHAR)*length);
memset(*s, '\0', length * sizeof(WCHAR));
wcsncpy_s(*s,length,strNative,lenstrNative);
}
typedef LPWSTR (__stdcall * Test_Del_MarshalStrB_InOut)(/*[in,out]*/ LPWSTR s);
-extern "C" DLL_EXPORT BOOL NATIVEAPI ReverseP_MarshalStrB_InOut(Test_Del_MarshalStrB_InOut d, /*[in]*/ LPCWSTR s)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE ReverseP_MarshalStrB_InOut(Test_Del_MarshalStrB_InOut d, /*[in]*/ LPCWSTR s)
{
LPWSTR ret = d((LPWSTR)s);
LPWSTR expectedret =(LPWSTR)W("Native");
}
typedef LPWSTR (__cdecl * Test_Del_MarshalStrB_Out)(/*[out]*/ LPWSTR * s);
-extern "C" DLL_EXPORT BOOL NATIVEAPI ReverseP_MarshalStrB_Out(Test_Del_MarshalStrB_Out d)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE ReverseP_MarshalStrB_Out(Test_Del_MarshalStrB_Out d)
{
LPWSTR s;
LPWSTR ret = d((LPWSTR*)&s);
NULL,
NULL);
- char *pszUTF8 = (char*)CoTaskMemAlloc(sizeof(char) * (cbUTF8 + 1));
+ char *pszUTF8 = (char*)CoreClrAlloc(sizeof(char) * (cbUTF8 + 1));
int nc = WideCharToMultiByte(CP_UTF8, // convert to UTF-8
0, //default flags
srcstring, //source wide string
0 // request size of destination buffer, in wchar_t's
);
- wszTextUTF16 = (wchar_t*)(CoTaskMemAlloc((cbUTF16 + 1) * sizeof(wchar_t)));
+ wszTextUTF16 = (wchar_t*)(CoreClrAlloc((cbUTF16 + 1) * sizeof(wchar_t)));
// Do the actual conversion from UTF-8 to UTF-16
int nc = ::MultiByteToWideChar(
CP_UTF8, // convert from UTF-8
void free_utf8_string(char *str)
{
- CoTaskMemFree(str);
+ CoreClrFree(str);
}
#else //Not WIndows
return ret;
size_t strLength = strlen(pReturn);
- ret = (LPSTR)(CoTaskMemAlloc(sizeof(char)* (strLength + 1)));
+ ret = (LPSTR)(CoreClrAlloc(sizeof(char)* (strLength + 1)));
memset(ret, '\0', strLength + 1);
strncpy_s(ret, strLength + 1, pReturn, strLength);
return ret;
{
char *pszTextutf8 = get_utf8_string(index);
size_t strLength = strlen(pszTextutf8);
- LPSTR ret = (LPSTR)(CoTaskMemAlloc(sizeof(char)* (strLength + 1)));
+ LPSTR ret = (LPSTR)(CoreClrAlloc(sizeof(char)* (strLength + 1)));
memcpy(ret, pszTextutf8, strLength);
ret[strLength] = '\0';
free_utf8_string(pszTextutf8);
}FieldWithUtf8;
//utf8 struct field
-extern "C" DLL_EXPORT void _cdecl TestStructWithUtf8Field(struct FieldWithUtf8 fieldStruct)
+extern "C" DLL_EXPORT void __cdecl TestStructWithUtf8Field(struct FieldWithUtf8 fieldStruct)
{
char *pszManagedutf8 = fieldStruct.pFirst;
int stringIndex = fieldStruct.index;
{
char *pszTextutf8 = get_utf8_string(index);
size_t strLength = strlen(pszTextutf8);
- *s = (LPSTR)(CoTaskMemAlloc(sizeof(char)* (strLength + 1)));
+ *s = (LPSTR)(CoreClrAlloc(sizeof(char)* (strLength + 1)));
memcpy(*s, pszTextutf8, strLength);
(*s)[strLength] = '\0';
free_utf8_string(pszTextutf8);
if (*s)
{
- CoTaskMemFree(*s);
+ CoreClrFree(*s);
}
// overwrite the orginal
- *s = (LPSTR)(CoTaskMemAlloc(sizeof(char)* (strLength + 1)));
+ *s = (LPSTR)(CoreClrAlloc(sizeof(char)* (strLength + 1)));
memcpy(*s, pszTextutf8, strLength);
(*s)[strLength] = '\0';
free_utf8_string(pszTextutf8);
// delegate test
typedef void (__cdecl * Callback)(char *text, int index);
-extern "C" DLL_EXPORT void _cdecl Utf8DelegateAsParameter(Callback managedCallback)
+extern "C" DLL_EXPORT void __cdecl Utf8DelegateAsParameter(Callback managedCallback)
{
for (int i = 0; i < NSTRINGS; ++i)
{
///////////////////////////////////////////////////////////////////////////////////
// EXPORTED METHODS
///////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal(InnerSequential inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal(InnerSequential inner)
{
if(!IsCorrectInnerSequential(&inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef(InnerSequential* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef(InnerSequential* inner)
{
if(!IsCorrectInnerSequential(inner))
{
ChangeInnerSequential(inner);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn(InnerSequential* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn(InnerSequential* inner)
{
if(!IsCorrectInnerSequential(inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut(InnerSequential inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut(InnerSequential inner)
{
if(!IsCorrectInnerSequential(&inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut(InnerSequential* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut(InnerSequential* inner)
{
ChangeInnerSequential(inner);
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal2(InnerArraySequential outer)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal2(InnerArraySequential outer)
{
if(!IsCorrectInnerArraySequential(&outer))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef2(InnerArraySequential* outer)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef2(InnerArraySequential* outer)
{
if(!IsCorrectInnerArraySequential(outer))
{
ChangeInnerArraySequential(outer);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn2(InnerArraySequential* outer)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn2(InnerArraySequential* outer)
{
if(!IsCorrectInnerArraySequential(outer))
{
ChangeInnerArraySequential(outer);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut2(InnerArraySequential outer)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut2(InnerArraySequential outer)
{
if(!IsCorrectInnerArraySequential(&outer))
{
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut2(InnerArraySequential* outer)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut2(InnerArraySequential* outer)
{
for(int i = 0;i<NumArrElements;i++)
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal3(CharSetAnsiSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal3(CharSetAnsiSequential str1)
{
if(!IsCorrectCharSetAnsiSequential(&str1))
{
ChangeCharSetAnsiSequential(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef3(CharSetAnsiSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef3(CharSetAnsiSequential* str1)
{
if(!IsCorrectCharSetAnsiSequential(str1))
{
ChangeCharSetAnsiSequential(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn3(CharSetAnsiSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn3(CharSetAnsiSequential* str1)
{
if(!IsCorrectCharSetAnsiSequential(str1))
{
ChangeCharSetAnsiSequential(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut3(CharSetAnsiSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut3(CharSetAnsiSequential str1)
{
if(!IsCorrectCharSetAnsiSequential(&str1))
{
str1.f2 = 'n';
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut3(CharSetAnsiSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut3(CharSetAnsiSequential* str1)
{
- CoTaskMemFree((void*)(str1->f1));
+ CoreClrFree((void*)(str1->f1));
str1->f1 = CoStrDup("change string");
str1->f2 = 'n';
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal4(CharSetUnicodeSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal4(CharSetUnicodeSequential str1)
{
if(!IsCorrectCharSetUnicodeSequential(&str1))
{
ChangeCharSetUnicodeSequential(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef4(CharSetUnicodeSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef4(CharSetUnicodeSequential* str1)
{
if(!IsCorrectCharSetUnicodeSequential(str1))
{
ChangeCharSetUnicodeSequential(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn4(CharSetUnicodeSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn4(CharSetUnicodeSequential* str1)
{
if(!IsCorrectCharSetUnicodeSequential(str1))
{
ChangeCharSetUnicodeSequential(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut4(CharSetUnicodeSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut4(CharSetUnicodeSequential str1)
{
if(!IsCorrectCharSetUnicodeSequential(&str1))
{
str1.f2 = L'n';
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut4(CharSetUnicodeSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut4(CharSetUnicodeSequential* str1)
{
if(str1->f1 != 0 || str1->f2 != 0)
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal6(NumberSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal6(NumberSequential str1)
{
if(!IsCorrectNumberSequential(&str1))
{
ChangeNumberSequential(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef6(NumberSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef6(NumberSequential* str1)
{
if(!IsCorrectNumberSequential(str1))
{
ChangeNumberSequential(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn6(NumberSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn6(NumberSequential* str1)
{
if(!IsCorrectNumberSequential(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut6(NumberSequential str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut6(NumberSequential str1)
{
if(!IsCorrectNumberSequential(&str1))
{
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut6(NumberSequential* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut6(NumberSequential* str1)
{
ChangeNumberSequential(str1);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal7(S3 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal7(S3 str1)
{
if(!IsCorrectS3(&str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef7(S3* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef7(S3* str1)
{
if(!IsCorrectS3(str1))
{
ChangeS3(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn7(S3* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn7(S3* str1)
{
if(!IsCorrectS3(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut7(S3 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut7(S3 str1)
{
if(!IsCorrectS3(&str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut7(S3* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut7(S3* str1)
{
ChangeS3(str1);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal8(S5 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal8(S5 str1)
{
if(!IsCorrectS5(&str1))
{
ChangeS5(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef8(S5* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef8(S5* str1)
{
if(!IsCorrectS5(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn8(S5* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn8(S5* str1)
{
if(!IsCorrectS5(str1))
{
ChangeS5(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut8(S5* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut8(S5* str1)
{
ChangeS5(str1);
return TRUE;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal9(StringStructSequentialAnsi str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal9(StringStructSequentialAnsi str1)
{
if(!IsCorrectStringStructSequentialAnsi(&str1))
{
ChangeStringStructSequentialAnsi(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef9(StringStructSequentialAnsi* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef9(StringStructSequentialAnsi* str1)
{
if(!IsCorrectStringStructSequentialAnsi(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn9(StringStructSequentialAnsi* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn9(StringStructSequentialAnsi* str1)
{
if(!IsCorrectStringStructSequentialAnsi(str1))
{
ChangeStringStructSequentialAnsi(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut9(StringStructSequentialAnsi str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut9(StringStructSequentialAnsi str1)
{
if(!IsCorrectStringStructSequentialAnsi(&str1))
{
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut9(StringStructSequentialAnsi* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut9(StringStructSequentialAnsi* str1)
{
ChangeStringStructSequentialAnsi(str1);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal10(StringStructSequentialUnicode str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal10(StringStructSequentialUnicode str1)
{
if(!IsCorrectStringStructSequentialUnicode(&str1))
{
ChangeStringStructSequentialUnicode(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef10(StringStructSequentialUnicode* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef10(StringStructSequentialUnicode* str1)
{
if(!IsCorrectStringStructSequentialUnicode(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn10(StringStructSequentialUnicode* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn10(StringStructSequentialUnicode* str1)
{
if(!IsCorrectStringStructSequentialUnicode(str1))
{
ChangeStringStructSequentialUnicode(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut10(StringStructSequentialUnicode str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut10(StringStructSequentialUnicode str1)
{
if(!IsCorrectStringStructSequentialUnicode(&str1))
{
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut10(StringStructSequentialUnicode* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut10(StringStructSequentialUnicode* str1)
{
ChangeStringStructSequentialUnicode(str1);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal11(S8 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal11(S8 str1)
{
if(!IsCorrectS8(&str1))
{
ChangeS8(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef11(S8* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef11(S8* str1)
{
if(!IsCorrectS8(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn11(S8* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn11(S8* str1)
{
if(!IsCorrectS8(str1))
{
ChangeS8(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut11(S8 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut11(S8 str1)
{
if(!IsCorrectS8(&str1))
{
str1.ui32 = 256;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut11(S8* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut11(S8* str1)
{
ChangeS8(str1);
{
printf("\tAction of the delegate");
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal12(S9 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal12(S9 str1)
{
if(str1.i32 != 128 ||
str1.myDelegate1 == NULL)
str1.myDelegate1 = NULL;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef12(S9* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef12(S9* str1)
{
if(str1->i32 != 128 ||
str1->myDelegate1 == NULL)
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn12(S9* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn12(S9* str1)
{
if(str1->i32 != 128 ||
str1->myDelegate1 == NULL)
}
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut12(S9 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut12(S9 str1)
{
if(str1.i32 != 128 ||
str1.myDelegate1 == NULL)
str1.myDelegate1 = NULL;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut12(S9* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut12(S9* str1)
{
str1->i32 = 256;
str1->myDelegate1 = NtestMethod;
///////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal13(S10 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal13(S10 str1)
{
if(!IsCorrectS10(&str1))
{
ChangeS10(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef13(S10* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef13(S10* str1)
{
if(!IsCorrectS10(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn13(S10* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn13(S10* str1)
{
if(!IsCorrectS10(str1))
{
ChangeS10(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut13(S10 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut13(S10 str1)
{
if(!IsCorrectS10(&str1))
{
str1.s.i = 64;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut13(S10* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut13(S10* str1)
{
ChangeS10(str1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByVal14(S11 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByVal14(S11 str1)
{
if( str1.i32 != 0 || str1.i != 32 )
return FALSE;
str1.i = 64;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRef14(S11* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRef14(S11* str1)
{
if(str1->i32 != 0 || str1->i != 32)
return FALSE;
return TRUE;
}
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefIn14(S11* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefIn14(S11* str1)
{
if(str1->i32 != 0 || str1->i != 32)
return FALSE;
return TRUE;
}
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByValOut14(S11 str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByValOut14(S11 str1)
{
if( str1.i32 != (LPINT)32 || str1.i != 32 )
return FALSE;
str1.i = 64;
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsSeqByRefOut14(S11* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsSeqByRefOut14(S11* str1)
{
str1->i32 = reinterpret_cast<LPINT>(static_cast<INT_PTR>(str1->i));
str1->i = 64;
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValINNER2(INNER2 inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValINNER2(INNER2 inner)
{
if(!IsCorrectINNER2(&inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefINNER2(INNER2* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefINNER2(INNER2* inner)
{
if(!IsCorrectINNER2(inner))
{
ChangeINNER2(inner);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInINNER2(INNER2* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInINNER2(INNER2* inner)
{
if(!IsCorrectINNER2(inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValOutINNER2(INNER2 inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValOutINNER2(INNER2 inner)
{
if(!IsCorrectINNER2(&inner))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutINNER2(INNER2* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutINNER2(INNER2* inner)
{
//change struct
ChangeINNER2(inner);
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValInnerExplicit(InnerExplicit inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValInnerExplicit(InnerExplicit inner)
{
if((&inner)->f1 != 1 || memcmp((&inner)->f3, "some string",11*sizeof(char)) != 0)
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInnerExplicit(InnerExplicit* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInnerExplicit(InnerExplicit* inner)
{
if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0)
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInInnerExplicit(InnerExplicit* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInInnerExplicit(InnerExplicit* inner)
{
if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0)
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutInnerExplicit(InnerExplicit* inner)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutInnerExplicit(InnerExplicit* inner)
{
if(inner->f1 != 0 || inner->f2 != 0.0)
{
////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValInnerArrayExplicit(InnerArrayExplicit outer2)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValInnerArrayExplicit(InnerArrayExplicit outer2)
{
for(int i = 0;i<NumArrElements;i++)
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInnerArrayExplicit(InnerArrayExplicit* outer2)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInnerArrayExplicit(InnerArrayExplicit* outer2)
{
for(int i = 0;i<NumArrElements;i++)
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInInnerArrayExplicit(InnerArrayExplicit* outer2)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInInnerArrayExplicit(InnerArrayExplicit* outer2)
{
for(int i = 0;i<NumArrElements;i++)
{
outer2->s.f4 = CoStrDup("change string2");
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit(InnerArrayExplicit* outer2)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit(InnerArrayExplicit* outer2)
{
for(int i =0;i<NumArrElements;i++)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValOUTER3(OUTER3 outer3)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValOUTER3(OUTER3 outer3)
{
if(!IsCorrectOUTER3(&outer3))
{
ChangeOUTER3(&outer3);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOUTER3(OUTER3* outer3)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOUTER3(OUTER3* outer3)
{
if(!IsCorrectOUTER3(outer3))
{
ChangeOUTER3(outer3);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInOUTER3(OUTER3* outer3)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInOUTER3(OUTER3* outer3)
{
if(!IsCorrectOUTER3(outer3))
{
ChangeOUTER3(outer3);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutOUTER3(OUTER3* outer3)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutOUTER3(OUTER3* outer3)
{
ChangeOUTER3(outer3);
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValU(U str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValU(U str1)
{
if(!IsCorrectU(&str1))
{
ChangeU(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefU(U* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefU(U* str1)
{
if(!IsCorrectU(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInU(U* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInU(U* str1)
{
if(!IsCorrectU(str1))
{
ChangeU(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutU(U* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutU(U* str1)
{
ChangeU(str1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValByteStructPack2Explicit(ByteStructPack2Explicit str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValByteStructPack2Explicit(ByteStructPack2Explicit str1)
{
if(!IsCorrectByteStructPack2Explicit(&str1))
{
ChangeByteStructPack2Explicit(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefByteStructPack2Explicit(ByteStructPack2Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefByteStructPack2Explicit(ByteStructPack2Explicit* str1)
{
if(!IsCorrectByteStructPack2Explicit(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit(ByteStructPack2Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit(ByteStructPack2Explicit* str1)
{
if(!IsCorrectByteStructPack2Explicit(str1))
{
ChangeByteStructPack2Explicit(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit(ByteStructPack2Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit(ByteStructPack2Explicit* str1)
{
ChangeByteStructPack2Explicit(str1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValShortStructPack4Explicit(ShortStructPack4Explicit str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValShortStructPack4Explicit(ShortStructPack4Explicit str1)
{
if(!IsCorrectShortStructPack4Explicit(&str1))
{
ChangeShortStructPack4Explicit(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefShortStructPack4Explicit(ShortStructPack4Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefShortStructPack4Explicit(ShortStructPack4Explicit* str1)
{
if(!IsCorrectShortStructPack4Explicit(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit(ShortStructPack4Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit(ShortStructPack4Explicit* str1)
{
if(!IsCorrectShortStructPack4Explicit(str1))
{
ChangeShortStructPack4Explicit(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit(ShortStructPack4Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit(ShortStructPack4Explicit* str1)
{
ChangeShortStructPack4Explicit(str1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValIntStructPack8Explicit(IntStructPack8Explicit str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValIntStructPack8Explicit(IntStructPack8Explicit str1)
{
if(!IsCorrectIntStructPack8Explicit(&str1))
{
ChangeIntStructPack8Explicit(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefIntStructPack8Explicit(IntStructPack8Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefIntStructPack8Explicit(IntStructPack8Explicit* str1)
{
if(!IsCorrectIntStructPack8Explicit(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit(IntStructPack8Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit(IntStructPack8Explicit* str1)
{
if(!IsCorrectIntStructPack8Explicit(str1))
{
ChangeIntStructPack8Explicit(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit(IntStructPack8Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit(IntStructPack8Explicit* str1)
{
ChangeIntStructPack8Explicit(str1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByValLongStructPack16Explicit(LongStructPack16Explicit str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByValLongStructPack16Explicit(LongStructPack16Explicit str1)
{
if(!IsCorrectLongStructPack16Explicit(&str1))
{
ChangeLongStructPack16Explicit(&str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefLongStructPack16Explicit(LongStructPack16Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefLongStructPack16Explicit(LongStructPack16Explicit* str1)
{
if(!IsCorrectLongStructPack16Explicit(str1))
{
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit(LongStructPack16Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit(LongStructPack16Explicit* str1)
{
if(!IsCorrectLongStructPack16Explicit(str1))
{
ChangeLongStructPack16Explicit(str1);
return TRUE;
}
-extern "C" DLL_EXPORT BOOL NATIVEAPI MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit(LongStructPack16Explicit* str1)
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit(LongStructPack16Explicit* str1)
{
ChangeLongStructPack16Explicit(str1);
inline char* CoStrDup(const char* str)
{
size_t size = strlen(str) + 1;
- char* dup = (char *)CoTaskMemAlloc(size);
+ char* dup = (char *)CoreClrAlloc(size);
if (dup != nullptr)
{
strcpy_s(dup, size, str);
LPCWSTR strSource = u"change string";
#endif
size_t len = wcslen(strSource);
- LPCWSTR temp = (LPCWSTR)CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
+ LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
if(temp != NULL)
{
wcscpy_s((WCHAR*)temp, (len+1), strSource);
{
p->flag = false;
- /*CoTaskMemFree((void *)p->str);*/
+ /*CoreClrFree((void *)p->str);*/
p->str = CoStrDup("change string");
for(int i = 1;i<257;i++)
void ChangeStringStructSequentialAnsi(StringStructSequentialAnsi* str)
{
- char* newFirst = (char*)CoTaskMemAlloc(sizeof(char)*513);
- char* newLast = (char*)CoTaskMemAlloc(sizeof(char)*513);
+ char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+ char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
for (int i = 0; i < 512; ++i)
{
newFirst[i] = 'b';
void ChangeStringStructSequentialUnicode(StringStructSequentialUnicode* str)
{
- WCHAR* newFirst = (WCHAR*)CoTaskMemAlloc(sizeof(WCHAR)*257);
- WCHAR* newLast = (WCHAR*)CoTaskMemAlloc(sizeof(WCHAR)*257);
+ WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+ WCHAR* newLast = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
for (int i = 0; i < 256; ++i)
{
newFirst[i] = L'b';
// include
#ifdef _WIN32
- #include <windows.h>
- #include <tchar.h>
+ #include <windows.h>
+
+ #ifndef snprintf
+ #define snprintf _snprintf
+ #endif //snprintf
+
#else
- #include "types.h"
+ #include "types.h"
+
#endif
#include <wchar.h>
-
// dllexport
#if defined _WIN32
#define DLL_EXPORT __declspec(dllexport)
-#ifndef snprintf
-#define snprintf _snprintf
-#endif //snprintf
-
#else //!_Win32
-#if __GNUC__ >= 4
+
+#if __GNUC__ >= 4
#define DLL_EXPORT __attribute__ ((visibility ("default")))
#else
#define DLL_EXPORT
#endif //_WIN32
-// The default P/Invoke calling convetion is STDCALL on Window, but CDECL on Unix.
-#ifdef _WIN32
-#define CALLBACK __stdcall
-#define NATIVEAPI __stdcall
-#else // _WIN32
-#define CALLBACK
-#define NATIVEAPI
-#endif // !_WIN32
-
-#ifndef _MSC_VER
+// Calling conventions
+#ifndef _WIN32
+
+#define STDMETHODCALLTYPE
+
#if __i386__
#define __stdcall __attribute__((stdcall))
-#define _cdecl __attribute__((cdecl))
#define __cdecl __attribute__((cdecl))
#else
#define __stdcall
-#define _cdecl
#define __cdecl
#endif
-#endif
-
-
-
-
+#endif //!_WIN32
// Ensure that both UNICODE and _UNICODE are set.
-#ifdef UNICODE
#ifndef _UNICODE
-#define _UNICODE
-#endif
-#else
-#ifdef _UNICODE
-#define UNICODE
+ #define _UNICODE
#endif
+#ifndef UNICODE
+ #define UNICODE
#endif
-
-// redirected functions
-#ifdef UNICODE
-#define _tcslen wcslen
-#define _tcsncmp wcsncmp
+void *CoreClrAlloc(size_t cb)
+{
+#ifdef _WIN32
+ return ::CoTaskMemAlloc(cb);
#else
-#define _tcslen strlen
-#define _tcsncmp strncmp
-#endif // UNICODE
-
+ return ::malloc(cb);
+#endif
+}
+void CoreClrFree(void *p)
+{
+#ifdef _WIN32
+ return ::CoTaskMemFree(p);
+#else
+ return ::free(p);
+#endif
+}
// redirected types not-windows only
#ifndef _WIN32
-typedef union tagCY {
- struct {
- unsigned long Lo;
- long Hi;
- };
- long int64;
-} CY, CURRENCY;
-
-
class IUnknown
{
public:
- virtual int QueryInterface(void* riid,void** ppvObject);
- virtual unsigned long AddRef();
- virtual unsigned long Release();
+ virtual int QueryInterface(void* riid,void** ppvObject) = 0;
+ virtual unsigned long AddRef() = 0;
+ virtual unsigned long Release() = 0;
};
-#define CoTaskMemAlloc(p) malloc(p)
-#define CoTaskMemFree(p) free(p)
-
// function implementation
size_t strncpy_s(char* strDest, size_t numberOfElements, const char *strSource, size_t count)
{
// NOTE: Need to pass count + 1 since strncpy_s does not count null,
// while snprintf does.
- return snprintf(strDest, count + 1, "%s", strSource);
+ return snprintf(strDest, count + 1, "%s", strSource);
}
size_t strcpy_s(char *dest, size_t n, char const *src)
{
- return snprintf(dest, n, "%s", src);
-}
-
-void SysFreeString(char* str)
-{
- free(str);
+ return snprintf(dest, n, "%s", src);
}
-
-char* SysAllocString( const char* str)
-{
- size_t nz = strlen(str);
- char *cArr = (char*) malloc(nz);
- memcpy(cArr, str, nz);
- return cArr;
-}
-
-
size_t wcslen(const WCHAR *str)
{
- int len;
- if (!str) return 0;
- len = 0;
- while ('\0' != *(str + len)) len++;
- return len;
-}
-
-WCHAR* SysAllocString(const WCHAR* str)
-{
- size_t nz = wcslen(str);
- nz *= 2;
- WCHAR *cArr = (WCHAR*)malloc(nz);
- memcpy(cArr, str, nz);
- return cArr;
+ size_t len = 0;
+ while ('\0' != *(str + len)) len++;
+ return len;
}
-
-
int wcsncpy_s(LPWSTR strDestination, size_t size1, LPCWSTR strSource, size_t size2)
{
- int cnt;
- // copy sizeInBytes bytes of strSource into strDestination
- if (NULL == strDestination || NULL == strSource) return 1;
-
- cnt = 0;
- while (cnt < size1 && '\0' != strSource[cnt])
- {
- strDestination[cnt] = strSource[cnt];
- cnt++;
- }
- strDestination[cnt] = '\0';
- return 0;
+ // copy sizeInBytes bytes of strSource into strDestination
+ if (NULL == strDestination || NULL == strSource) return 1;
+
+ int cnt = 0;
+ while (cnt < size1 && '\0' != strSource[cnt])
+ {
+ strDestination[cnt] = strSource[cnt];
+ cnt++;
+ }
+
+ strDestination[cnt] = '\0';
+ return 0;
}
int wcsncpy_s(LPWSTR strDestination, size_t size1, LPCWSTR strSource)
{
- return wcsncpy_s(strDestination, size1, strSource, 0);
-
+ return wcsncpy_s(strDestination, size1, strSource, 0);
}
-#define wcsncmp wmemcmp
+int wcsncmp(LPCWSTR str1, LPCWSTR str2,size_t len)
+{
+ // < 0 str1 less than str2
+ // 0 str1 identical to str2
+ // > 0 str1 greater than str2
+ if (NULL == str1 && NULL != str2) return -1;
+ if (NULL != str1 && NULL == str2) return 1;
+ if (NULL == str1 && NULL == str2) return 0;
+
+ while (*str1 == *str2 && '\0' != *str1 && '\0' != *str2 && len--!= 0)
+ {
+ str1++;
+ str2++;
+ }
+
+ if ('\0' == *str1 && '\0' == *str2) return 0;
+ if ('\0' != *str1) return -1;
+ if ('\0' != *str2) return 1;
+
+ return (*str1 > *str2) ? 1 : -1;
+}
int wmemcmp(LPCWSTR str1, LPCWSTR str2,size_t len)
{
- // < 0 str1 less than str2
- // 0 str1 identical to str2
- // > 0 str1 greater than str2
-
- if (NULL == str1 && NULL != str2) return -1;
- if (NULL != str1 && NULL == str2) return 1;
- if (NULL == str1 && NULL == str2) return 0;
-
- while (*str1 == *str2 && '\0' != *str1 && '\0' != *str2 && len--!= 0)
- {
- str1++;
- str2++;
- }
-
- if ('\0' == *str1 && '\0' == *str2) return 0;
-
- if ('\0' != *str1) return -1;
- if ('\0' != *str2) return 1;
-
- return (*str1 > *str2) ? 1 : -1;
+ return wcsncmp(str1, str2, len);
}
-
#endif //!_Win32
#endif // __XPLAT_H__
projects / platform / upstream / coreclr.git / commitdiff