Dictionary mono_object_to_Dictionary(MonoObject *p_dict) {
Dictionary ret;
GDMonoUtils::MarshalUtils_DictToArrays dict_to_arrays = CACHED_METHOD_THUNK(MarshalUtils, DictionaryToArrays);
MonoArray *keys = NULL;
MonoArray *values = NULL;
MonoObject *ex = NULL;
dict_to_arrays(p_dict, &keys, &values, &ex);
if (ex) {
mono_print_unhandled_exception(ex);
ERR_FAIL_V(Dictionary());
}
int length = mono_array_length(keys);
for (int i = 0; i < length; i++) {
MonoObject *key_obj = mono_array_get(keys, MonoObject *, i);
MonoObject *value_obj = mono_array_get(values, MonoObject *, i);
Variant key = key_obj ? mono_object_to_variant(key_obj) : Variant();
Variant value = value_obj ? mono_object_to_variant(value_obj) : Variant();
ret[key] = value;
}
return ret;
}
gpointer
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (gpointer handle, MonoArray *arry)
{
guint32 len = mono_array_length (arry);
guchar *buf = mono_array_addr (arry, guchar, 0);
/* Read until the buffer is filled. This may block if using NAME_DEV_RANDOM. */
gint count = 0;
gint err;
do {
if (len - count >= sizeof (long))
{
*(long*)buf = rand();
count += sizeof (long);
}
else if (len - count >= sizeof (short))
{
*(short*)buf = rand();
count += sizeof (short);
}
else if (len - count >= sizeof (char))
{
*buf = rand();
count += sizeof (char);
}
} while (count < len);
return (gpointer)-1L;
}
CFArrayRef CMCreateArrayWithMonoStringArray(CFAllocatorRef allocator, MonoArray *monoArray) {
CFArrayRef array = NULL;
if (monoArray) {
uintptr_t n = mono_array_length(monoArray);
CFTypeRef *values = CFAllocatorAllocate(allocator, n * sizeof(CFTypeRef), 0);
if (values) {
for (uintptr_t i = 0; i < n; i++) {
values[i] = kCFNull;
MonoString *monoString = mono_array_get(monoArray, MonoString*, i);
if (monoString) {
char *utf8MonoString = mono_string_to_utf8(monoString);
if (utf8MonoString) {
CFStringRef string = CFStringCreateWithCString(allocator, utf8MonoString, kCFStringEncodingUTF8);
if (string) {
values[i] = string;
}
mono_free(utf8MonoString);
}
}
}
array = CFArrayCreate(allocator, values, n, &kCFTypeArrayCallBacks);
for (uintptr_t i = 0; i < n; i++) {
if (values[i] != kCFNull) {
CFRelease(values[i]);
}
}
CFAllocatorDeallocate(allocator, values);
}
}
return array;
}
Array mono_array_to_Array(MonoArray *p_array) {
Array ret;
int length = mono_array_length(p_array);
for (int i = 0; i < length; i++) {
MonoObject *elem = mono_array_get(p_array, MonoObject *, i);
ret.push_back(mono_object_to_variant(elem));
}
return ret;
}
PoolRealArray mono_array_to_PoolRealArray(MonoArray *p_array) {
PoolRealArray ret;
int length = mono_array_length(p_array);
for (int i = 0; i < length; i++) {
real_t elem = mono_array_get(p_array, real_t, i);
ret.push_back(elem);
}
return ret;
}
PoolStringArray mono_array_to_PoolStringArray(MonoArray *p_array) {
PoolStringArray ret;
int length = mono_array_length(p_array);
for (int i = 0; i < length; i++) {
MonoString *elem = mono_array_get(p_array, MonoString *, i);
ret.push_back(mono_string_to_godot(elem));
}
return ret;
}
PoolVector3Array mono_array_to_PoolVector3Array(MonoArray *p_array) {
PoolVector3Array ret;
int length = mono_array_length(p_array);
for (int i = 0; i < length; i++) {
real_t *raw_elem = (real_t *)mono_array_addr_with_size(p_array, sizeof(real_t) * 3, i);
MARSHALLED_IN(Vector3, raw_elem, elem);
ret.push_back(elem);
}
return ret;
}
gpointer
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (gpointer handle, MonoArray *arry)
{
gint file = GPOINTER_TO_INT (handle);
guint32 len = mono_array_length (arry);
guchar *buf = mono_array_addr (arry, guchar, 0);
if (egd) {
const char *socket_path = g_getenv ("MONO_EGD_SOCKET");
/* exception will be thrown in managed code */
if (socket_path == NULL)
return NULL;
get_entropy_from_server (socket_path, mono_array_addr (arry, guchar, 0), mono_array_length (arry));
return (gpointer) -1;
} else {
/* Read until the buffer is filled. This may block if using NAME_DEV_RANDOM. */
gint count = 0;
gint err;
do {
err = read (file, buf + count, len - count);
if (err < 0) {
if (errno == EINTR)
continue;
break;
}
count += err;
} while (count < len);
if (err < 0) {
g_warning("Entropy error! Error in read (%s).", strerror (errno));
/* exception will be thrown in managed code */
return NULL;
}
}
/* We do not support PRNG seeding right now but the class library is this */
return handle;
}
/* INFO: toplevel udt_clr_serialize */
int clr_serialize (int _gc_in, dk_session_t * ses)
{
MonoArray *v_args = NULL;
MonoArray *mono_list;
int len, inx;
MonoDomain *domain = virtuoso_domain;
get_mono_thread ();
v_args = MAKE_PARAM_ARRAY (domain, 1);
SET_INT_ARG (domain, v_args, 0, _gc_in);
QR_RESET_CTX
{
mono_list = (MonoArray *) call_mono (VIRTCLR_NAME, "VInvoke:obj_serialize_soap", v_args, domain);
}
QR_RESET_CODE
{
caddr_t err;
POP_QR_RESET;
err = thr_get_error_code (THREAD_CURRENT_THREAD);
if (ARRAYP (err))
log_error ("Mono Serialization error : [%s] [%s]", ERR_STATE(err), ERR_MESSAGE (err));
else
log_error ("Mono Serialization error : unknown");
dk_free_tree (err);
goto no_obj;
}
END_QR_RESET;
len = mono_array_length (mono_list);
if (len - 1 < 256)
{
session_buffered_write_char (DV_BIN, ses);
session_buffered_write_char (len - 1, ses);
}
else
{
session_buffered_write_char (DV_LONG_BIN, ses);
print_long (len - 1, ses);
}
for (inx = 1; inx < len; inx++)
{
MonoObject *obj = (MonoObject *)mono_array_get (mono_list, gpointer, inx);
guint8 b = *(guint8 *)((char *)obj + sizeof (MonoObject));
session_buffered_write_char (b, ses);
}
return len;
no_obj:
session_buffered_write_char (DV_DB_NULL, ses);
return 1;
}
//Get Set Static Properties Methods
// Get:RegisteredChannels
std::vector<mscorlib::System::Runtime::Remoting::Channels::IChannel*> ChannelServices::get_RegisteredChannels()
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Runtime.Remoting.Channels", "ChannelServices", 0, NULL, "get_RegisteredChannels", NullMonoObject, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Runtime::Remoting::Channels::IChannel*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Runtime::Remoting::Channels::IChannel (__array_item__));
}
return __array_result__;
}
// Get:Eras
std::vector<mscorlib::System::Int32*> EastAsianLunisolarCalendar::get_Eras() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Globalization", "Calendar", 0, NULL, "get_Eras", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Int32*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back((mscorlib::System::Int32 *)mono_object_unbox(__array_item__));
}
return __array_result__;
}
// Get:LegalKeySizes
std::vector<mscorlib::System::Security::Cryptography::KeySizes*> RSACryptoServiceProvider::get_LegalKeySizes() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Cryptography", "AsymmetricAlgorithm", 0, NULL, "get_LegalKeySizes", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Security::Cryptography::KeySizes*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Security::Cryptography::KeySizes (__array_item__));
}
return __array_result__;
}
// Get/Set:HashValue
std::vector<mscorlib::System::Byte*> HashMembershipCondition::get_HashValue() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Policy", "HashMembershipCondition", 0, NULL, "get_HashValue", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
// Get:OptionalCalendars
std::vector<mscorlib::System::Globalization::Calendar*> CultureInfo::get_OptionalCalendars() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Globalization", "CultureInfo", 0, NULL, "get_OptionalCalendars", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Globalization::Calendar*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Globalization::Calendar (__array_item__));
}
return __array_result__;
}
PoolIntArray mono_array_to_PoolIntArray(MonoArray *p_array) {
PoolIntArray ret;
if (!p_array)
return ret;
int length = mono_array_length(p_array);
ret.resize(length);
for (int i = 0; i < length; i++) {
int32_t elem = mono_array_get(p_array, int32_t, i);
ret.set(i, elem);
}
return ret;
}
// Get/Set:AppDomainInitializerArguments
std::vector<mscorlib::System::String*> AppDomainSetup::get_AppDomainInitializerArguments() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System", "AppDomainSetup", 0, NULL, "get_AppDomainInitializerArguments", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::String*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::String (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::Reflection::ParameterInfo*> PropertyBuilder::GetIndexParameters()
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Reflection.Emit", "PropertyBuilder", 0, NULL, "GetIndexParameters", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Reflection::ParameterInfo*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Reflection::ParameterInfo (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::Object*> Stack::ToArray()
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Collections", "Stack", 0, NULL, "ToArray", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Object*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Object (__array_item__));
}
return __array_result__;
}
// Get/Set:DQ
std::vector<mscorlib::System::Byte*> RSAParameters::get_DQ() const
{
MonoObject *__result__ = Global::GetFieldValue("mscorlib", "System.Security.Cryptography", "RSAParameters", 0, NULL, "DQ");
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
// Get:Hash
std::vector<mscorlib::System::Byte*> SHA1::get_Hash() const
{
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Cryptography", "HashAlgorithm", 0, NULL, "get_Hash", __native_object__, 0, NULL, NULL, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
Array mono_array_to_Array(MonoArray *p_array) {
Array ret;
if (!p_array)
return ret;
int length = mono_array_length(p_array);
ret.resize(length);
for (int i = 0; i < length; i++) {
MonoObject *elem = mono_array_get(p_array, MonoObject *, i);
ret[i] = mono_object_to_variant(elem);
}
return ret;
}
PoolStringArray mono_array_to_PoolStringArray(MonoArray *p_array) {
PoolStringArray ret;
if (!p_array)
return ret;
int length = mono_array_length(p_array);
ret.resize(length);
for (int i = 0; i < length; i++) {
MonoString *elem = mono_array_get(p_array, MonoString *, i);
ret.set(i, mono_string_to_godot(elem));
}
return ret;
}
void godot_icall_Array_CopyTo(Array *ptr, MonoArray *array, int array_index) {
int count = ptr->size();
if (mono_array_length(array) < (array_index + count)) {
MonoException *exc = mono_get_exception_argument("", "Destination array was not long enough. Check destIndex and length, and the array's lower bounds.");
GDMonoUtils::set_pending_exception(exc);
return;
}
for (int i = 0; i < count; i++) {
MonoObject *boxed = GDMonoMarshal::variant_to_mono_object(ptr->operator[](i));
mono_array_setref(array, array_index, boxed);
array_index++;
}
}
PoolVector2Array mono_array_to_PoolVector2Array(MonoArray *p_array) {
PoolVector2Array ret;
if (!p_array)
return ret;
int length = mono_array_length(p_array);
ret.resize(length);
for (int i = 0; i < length; i++) {
real_t *raw_elem = (real_t *)mono_array_addr_with_size(p_array, sizeof(real_t) * 2, i);
MARSHALLED_IN(Vector2, raw_elem, elem);
ret.set(i, elem);
}
return ret;
}
std::vector<mscorlib::System::Byte*> RSACryptoServiceProvider::ExportCspBlob(mscorlib::System::Boolean includePrivateParameters)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType(typeid(includePrivateParameters).name());
__parameters__[0] = reinterpret_cast<void*>(includePrivateParameters);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Cryptography", "RSACryptoServiceProvider", 0, NULL, "ExportCspBlob", __native_object__, 1, __parameter_types__, __parameters__, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::String*> ChannelServices::GetUrlsForObject(mscorlib::System::MarshalByRefObject obj)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType(typeid(obj).name());
__parameters__[0] = (MonoObject*)obj;
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Runtime.Remoting.Channels", "ChannelServices", 0, NULL, "GetUrlsForObject", NullMonoObject, 1, __parameter_types__, __parameters__, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::String*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::String (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::String*> FileIOPermission::GetPathList(mscorlib::System::Security::Permissions::FileIOPermissionAccess::__ENUM__ access)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType(typeid(access).name());
mscorlib::System::Int32 __param_access__ = access;
__parameters__[0] = &__param_access__;
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Permissions", "FileIOPermission", 0, NULL, "GetPathList", __native_object__, 1, __parameter_types__, __parameters__, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::String*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::String (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::Byte*> RSACryptoServiceProvider::SignData(mscorlib::System::IO::Stream inputStream, mscorlib::System::Object halg)
{
MonoType *__parameter_types__[2];
void *__parameters__[2];
__parameter_types__[0] = Global::GetType(typeid(inputStream).name());
__parameter_types__[1] = Global::GetType(typeid(halg).name());
__parameters__[0] = (MonoObject*)inputStream;
__parameters__[1] = (MonoObject*)halg;
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Cryptography", "RSACryptoServiceProvider", 0, NULL, "SignData", __native_object__, 2, __parameter_types__, __parameters__, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
std::vector<mscorlib::System::Byte*> RSACryptoServiceProvider::SignHash(std::vector<mscorlib::System::Byte*> rgbHash, const char *str)
{
MonoType *__parameter_types__[2];
void *__parameters__[2];
__parameter_types__[0] = mono_class_get_type(mono_array_class_get(mono_class_from_mono_type(Global::GetType("mscorlib", "System", "Byte")), 1));
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = Global::FromArray<mscorlib::System::Byte*>(rgbHash, typeid(mscorlib::System::Byte).name());
__parameters__[1] = mono_string_new(Global::GetDomain(), str);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security.Cryptography", "RSACryptoServiceProvider", 0, NULL, "SignHash", __native_object__, 2, __parameter_types__, __parameters__, NULL);
MonoArray *__array_ptr__ = (MonoArray*)__result__;
uintptr_t __array_length__ = mono_array_length(__array_ptr__);
std::vector<mscorlib::System::Byte*> __array_result__(__array_length__);
for(uintptr_t __array_index__ = 0; __array_index__ < __array_length__; __array_index__++)
{
MonoObject *__array_item__ = mono_array_get(__array_ptr__,MonoObject*,__array_index__);
__array_result__.push_back(new mscorlib::System::Byte (__array_item__));
}
return __array_result__;
}
gpointer
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (gpointer handle, MonoArray *arry)
{
HCRYPTPROV provider = (HCRYPTPROV) handle;
guint32 len = mono_array_length (arry);
guchar *buf = mono_array_addr (arry, guchar, 0);
if (!CryptGenRandom (provider, len, buf)) {
CryptReleaseContext (provider, 0);
/* we may have lost our context with CryptoAPI, but all hope isn't lost yet! */
provider = (HCRYPTPROV) ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngInitialize (NULL);
if (!CryptGenRandom (provider, len, buf)) {
CryptReleaseContext (provider, 0);
provider = 0;
/* exception will be thrown in managed code */
}
}
return (gpointer) provider;
}
