XCode/Badminton-Scoreboard
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[add] first

Browse Source
This commit is contained in:
建喵
2023-10-08 10:24:48 +08:00
commit b1ae0510a9
1048 changed files with 3254361 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Libraries/libil2cpp/include/icalls/mscorlib/Interop.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
struct Il2CppMonoAssemblyName;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
class LIBIL2CPP_CODEGEN_API Interop
{
public:
class LIBIL2CPP_CODEGEN_API Sys
{
public:
static int32_t DoubleToString(double value, char* format, char* buffer, int32_t bufferLength);
};
};
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

22
Libraries/libil2cpp/include/icalls/mscorlib/Microsoft.Win32/NativeMethods.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Microsoft
{
namespace Win32
{
class LIBIL2CPP_CODEGEN_API NativeMethods
{
public:
static int32_t GetCurrentProcessId();
};
} // namespace Win32
} // namespace Microsoft
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

29
Libraries/libil2cpp/include/icalls/mscorlib/Mono.Security.Cryptography/KeyPairPersistence.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
namespace Security
{
namespace Cryptography
{
class LIBIL2CPP_CODEGEN_API KeyPairPersistence
{
public:
static bool _CanSecure(Il2CppChar* root);
static bool _IsMachineProtected(Il2CppChar* path);
static bool _IsUserProtected(Il2CppChar* path);
static bool _ProtectMachine(Il2CppChar* path);
static bool _ProtectUser(Il2CppChar* path);
};
} /* namespace Cryptography */
} /* namespace Security */
} /* namespace Mono */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

23
Libraries/libil2cpp/include/icalls/mscorlib/Mono.Unity/UnityTls.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include "il2cpp-config.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
namespace Unity
{
class LIBIL2CPP_CODEGEN_API UnityTls
{
public:
static const void* GetUnityTlsInterface();
};
} /* namespace Unity */
} /* namespace Mono */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

32
Libraries/libil2cpp/include/icalls/mscorlib/Mono/Runtime.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
class LIBIL2CPP_CODEGEN_API Runtime
{
public:
static int32_t CheckCrashReportLog_internal(intptr_t directory, bool clear);
static Il2CppString* DumpStateSingle_internal(uint64_t* portable_hash, uint64_t* unportable_hash);
static Il2CppString* DumpStateTotal_internal(uint64_t* portable_hash, uint64_t* unportable_hash);
static Il2CppString* ExceptionToState_internal(Il2CppException* exc, uint64_t* portable_hash, uint64_t* unportable_hash);
static Il2CppString* GetDisplayName();
static Il2CppString* GetNativeStackTrace(Il2CppException* exception);
static void AnnotateMicrosoftTelemetry_internal(intptr_t key, intptr_t val);
static void EnableCrashReportLog_internal(intptr_t directory);
static void mono_runtime_cleanup_handlers();
static void mono_runtime_install_handlers();
static void RegisterReportingForAllNativeLibs_internal();
static void RegisterReportingForNativeLib_internal(intptr_t modulePathSuffix, intptr_t moduleName);
};
} /* namespace Mono */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

21
Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeClassHandle.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
class LIBIL2CPP_CODEGEN_API RuntimeClassHandle
{
public:
static intptr_t GetTypeFromClass(Il2CppClass* klass);
};
} // namespace Mono
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

19
Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeGPtrArrayHandle.h Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
class LIBIL2CPP_CODEGEN_API RuntimeGPtrArrayHandle
{
public:
static void GPtrArrayFree(void* value);
};
} // namespace Mono
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

21
Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeMarshal.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
struct Il2CppMonoAssemblyName;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
class LIBIL2CPP_CODEGEN_API RuntimeMarshal
{
public:
static void FreeAssemblyName(Il2CppMonoAssemblyName* name, bool freeStruct);
};
} // namespace Mono
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

22
Libraries/libil2cpp/include/icalls/mscorlib/Mono/SafeStringMarshal.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace Mono
{
class LIBIL2CPP_CODEGEN_API SafeStringMarshal
{
public:
static intptr_t StringToUtf8_icall(Il2CppString *volatile* str);
static void GFree(intptr_t ptr);
};
} // namespace Mono
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

24
Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/Debugger.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Diagnostics
{
class LIBIL2CPP_CODEGEN_API Debugger
{
public:
static bool IsAttached_internal();
static bool IsLogging();
static void Log_icall(int32_t level, Il2CppString** category, Il2CppString** message);
};
} /* namespace Diagnostics */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

36
Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/StackFrame.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppReflectionMethod;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Diagnostics
{
class LIBIL2CPP_CODEGEN_API StackFrame
{
public:
static bool get_frame_info(
int32_t skip,
bool needFileInfo,
Il2CppReflectionMethod ** method,
int32_t* iloffset,
int32_t* native_offset,
Il2CppString** file,
int32_t* line,
int32_t* column);
};
} /* namespace Diagnostics */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

28
Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/StackTrace.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppException;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Diagnostics
{
class LIBIL2CPP_CODEGEN_API StackTrace
{
public:
static Il2CppArray* get_trace(Il2CppException *exc, int32_t skip, bool need_file_info);
};
} /* namespace Diagnostics */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

24
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CalendarData.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
struct Il2CppCalendarData;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
class LIBIL2CPP_CODEGEN_API CalendarData
{
public:
static bool fill_calendar_data(Il2CppCalendarData* _this, Il2CppString* localeName, int32_t datetimeIndex);
};
} // namespace Globalization
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

23
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CompareInfo.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
class LIBIL2CPP_CODEGEN_API CompareInfo
{
public:
static int32_t internal_compare_icall(Il2CppChar* str1, int32_t length1, Il2CppChar* str2, int32_t length2, int32_t options);
static int32_t internal_index_icall(Il2CppChar* source, int32_t sindex, int32_t count, Il2CppChar* value, int32_t value_length, bool first);
};
} /* namespace Globalization */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

32
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CompareOptions.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include <stdint.h>
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
// System.Globalization.CompareOptions
typedef enum
{
CompareOptions_None = 0x00,
CompareOptions_IgnoreCase = 0x01,
CompareOptions_IgnoreNonSpace = 0x02,
CompareOptions_IgnoreSymbols = 0x04,
CompareOptions_IgnoreKanaType = 0x08,
CompareOptions_IgnoreWidth = 0x10,
CompareOptions_StringSort = 0x20000000,
CompareOptions_Ordinal = 0x40000000,
CompareOptions_OrdinalIgnoreCase = 0x10000000
} CompareOptions;
} /* namespace Globalization */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

26
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureData.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
struct NumberFormatEntryManaged;
struct Il2CppCultureData;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
class LIBIL2CPP_CODEGEN_API CultureData
{
public:
static const void* fill_number_data(int32_t number_index, NumberFormatEntryManaged* managed);
static void fill_culture_data(Il2CppCultureData* _this, int32_t datetimeIndex);
};
} // namespace Globalization
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

31
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureInfo.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppCultureInfo;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
class LIBIL2CPP_CODEGEN_API CultureInfo
{
public:
static bool construct_internal_locale_from_lcid(Il2CppCultureInfo* cultureInfo, int lcid);
static bool construct_internal_locale_from_name(Il2CppCultureInfo* cultureInfo, Il2CppString* name);
static Il2CppArray* internal_get_cultures(bool neutral, bool specific, bool installed);
static Il2CppString* get_current_locale_name();
};
} /* namespace Diagnostics */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

5
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureInfoInternals.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include <stdint.h>
#include "Generated/CultureInfoInternalsNet_4_0.h"

5
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureInfoTables.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "CultureInfoInternals.h"
#include "Generated/CultureInfoTablesNet_4_0.h"

138
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/Generated/CultureInfoInternalsNet_4_0.h Normal file
View File

@@ -0,0 +1,138 @@
//This is a Generated File.... Run CultureInfoUpdater tool to update
/**
* \file
*/
#ifndef _MONO_METADATA_CULTURE_INFO_H_
#define _MONO_METADATA_CULTURE_INFO_H_ 1
#define NUM_DAYS 7
#define NUM_MONTHS 13
#define GROUP_SIZE 2
#define NUM_CALENDARS 4
#define NUM_SHORT_DATE_PATTERNS 14
#define NUM_LONG_DATE_PATTERNS 10
#define NUM_SHORT_TIME_PATTERNS 12
#define NUM_LONG_TIME_PATTERNS 9
#define NUM_YEAR_MONTH_PATTERNS 8
#define idx2string(idx) (locale_strings + (idx))
#define pattern2string(idx) (patterns + (idx))
#define dtidx2string(idx) (datetime_strings + (idx))
/* need to change this if the string data ends up to not fit in a 64KB array. */
typedef struct {
const uint16_t month_day_pattern;
const uint16_t am_designator;
const uint16_t pm_designator;
const uint16_t day_names [NUM_DAYS];
const uint16_t abbreviated_day_names [NUM_DAYS];
const uint16_t shortest_day_names [NUM_DAYS];
const uint16_t month_names [NUM_MONTHS];
const uint16_t month_genitive_names [NUM_MONTHS];
const uint16_t abbreviated_month_names [NUM_MONTHS];
const uint16_t abbreviated_month_genitive_names [NUM_MONTHS];
const int8_t calendar_week_rule;
const int8_t first_day_of_week;
const uint16_t date_separator;
const uint16_t time_separator;
const uint16_t short_date_patterns [NUM_SHORT_DATE_PATTERNS];
const uint16_t long_date_patterns [NUM_LONG_DATE_PATTERNS];
const uint16_t short_time_patterns [NUM_SHORT_TIME_PATTERNS];
const uint16_t long_time_patterns [NUM_LONG_TIME_PATTERNS];
const uint16_t year_month_patterns [NUM_YEAR_MONTH_PATTERNS];
} DateTimeFormatEntry;
typedef struct {
const uint16_t currency_decimal_separator;
const uint16_t currency_group_separator;
const uint16_t number_decimal_separator;
const uint16_t number_group_separator;
const uint16_t currency_symbol;
const uint16_t percent_symbol;
const uint16_t nan_symbol;
const uint16_t per_mille_symbol;
const uint16_t negative_infinity_symbol;
const uint16_t positive_infinity_symbol;
const uint16_t negative_sign;
const uint16_t positive_sign;
const int8_t currency_negative_pattern;
const int8_t currency_positive_pattern;
const int8_t percent_negative_pattern;
const int8_t percent_positive_pattern;
const int8_t number_negative_pattern;
const int8_t currency_decimal_digits;
const int8_t number_decimal_digits;
const int currency_group_sizes [GROUP_SIZE];
const int number_group_sizes [GROUP_SIZE];
} NumberFormatEntry;
typedef struct {
int ansi;
int ebcdic;
int mac;
int oem;
bool is_right_to_left;
char list_sep;
} TextInfoEntry;
typedef struct {
int16_t lcid;
int16_t parent_lcid;
int16_t calendar_type;
int16_t region_entry_index;
uint16_t name;
uint16_t englishname;
uint16_t nativename;
uint16_t win3lang;
uint16_t iso3lang;
uint16_t iso2lang;
uint16_t territory;
uint16_t native_calendar_names [NUM_CALENDARS];
int16_t datetime_format_index;
int16_t number_format_index;
TextInfoEntry text_info;
} CultureInfoEntry;
typedef struct {
const uint16_t name;
const int16_t culture_entry_index;
} CultureInfoNameEntry;
typedef struct {
const int16_t geo_id;
const uint16_t iso2name;
const uint16_t iso3name;
const uint16_t win3name;
const uint16_t english_name;
const uint16_t native_name;
const uint16_t currency_symbol;
const uint16_t iso_currency_symbol;
const uint16_t currency_english_name;
const uint16_t currency_native_name;
} RegionInfoEntry;
typedef struct {
const uint16_t name;
const int16_t region_entry_index;
} RegionInfoNameEntry;
#endif

8486
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/Generated/CultureInfoTablesNet_4_0.h Normal file
View File

File diff suppressed because it is too large Load Diff

38
Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/RegionInfo.h Normal file
View File

@@ -0,0 +1,38 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Globalization
{
class LIBIL2CPP_CODEGEN_API RegionInfo
{
public:
static bool construct_internal_region_from_name(Il2CppRegionInfo* regionInfo, Il2CppString* name);
};
} /* namespace Globalization */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

48
Libraries/libil2cpp/include/icalls/mscorlib/System.IO/BrokeredFileSystem.h Normal file
View File

@@ -0,0 +1,48 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-class-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace IO
{
#pragma pack(push, 4)
struct WIN32_FILE_ATTRBIUTE_DATA_MIRROR
{
int32_t attributes;
int64_t creation_time;
int64_t last_access_time;
int64_t last_write_time;
uint32_t length_high;
uint32_t length_low;
};
#pragma pack(pop)
class LIBIL2CPP_CODEGEN_API BrokeredFileSystem
{
public:
static bool CreateDirectory(Il2CppString* path);
static bool RemoveDirectory(Il2CppString* path);
static bool GetFileAttributes(Il2CppString* path, WIN32_FILE_ATTRBIUTE_DATA_MIRROR* data);
static bool SetAttributes(Il2CppString* path, int32_t attributes);
static void* OpenFile(Il2CppString* path, int32_t desiredAccess, int32_t shareMode, int32_t creationDisposition, int32_t flagsAndAttributes);
static void CopyFile(Il2CppString* sourcePath, Il2CppString* destinationPath, bool overwrite, int32_t* error);
static bool MoveFile(Il2CppString* sourcePath, Il2CppString* destinationPath);
static bool DeleteFile(Il2CppString* path);
static void* FindFirstFile(Il2CppString* searchPath, Il2CppString** resultFileName, uint32_t* fileAttributes);
static bool FindNextFile(void* handle, Il2CppString** resultFileName, uint32_t* fileAttributes);
static void FindHandleClose(void* handle);
};
} /* namespace IO */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

24
Libraries/libil2cpp/include/icalls/mscorlib/System.IO/DriveInfo.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace IO
{
class LIBIL2CPP_CODEGEN_API DriveInfo
{
public:
static bool GetDiskFreeSpaceInternal(Il2CppChar* pathName, int32_t pathName_length, uint64_t* freeBytesAvail, uint64_t* totalNumberOfBytes, uint64_t* totalNumberOfFreeBytes, int32_t* error);
static Il2CppString* GetDriveFormatInternal(Il2CppChar* rootPathName, int32_t rootPathName_length);
static uint32_t GetDriveTypeInternal(Il2CppChar* rootPathName, int32_t rootPathName_length);
};
} /* namespace IO */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

89
Libraries/libil2cpp/include/icalls/mscorlib/System.IO/MonoIO.h Normal file
View File

@@ -0,0 +1,89 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
#undef CopyFile
#undef DeleteFile
#undef MoveFile
#undef ReplaceFile
#undef GetFileAttributes
#undef SetFileAttributes
#undef CreatePipe
#undef GetTempPath
#undef FindNextFile
#undef FindFirstFile
struct Il2CppArray;
struct Il2CppString;
typedef int32_t MonoIOError;
typedef int32_t FileAttributes;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace IO
{
struct FileStat
{
int32_t attributes;
int64_t length;
int64_t creation_time;
int64_t last_access_time;
int64_t last_write_time;
};
class LIBIL2CPP_CODEGEN_API MonoIO
{
public:
static bool Cancel_internal(intptr_t handle, int32_t* error);
static bool Close(intptr_t handle, int32_t* error);
static bool CopyFile(Il2CppChar* path, Il2CppChar* dest, bool overwrite, int32_t* error);
static bool CreateDirectory(Il2CppChar* path, int32_t* error);
static bool CreatePipe(intptr_t* read_handle, intptr_t* write_handle, int32_t* error);
static bool DeleteFile(Il2CppChar* path, int32_t* error);
static bool DuplicateHandle(intptr_t source_process_handle, intptr_t source_handle, intptr_t target_process_handle, intptr_t* target_handle, int32_t access, int32_t inherit, int32_t options, int32_t* error);
static bool FindCloseFile(intptr_t hnd);
static bool FindNextFile(intptr_t hnd, Il2CppString** fileName, int32_t* fileAttr, int32_t* error);
static bool Flush(intptr_t handle, int32_t* error);
static bool GetFileStat(Il2CppChar* path, FileStat* stat, int32_t* error);
static bool MoveFile(Il2CppChar* path, Il2CppChar* dest, int32_t* error);
static bool RemapPath(Il2CppString* path, Il2CppString** newPath);
static bool RemoveDirectory(Il2CppChar* path, int32_t* error);
static bool ReplaceFile(Il2CppChar* sourceFileName, Il2CppChar* destinationFileName, Il2CppChar* destinationBackupFileName, bool ignoreMetadataErrors, int32_t* error);
static bool SetCurrentDirectory(Il2CppChar* path, int32_t* error);
static bool SetFileAttributes(Il2CppChar* path, int32_t attrs, int32_t* error);
static bool SetFileTime(intptr_t handle, int64_t creation_time, int64_t last_access_time, int64_t last_write_time, int32_t* error);
static bool SetLength(intptr_t handle, int64_t length, int32_t* error);
static Il2CppChar get_AltDirectorySeparatorChar();
static Il2CppChar get_DirectorySeparatorChar();
static Il2CppChar get_PathSeparator();
static Il2CppChar get_VolumeSeparatorChar();
static int32_t Read(intptr_t handle, Il2CppArray* dest, int32_t dest_offset, int32_t count, int32_t* error);
static int32_t Write(intptr_t handle, Il2CppArray* src, int32_t src_offset, int32_t count, int32_t* error);
static int64_t GetLength(intptr_t handle, int32_t* error);
static int64_t Seek(intptr_t handle, int64_t offset, int32_t origin, int32_t* error);
static intptr_t FindFirstFile(Il2CppChar* pathWithPattern, Il2CppString** fileName, int32_t* fileAttr, int32_t* error);
static intptr_t get_ConsoleError();
static intptr_t get_ConsoleInput();
static intptr_t get_ConsoleOutput();
static intptr_t Open(Il2CppChar* filename, int32_t mode, int32_t access, int32_t share, int32_t options, int32_t* error);
static int32_t GetFileAttributes(Il2CppChar* path, int32_t* error);
static int32_t GetFileType(intptr_t handle, int32_t* error);
static Il2CppString* GetCurrentDirectory(int32_t* error);
static void DumpHandles();
static void Lock(intptr_t handle, int64_t position, int64_t length, int32_t* error);
static void Unlock(intptr_t handle, int64_t position, int64_t length, int32_t* error);
};
} /* namespace IO */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

38
Libraries/libil2cpp/include/icalls/mscorlib/System.IO/Path.h Normal file
View File

@@ -0,0 +1,38 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace IO
{
class LIBIL2CPP_CODEGEN_API Path
{
public:
static Il2CppString* get_temp_path();
};
} /* namespace IO */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

43
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/Assembly.h Normal file
View File

@@ -0,0 +1,43 @@
#pragma once
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppString;
struct Il2CppAssemblyName;
struct Il2CppReflectionAssembly;
struct mscorlib_System_Reflection_Assembly;
struct mscorlib_System_Reflection_Module;
struct mscorlib_System_Security_Policy_Evidence;
struct mscorlib_System_Reflection_AssemblyName;
struct Il2CppMonoAssemblyName;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API Assembly
{
public:
static intptr_t InternalGetReferencedAssemblies(Il2CppReflectionAssembly* module);
static Il2CppReflectionAssembly* GetCallingAssembly();
static Il2CppObject* GetEntryAssembly();
static Il2CppReflectionAssembly* GetExecutingAssembly();
static Il2CppReflectionAssembly* load_with_partial_name(Il2CppString* name, Il2CppObject* e);
static Il2CppReflectionAssembly* LoadFile_internal(Il2CppString* assemblyFile, int32_t* stackMark);
static Il2CppReflectionAssembly* LoadFrom(Il2CppString* assemblyFile, bool refOnly, int32_t* stackMark);
static Il2CppReflectionType* InternalGetType(Il2CppReflectionAssembly* thisPtr, Il2CppObject* module, Il2CppString* name, bool throwOnError, bool ignoreCase);
static Il2CppArray* GetTypes(Il2CppReflectionAssembly* thisPtr, bool exportedOnly);
static void InternalGetAssemblyName(Il2CppString* assemblyFile, void* aname, Il2CppString** codebase);
};
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

31
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/AssemblyName.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppReflectionAssemblyName;
struct Il2CppMonoAssemblyName;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API AssemblyName
{
public:
static Il2CppMonoAssemblyName* GetNativeName(intptr_t assembly_ptr);
static bool ParseAssemblyName(intptr_t name, Il2CppMonoAssemblyName* aname, bool* is_version_definited, bool* is_token_defined);
static void get_public_token(uint8_t* token, uint8_t* pubkey, int32_t len);
};
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

24
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/CustomAttributeData.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API CustomAttributeData
{
public:
static void ResolveArgumentsInternal(Il2CppObject* ctor, Il2CppObject* assembly, intptr_t data, uint32_t data_length, Il2CppArray** ctorArgs, Il2CppArray** namedArgs);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

24
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/EventInfo.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API EventInfo
{
public:
static Il2CppReflectionEvent* internal_from_handle_type(intptr_t event_handle, intptr_t type_handle);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

29
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/FieldInfo.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include "il2cpp-object-internals.h"
#include "il2cpp-config.h"
struct Il2CppReflectionField;
struct Il2CppReflectionMarshal;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API FieldInfo
{
public:
static Il2CppReflectionField* internal_from_handle_type(intptr_t field_handle, intptr_t type_handle);
static Il2CppObject* get_marshal_info(Il2CppObject* thisPtr);
};
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

22
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MethodBase.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API MethodBase
{
public:
static Il2CppReflectionMethod* GetCurrentMethod();
};
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

0
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/Module.h Normal file
View File

30
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoMethodInfo.h Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API MonoMethodInfo
{
public:
static void get_method_info(intptr_t methodPtr, Il2CppMethodInfo* info);
static void* /* System.Reflection.Emit.UnmanagedMarshal */ get_retval_marshal(intptr_t handle);
static Il2CppArray* get_parameter_info(intptr_t methodPtr, Il2CppReflectionMethod* member);
static int32_t get_method_attributes(intptr_t methodPtr);
};
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

37
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeAssembly.h Normal file
View File

@@ -0,0 +1,37 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeAssembly
{
public:
static bool get_global_assembly_cache(Il2CppObject* thisPtr);
static bool get_ReflectionOnly(Il2CppObject* thisPtr);
static bool GetAotIdInternal(Il2CppArray* aotid);
static bool GetManifestResourceInfoInternal(Il2CppReflectionAssembly* assembly, Il2CppString* name, Il2CppManifestResourceInfo* info);
static intptr_t GetManifestResourceInternal(Il2CppReflectionAssembly* assembly, Il2CppString* name, int* size, Il2CppReflectionModule** module);
static Il2CppObject* GetFilesInternal(Il2CppObject* thisPtr, Il2CppString* name, bool getResourceModules);
static Il2CppReflectionMethod* get_EntryPoint(Il2CppReflectionAssembly* self);
static Il2CppObject* GetManifestModuleInternal(Il2CppObject* thisPtr);
static Il2CppArray* GetModulesInternal(Il2CppReflectionAssembly * thisPtr);
static Il2CppString* get_code_base(Il2CppReflectionAssembly* reflectionAssembly, bool escaped);
static Il2CppString* get_fullname(Il2CppReflectionAssembly* assembly);
static Il2CppString* get_location(Il2CppReflectionAssembly* assembly);
static Il2CppString* InternalImageRuntimeVersion(Il2CppObject* a);
static Il2CppArray* GetManifestResourceNames(Il2CppReflectionAssembly* assembly);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

23
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeConstructorInfo.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeConstructorInfo
{
public:
static int32_t get_metadata_token(Il2CppObject* method);
static Il2CppObject* InternalInvoke(Il2CppReflectionMethod* method, Il2CppObject* thisPtr, Il2CppArray* params, Il2CppException** exc);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

24
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeEventInfo.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <il2cpp-object-internals.h>
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeEventInfo
{
public:
static int32_t get_metadata_token(Il2CppObject* monoEvent);
static void get_event_info(Il2CppReflectionMonoEvent* event, Il2CppReflectionMonoEventInfo* eventInfo);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

32
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeFieldInfo.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeFieldInfo
{
public:
static int32_t get_metadata_token(Il2CppObject* monoField);
static int32_t GetFieldOffset(Il2CppReflectionField* field);
static Il2CppObject* GetRawConstantValue(Il2CppReflectionField* field);
static Il2CppObject* GetValueInternal(Il2CppReflectionField* field, Il2CppObject* obj);
static Il2CppObject* UnsafeGetValue(Il2CppReflectionField* field, Il2CppObject* obj);
static Il2CppReflectionType* GetParentType(Il2CppReflectionField* field, bool declaring);
static Il2CppObject* ResolveType(Il2CppObject* thisPtr);
static Il2CppArray* GetTypeModifiers(Il2CppObject* thisPtr, bool optional);
static void SetValueInternal(Il2CppReflectionField* fi, Il2CppObject* obj, Il2CppObject* value);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

35
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeMethodInfo.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeMethodInfo
{
public:
static bool get_IsGenericMethod(Il2CppReflectionMethod* method);
static bool get_IsGenericMethodDefinition(Il2CppReflectionMethod* method);
static int32_t get_metadata_token(Il2CppObject* method);
static Il2CppObject* InternalInvoke(Il2CppReflectionMethod * method, Il2CppObject * thisPtr, Il2CppArray * params, Il2CppException * * exc);
static Il2CppReflectionMethod* GetMethodFromHandleInternalType_native(intptr_t method_handle, intptr_t type_handle, bool genericCheck);
static Il2CppObject* GetMethodBodyInternal(intptr_t handle);
static Il2CppReflectionMethod* GetGenericMethodDefinition_impl(Il2CppReflectionMethod* method);
static Il2CppReflectionMethod* MakeGenericMethod_impl(Il2CppReflectionMethod* method, Il2CppArray* genericArgumentTypes);
static Il2CppReflectionMethod* get_base_method(Il2CppReflectionMethod* method, bool definition);
static Il2CppString* get_name(Il2CppReflectionMethod* reflectionMethod);
static Il2CppArray* GetGenericArguments(Il2CppReflectionMethod* method);
static void GetPInvoke(Il2CppReflectionMethod* _this, int32_t* flags, Il2CppString** entryPoint, Il2CppString** dllName);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

36
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeModule.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeModule
{
public:
static Il2CppArray* ResolveSignature(intptr_t module, int32_t metadataToken, int32_t* error);
static int32_t get_MetadataToken(Il2CppReflectionModule* module);
static int32_t GetMDStreamVersion(intptr_t module);
static intptr_t GetHINSTANCE(intptr_t module);
static intptr_t ResolveFieldToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, int32_t* error);
static intptr_t ResolveMethodToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, int32_t* error);
static intptr_t ResolveTypeToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, int32_t* error);
static Il2CppObject* ResolveMemberToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, int32_t* error);
static Il2CppString* ResolveStringToken(intptr_t module, int32_t token, int32_t* error);
static Il2CppObject* GetGlobalType(intptr_t module);
static Il2CppArray* InternalGetTypes(const Il2CppImage* module);
static void GetGuidInternal(intptr_t module, Il2CppArray* guid);
static void GetPEKind(intptr_t module, int32_t* peKind, int32_t* machine);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

23
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimeParameterInfo.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
class LIBIL2CPP_CODEGEN_API RuntimeParameterInfo
{
public:
static int32_t GetMetadataToken(Il2CppObject* thisPtr);
static Il2CppArray* GetTypeModifiers(Il2CppObject* type, Il2CppObject* member, int32_t position, bool optional);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

38
Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RuntimePropertyInfo.h Normal file
View File

@@ -0,0 +1,38 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
typedef enum
{
PInfo_Attributes = 1,
PInfo_GetMethod = 1 << 1,
PInfo_SetMethod = 1 << 2,
PInfo_ReflectedType = 1 << 3,
PInfo_DeclaringType = 1 << 4,
PInfo_Name = 1 << 5
} PInfo;
class LIBIL2CPP_CODEGEN_API RuntimePropertyInfo
{
public:
static int32_t get_metadata_token(Il2CppObject* monoProperty);
static Il2CppObject* get_default_value(Il2CppObject* prop);
static Il2CppReflectionProperty* internal_from_handle_type(intptr_t handlePtr, intptr_t typePtr);
static Il2CppArray* GetTypeModifiers(Il2CppObject* prop, bool optional);
static void get_property_info(Il2CppReflectionProperty *property, Il2CppPropertyInfo *info, PInfo req_info);
};
} // namespace Reflection
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

34
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.CompilerServices/RuntimeHelpers.h Normal file
View File

@@ -0,0 +1,34 @@
#pragma once
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace CompilerServices
{
class LIBIL2CPP_CODEGEN_API RuntimeHelpers
{
public:
static Il2CppObject* GetObjectValue(Il2CppObject* obj);
static void RunClassConstructor(intptr_t type);
static void RunModuleConstructor(intptr_t module);
static int get_OffsetToStringData(void);
static void InitializeArray(Il2CppArray* arr, intptr_t ptr);
static bool SufficientExecutionStack();
};
} /* namespace CompilerServices */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

35
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices/GCHandle.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace InteropServices
{
class LIBIL2CPP_CODEGEN_API GCHandle
{
public:
static bool CheckCurrentDomain(int32_t handle);
static void FreeHandle(int32_t handle);
static intptr_t GetAddrOfPinnedObject(int32_t handle);
static Il2CppObject * GetTarget(int32_t handle);
static int32_t GetTargetHandle(Il2CppObject * obj, int32_t handle, int32_t type);
};
} /* namespace InteropServices */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

97
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices/Marshal.h Normal file
View File

@@ -0,0 +1,97 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct mscorlib_System_Guid;
struct mscorlib_System_Reflection_MemberInfo;
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppString;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace InteropServices
{
class LIBIL2CPP_CODEGEN_API Marshal
{
public:
static int32_t GetLastWin32Error();
static void SetLastWin32Error(uint32_t);
static int32_t AddRefInternal(intptr_t pUnk);
static intptr_t AllocCoTaskMem(int32_t size);
static intptr_t AllocHGlobal(intptr_t size);
static void DestroyStructure(intptr_t ptr, Il2CppReflectionType* structureType);
static void FreeBSTR(intptr_t ptr);
static void FreeCoTaskMem(intptr_t ptr);
static void FreeHGlobal(intptr_t hglobal);
static intptr_t GetCCW(Il2CppObject* o, Il2CppReflectionType * T);
static int32_t GetComSlotForMethodInfoInternal(mscorlib_System_Reflection_MemberInfo * m);
static Il2CppDelegate* GetDelegateForFunctionPointerInternal(intptr_t ptr, Il2CppReflectionType* t);
static intptr_t GetFunctionPointerForDelegateInternal(Il2CppDelegate* d);
static intptr_t GetIDispatchForObjectInternal(Il2CppObject* o);
static intptr_t GetIUnknownForObjectInternal(Il2CppObject* o);
static Il2CppObject* GetObjectForCCW(intptr_t pUnk);
static bool IsComObject(Il2CppObject* o);
static intptr_t OffsetOf(Il2CppReflectionType* t, Il2CppString* fieldName);
static void Prelink(Il2CppReflectionMethod* m);
static void PrelinkAll(Il2CppReflectionType* c);
static Il2CppString* PtrToStringAnsi_mscorlib_System_String_mscorlib_System_IntPtr(intptr_t ptr);
static Il2CppString* PtrToStringAnsi_mscorlib_System_String_mscorlib_System_IntPtr_mscorlib_System_Int32(intptr_t ptr, int32_t len);
static Il2CppString* PtrToStringBSTR(intptr_t ptr);
static Il2CppString* PtrToStringUni_mscorlib_System_String_mscorlib_System_IntPtr(intptr_t ptr);
static Il2CppString* PtrToStringUni_mscorlib_System_String_mscorlib_System_IntPtr_mscorlib_System_Int32(intptr_t ptr, int32_t len);
static Il2CppObject* PtrToStructure(intptr_t ptr, Il2CppReflectionType * structureType);
static void PtrToStructureObject(intptr_t ptr, Il2CppObject* structure);
static int32_t QueryInterfaceInternal(intptr_t pUnk, mscorlib_System_Guid * iid, intptr_t* ppv);
static intptr_t ReAllocCoTaskMem(intptr_t ptr, int32_t size);
static intptr_t ReAllocHGlobal(intptr_t ptr, intptr_t size);
static uint8_t ReadByte(intptr_t ptr, int32_t ofs);
static int16_t ReadInt16(intptr_t ptr, int32_t ofs);
static int32_t ReadInt32(intptr_t ptr, int32_t ofs);
static int64_t ReadInt64(intptr_t ptr, int32_t ofs);
static intptr_t ReadIntPtr(intptr_t ptr, int32_t ofs);
static int32_t ReleaseComObjectInternal(Il2CppObject* co);
static int32_t ReleaseInternal(intptr_t pUnk);
static int SizeOf(Il2CppReflectionType * rtype);
static intptr_t StringToBSTR(Il2CppString* s);
static intptr_t StringToHGlobalAnsi(Il2CppChar* s, int32_t length);
static intptr_t StringToHGlobalUni(Il2CppChar* s, int32_t length);
static void StructureToPtr(Il2CppObject* structure, intptr_t ptr, bool deleteOld);
static intptr_t UnsafeAddrOfPinnedArrayElement(Il2CppArray* arr, int32_t index);
static void WriteByte(intptr_t ptr, int32_t ofs, uint8_t val);
static void WriteInt16(intptr_t ptr, int32_t ofs, int16_t val);
static void WriteInt32(intptr_t ptr, int32_t ofs, int32_t val);
static void WriteInt64(intptr_t ptr, int32_t ofs, int64_t val);
static void copy_from_unmanaged(intptr_t, int, Il2CppArray *, int);
static void copy_to_unmanaged(Il2CppArray * source, int32_t startIndex, intptr_t destination, int32_t length);
static void WriteIntPtr(intptr_t ptr, int32_t ofs, intptr_t val);
static intptr_t BufferToBSTR(Il2CppChar* ptr, int32_t slen);
static int32_t GetHRForException_WinRT(Il2CppException* e);
static intptr_t GetRawIUnknownForComObjectNoAddRef(Il2CppObject* o);
static Il2CppObject* GetNativeActivationFactory(Il2CppObject* type);
static intptr_t AllocCoTaskMemSize(intptr_t sizet);
static void copy_from_unmanaged_fixed(intptr_t source, int32_t startIndex, Il2CppArray* destination, int32_t length, void* fixed_destination_element);
static void copy_to_unmanaged_fixed(Il2CppArray* source, int32_t startIndex, intptr_t destination, int32_t length, void* fixed_source_element);
};
} /* namespace InteropServices */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

26
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices/RuntimeInformation.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace InteropServices
{
class LIBIL2CPP_CODEGEN_API RuntimeInformation
{
public:
static Il2CppString* GetOSName();
static Il2CppString* GetRuntimeArchitecture();
};
} // namespace InteropServices
} // namespace Runtime
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

33
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Activation/ActivationServices.h Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#include "il2cpp-config.h"
struct Il2CppObject;
struct Il2CppReflectionType;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Activation
{
class LIBIL2CPP_CODEGEN_API ActivationServices
{
public:
static void EnableProxyActivation(Il2CppReflectionType*, bool);
static Il2CppObject * AllocateUninitializedClassInstance(Il2CppReflectionType*);
};
} /* namespace Activation */
} /* namespace Remoting */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

29
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Contexts/Context.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Contexts
{
class LIBIL2CPP_CODEGEN_API Context
{
public:
static void RegisterContext(Il2CppObject* ctx);
static void ReleaseContext(Il2CppObject* ctx);
};
} // namespace Contexts
} // namespace Remoting
} // namespace Runtime
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

28
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Messaging/AsyncResult.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Messaging
{
class LIBIL2CPP_CODEGEN_API AsyncResult
{
public:
static Il2CppObject* Invoke(Il2CppObject* _this);
};
} // namespace Messaging
} // namespace Remoting
} // namespace Runtime
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

33
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Messaging/MonoMethodMessage.h Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppMethodMessage;
struct Il2CppReflectionMethod;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Messaging
{
class LIBIL2CPP_CODEGEN_API MonoMethodMessage
{
public:
static void InitMessage(Il2CppMethodMessage*, Il2CppReflectionMethod*, Il2CppArray*);
};
} /* namespace Messaging */
} /* namespace Remoting */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

34
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Proxies/RealProxy.h Normal file
View File

@@ -0,0 +1,34 @@
#pragma once
#include "il2cpp-config.h"
struct Il2CppObject;
struct Il2CppReflectionType;
struct Il2CppString;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Proxies
{
class LIBIL2CPP_CODEGEN_API RealProxy
{
public:
static Il2CppObject* InternalGetTransparentProxy(Il2CppObject*, Il2CppString*);
static Il2CppReflectionType* InternalGetProxyType(Il2CppObject*);
};
} /* namespace Proxies */
} /* namespace Remoting */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

32
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting/RemotingServices.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppObject;
struct Il2CppReflectionMethod;
struct Il2CppReflectionType;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
class LIBIL2CPP_CODEGEN_API RemotingServices
{
public:
static Il2CppReflectionMethod * GetVirtualMethod(Il2CppReflectionType*, Il2CppReflectionMethod*);
static Il2CppObject* InternalExecute(Il2CppReflectionMethod*, Il2CppObject*, Il2CppArray*, Il2CppArray**);
};
} /* namespace Remoting */
} /* namespace Runtime */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

25
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Versioning/VersioningHelper.h Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Versioning
{
class LIBIL2CPP_CODEGEN_API VersioningHelper
{
public:
static int32_t GetRuntimeId();
};
} // namespace Versioning
} // namespace Runtime
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

27
Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime/RuntimeImports.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Runtime
{
class LIBIL2CPP_CODEGEN_API RuntimeImports
{
public:
static void ecvt_s(char* buffer, int32_t sizeInBytes, double value, int32_t count, int32_t* dec, int32_t* sign);
static void Memmove(uint8_t* dest, uint8_t* src, uint32_t len);
static void Memmove_wbarrier(uint8_t* dest, uint8_t* src, uint32_t len, intptr_t type_handle);
static void ZeroMemory(void* p, uint32_t byteLength);
};
} // namespace Runtime
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

31
Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Cryptography/RNGCryptoServiceProvider.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Security
{
namespace Cryptography
{
class LIBIL2CPP_CODEGEN_API RNGCryptoServiceProvider
{
public:
static bool RngOpen();
static intptr_t RngGetBytes(intptr_t handle, uint8_t* data, intptr_t data_length);
static intptr_t RngInitialize(uint8_t* seed, intptr_t seed_length);
static void RngClose(intptr_t handle);
};
} /* namespace Cryptography */
} /* namespace Security */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

41
Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Policy/Evidence.h Normal file
View File

@@ -0,0 +1,41 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Security
{
namespace Policy
{
class LIBIL2CPP_CODEGEN_API Evidence
{
public:
static bool IsAuthenticodePresent(Il2CppAssembly* a);
};
} /* namespace Policy */
} /* namespace Security */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

33
Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsIdentity.h Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppString;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Security
{
namespace Principal
{
class LIBIL2CPP_CODEGEN_API WindowsIdentity
{
public:
static intptr_t GetCurrentToken();
static intptr_t GetUserToken(Il2CppString* username);
static Il2CppString* GetTokenName(intptr_t token);
static Il2CppArray* _GetRoles(intptr_t token);
};
} /* namespace Principal */
} /* namespace Security */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

44
Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsImpersonationContext.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Security
{
namespace Principal
{
class LIBIL2CPP_CODEGEN_API WindowsImpersonationContext
{
public:
static bool CloseToken(intptr_t token);
static bool RevertToSelf();
static bool SetCurrentToken(intptr_t token);
static intptr_t DuplicateToken(intptr_t token);
};
} /* namespace Principal */
} /* namespace Security */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

42
Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsPrincipal.h Normal file
View File

@@ -0,0 +1,42 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Security
{
namespace Principal
{
class LIBIL2CPP_CODEGEN_API WindowsPrincipal
{
public:
static bool IsMemberOfGroupId(intptr_t user, intptr_t group);
static bool IsMemberOfGroupName(intptr_t user, intptr_t group);
};
} /* namespace Principal */
} /* namespace Security */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

22
Libraries/libil2cpp/include/icalls/mscorlib/System.Text/EncodingHelper.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Text
{
class LIBIL2CPP_CODEGEN_API EncodingHelper
{
public:
static Il2CppString* InternalCodePage(int32_t* code_page);
};
} // namespace Text
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

23
Libraries/libil2cpp/include/icalls/mscorlib/System.Text/Normalization.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Text
{
class LIBIL2CPP_CODEGEN_API Normalization
{
public:
static void load_normalization_resource(intptr_t* props, intptr_t* mappedChars, intptr_t* charMapIndex, intptr_t* helperIndex, intptr_t* mapIdxToComposite, intptr_t* combiningClass);
};
} // namespace Text
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

25
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/InternalThread.h Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
#include "il2cpp-object-internals.h"
struct Il2CppInternalThread;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API InternalThread
{
public:
static void Thread_free_internal(Il2CppInternalThread* _this);
};
} // namespace Threading
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

33
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Monitor.h Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppObject;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API Monitor
{
public:
static bool Monitor_test_owner(Il2CppObject* obj);
static bool Monitor_test_synchronised(Il2CppObject* obj);
static bool Monitor_wait(Il2CppObject* obj, int32_t ms);
static void Enter(Il2CppObject* obj);
static void Exit(Il2CppObject* obj);
static void Monitor_pulse(Il2CppObject* obj);
static void Monitor_pulse_all(Il2CppObject* obj);
static void try_enter_with_atomic_var(Il2CppObject* obj, int32_t millisecondsTimeout, bool* lockTaken);
};
} /* namespace Threading */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

34
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Mutex.h Normal file
View File

@@ -0,0 +1,34 @@
#pragma once
#include <stdint.h>
#include "il2cpp-object-internals.h"
#include "il2cpp-config.h"
struct Il2CppString;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
struct MonoIOError;
typedef int32_t MutexRights;
class LIBIL2CPP_CODEGEN_API Mutex
{
public:
static bool ReleaseMutex_internal(intptr_t handle);
static intptr_t CreateMutex_icall(bool initiallyOwned, Il2CppChar* name, int32_t name_length, bool* created);
static intptr_t OpenMutex_icall(Il2CppChar* name, int32_t name_length, int32_t rights, int32_t* error);
};
} /* namespace Threading */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

35
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/NativeEventCalls.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <stdint.h>
#include "il2cpp-object-internals.h"
#include "il2cpp-config.h"
struct Il2CppString;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
struct MonoIOError;
typedef int32_t EventWaitHandleRights;
class LIBIL2CPP_CODEGEN_API NativeEventCalls
{
public:
static bool ResetEvent_internal(intptr_t handle);
static bool SetEvent_internal(intptr_t handle);
static intptr_t CreateEvent_icall(bool manual, bool initial, Il2CppChar* name, int32_t name_length, int32_t* errorCode);
static void CloseEvent_internal(intptr_t handle);
};
} /* namespace Threading */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

23
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/OSSpecificSynchronizationContext.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API OSSpecificSynchronizationContext
{
public:
static Il2CppObject* GetOSContext();
static void PostInternal(Il2CppObject* context, SynchronizationContextCallback callback, intptr_t arg);
};
}
}
}
}
}

73
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Thread.h Normal file
View File

@@ -0,0 +1,73 @@
#pragma once
#include <stdint.h>
#include "il2cpp-object-internals.h"
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppThread;
struct mscorlib_System_Globalization_CultureInfo;
struct Il2CppDelegate;
struct mscorlib_System_Threading_Thread;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API Thread
{
public:
static bool JoinInternal(Il2CppThread* thisPtr, int32_t millisecondsTimeout);
static bool Thread_internal(Il2CppThread* thisPtr, Il2CppDelegate* start);
static bool YieldInternal();
static Il2CppArray* ByteArrayToCurrentDomain(Il2CppArray* arr);
static Il2CppArray* ByteArrayToRootDomain(Il2CppArray* arr);
static int32_t GetDomainID();
static int32_t GetPriorityNative(Il2CppThread* thisPtr);
static int32_t SystemMaxStackStize();
static int8_t VolatileRead_1(volatile void* address);
static double VolatileRead_Double(volatile double* address);
static int16_t VolatileRead_2(volatile void* address);
static int32_t VolatileRead_4(volatile void* address);
static int64_t VolatileRead_8(volatile void* address);
static intptr_t VolatileRead_IntPtr(volatile void* address);
static Il2CppObject* VolatileRead_Object(volatile void* address);
static float VolatileRead_Float(volatile float* address);
static Il2CppObject* GetAbortExceptionState(Il2CppThread* thisPtr);
static Il2CppString* GetName_internal(Il2CppInternalThread* thread);
static int32_t GetState(Il2CppInternalThread* thread);
static void Abort_internal(Il2CppInternalThread* thread, Il2CppObject* stateInfo);
static void ClrState(Il2CppInternalThread* thread, int32_t clr);
static void ConstructInternalThread(Il2CppThread* thisPtr);
static void GetCurrentThread_icall(volatile Il2CppThread** thread);
static void GetStackTraces(Il2CppArray** threads, Il2CppArray** stack_frames);
static void InterruptInternal(Il2CppThread* thisPtr);
static void MemoryBarrier();
static void ResetAbortNative(Il2CppThread* thisPtr);
static void ResumeInternal(Il2CppThread* thisPtr);
static void SetName_icall(Il2CppInternalThread* thread, Il2CppChar* name, int32_t nameLength);
static void SetPriorityNative(Il2CppThread* thisPtr, int32_t priority);
static void SetState(Il2CppInternalThread* thread, int32_t set);
static void SleepInternal(int32_t millisecondsTimeout);
static void SpinWait_nop();
static void SuspendInternal(Il2CppThread* thisPtr);
static void VolatileWrite_1(volatile void* address, int8_t value);
static void VolatileWrite_Double(volatile void* address, double value);
static void VolatileWrite_Float(volatile void* address, float value);
static void VolatileWrite_2(volatile void* address, int16_t value);
static void VolatileWrite_4(volatile void* address, int32_t value);
static void VolatileWrite_8(volatile void* address, int64_t value);
static void VolatileWrite_IntPtr(volatile void* address, intptr_t value);
static void VolatileWrite_Object(volatile void* address, Il2CppObject* value);
};
} /* namespace Threading */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

22
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Timer.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API Timer
{
public:
static int64_t GetTimeMonotonic();
};
} // namespace Threading
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

25
Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/WaitHandle.h Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Threading
{
class LIBIL2CPP_CODEGEN_API WaitHandle
{
public:
static int32_t SignalAndWait_Internal(intptr_t toSignal, intptr_t toWaitOn, int32_t ms);
static int32_t Wait_internal(intptr_t* handles, int32_t numHandles, bool waitAll, int32_t ms);
};
} /* namespace Threading */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

59
Libraries/libil2cpp/include/icalls/mscorlib/System/AppDomain.h Normal file
View File

@@ -0,0 +1,59 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct mscorlib_System_AppDomain;
struct mscorlib_System_AppDomainSetup;
struct mscorlib_System_Runtime_Remoting_Contexts_Context;
struct mscorlib_System_Security_Policy_Evidence;
struct mscorlib_System_Reflection_Assembly;
struct Il2CppObject;
struct Il2CppString;
struct Il2CppArray;
struct Il2CppAssembly;
struct Il2CppAppDomain;
struct Il2CppAppDomainSetup;
struct Il2CppReflectionAssembly;
struct Il2CppAppContext;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API AppDomain
{
public:
static Il2CppObject* createDomain(Il2CppString* friendlyName, Il2CppObject* info);
static Il2CppAppDomain* getCurDomain();
static Il2CppAppDomain* getRootDomain();
static Il2CppObject* InternalSetDomain(Il2CppObject* context);
static Il2CppObject* InternalSetDomainByID(int32_t domain_id);
static Il2CppAppDomainSetup* getSetup(Il2CppAppDomain* thisPtr);
static bool InternalIsFinalizingForUnload(int32_t domain_id);
static int32_t ExecuteAssembly(Il2CppObject* thisPtr, Il2CppObject* a, Il2CppArray* args);
static Il2CppObject* GetData(Il2CppAppDomain* thisPtr, Il2CppString* name);
static Il2CppReflectionAssembly* LoadAssembly(Il2CppAppDomain* thisPtr, Il2CppString* assemblyRef, Il2CppObject* securityEvidence, bool refOnly, int32_t* stackMark);
static Il2CppObject* LoadAssemblyRaw(Il2CppObject* thisPtr, Il2CppArray* rawAssembly, Il2CppArray* rawSymbolStore, Il2CppObject* securityEvidence, bool refonly);
static Il2CppArray* GetAssemblies(Il2CppObject* thisPtr, bool refOnly);
static Il2CppAppContext* InternalGetContext();
static Il2CppAppContext* InternalGetDefaultContext();
static Il2CppObject* InternalSetContext(Il2CppObject* context);
static Il2CppString* getFriendlyName(Il2CppAppDomain* thisPtr);
static Il2CppString* InternalGetProcessGuid(Il2CppString* newguid);
static void DoUnhandledException(Il2CppObject* thisPtr, Il2CppException* e);
static void InternalPopDomainRef();
static void InternalPushDomainRef(Il2CppObject* domain);
static void InternalPushDomainRefByID(int32_t domain_id);
static void InternalUnload(int32_t domain_id);
static void SetData(Il2CppAppDomain* thisPtr, Il2CppString* name, Il2CppObject* data);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

28
Libraries/libil2cpp/include/icalls/mscorlib/System/ArgIterator.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct mscorlib_System_ArgIterator;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API ArgIterator
{
public:
static intptr_t IntGetNextArgType(mscorlib_System_ArgIterator* thisPtr);
static void IntGetNextArg(mscorlib_System_ArgIterator* thisPtr, void* res);
static void IntGetNextArgWithType(mscorlib_System_ArgIterator* thisPtr, void* res, intptr_t rth);
static void Setup(mscorlib_System_ArgIterator* thisPtr, intptr_t argsp, intptr_t start);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

34
Libraries/libil2cpp/include/icalls/mscorlib/System/Array.h Normal file
View File

@@ -0,0 +1,34 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppReflectionType;
struct Il2CppObject;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Array
{
public:
static Il2CppArray* CreateInstanceImpl(Il2CppReflectionType* elementType, Il2CppArray* lengths, Il2CppArray* bounds);
static bool FastCopy(Il2CppArray* source, int32_t source_idx, Il2CppArray* dest, int32_t dest_idx, int32_t length);
static int32_t GetLength(Il2CppArray* thisPtr, int32_t dimension);
static int32_t GetLowerBound(Il2CppArray* thisPtr, int32_t dimension);
static int32_t GetRank(Il2CppArray* arr);
static Il2CppObject* GetValue(Il2CppArray* thisPtr, Il2CppArray* indices);
static Il2CppObject* GetValueImpl(Il2CppArray* thisPtr, int32_t pos);
static void ClearInternal(Il2CppArray* arr, int32_t index, int32_t count);
static void SetValue(Il2CppArray* thisPtr, Il2CppObject* value, Il2CppArray* indices);
static void SetValueImpl(Il2CppArray* thisPtr, Il2CppObject* value, int32_t pos);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

27
Libraries/libil2cpp/include/icalls/mscorlib/System/Buffer.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppArray;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Buffer
{
public:
static bool InternalBlockCopy(Il2CppArray* src, int32_t srcOffsetBytes, Il2CppArray* dst, int32_t dstOffsetBytes, int32_t byteCount);
static int32_t _ByteLength(Il2CppArray* array);
static void InternalMemcpy(uint8_t* dest, uint8_t* src, int32_t count);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

19
Libraries/libil2cpp/include/icalls/mscorlib/System/CLRConfig.h Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API CLRConfig
{
public:
static bool CheckThrowUnobservedTaskExceptions();
};
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

39
Libraries/libil2cpp/include/icalls/mscorlib/System/ConsoleDriver.h Normal file
View File

@@ -0,0 +1,39 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API ConsoleDriver
{
public:
static int32_t InternalKeyAvailable(int32_t ms_timeout);
static bool SetBreak(bool wantBreak);
static bool SetEcho(bool wantEcho);
static bool TtySetup(Il2CppString* keypadXmit, Il2CppString* teardown, Il2CppArray** control_characters, int32_t** size);
static bool Isatty(intptr_t handle);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

24
Libraries/libil2cpp/include/icalls/mscorlib/System/CurrentSystemTimeZone.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppArray;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API CurrentSystemTimeZone
{
public:
static bool GetTimeZoneData40(int year, Il2CppArray * *, Il2CppArray * *, bool * daylight_inverted);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

19
Libraries/libil2cpp/include/icalls/mscorlib/System/DateTime.h Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API DateTime
{
public:
static int64_t GetSystemTimeAsFileTime();
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

32
Libraries/libil2cpp/include/icalls/mscorlib/System/Delegate.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppObject;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppDelegate;
struct Il2CppMulticastDelegate;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Delegate
{
public:
static Il2CppDelegate * CreateDelegate_internal(Il2CppReflectionType *, Il2CppObject *, Il2CppReflectionMethod *, bool);
static void SetMulticastInvoke(Il2CppDelegate *);
static Il2CppMulticastDelegate* AllocDelegateLike_internal(Il2CppDelegate* d);
static Il2CppReflectionMethod* GetVirtualMethod_internal(Il2CppDelegate* _this);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

28
Libraries/libil2cpp/include/icalls/mscorlib/System/Enum.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Enum
{
public:
static bool GetEnumValuesAndNames(Il2CppReflectionRuntimeType* enumType, Il2CppArray** values, Il2CppArray** names);
static bool InternalHasFlag(Il2CppObject* thisPtr, Il2CppObject* flags);
static int32_t get_hashcode(Il2CppObject* thisPtr);
static int32_t InternalCompareTo(Il2CppObject* o1, Il2CppObject* o2);
static Il2CppObject* get_value(Il2CppObject* thisPtr);
static Il2CppObject* InternalBoxEnum(Il2CppReflectionRuntimeType* enumType, int64_t value);
static Il2CppReflectionRuntimeType* InternalGetUnderlyingType(Il2CppReflectionRuntimeType* enumType);
#if IL2CPP_TINY
static bool TinyEnumEquals(Il2CppObject* left, Il2CppObject* right);
#endif
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

51
Libraries/libil2cpp/include/icalls/mscorlib/System/Environment.h Normal file
View File

@@ -0,0 +1,51 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppArray;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Environment
{
public:
static bool get_HasShutdownStarted();
static bool GetIs64BitOperatingSystem();
static int32_t get_ExitCode();
static int32_t get_ProcessorCount();
static int32_t get_TickCount();
static int32_t GetPageSize();
static int32_t get_Platform();
static Il2CppString* get_bundled_machine_config();
static Il2CppString* get_MachineName();
static Il2CppString* get_UserName();
static Il2CppString* GetMachineConfigPath();
static Il2CppString* GetNewLine();
static Il2CppString* GetOSVersionString();
static Il2CppString* GetWindowsFolderPath(int32_t folder);
static Il2CppString* internalGetEnvironmentVariable_native(intptr_t variable);
static Il2CppString* internalGetHome();
static Il2CppArray* GetCommandLineArgs();
static Il2CppArray* GetEnvironmentVariableNames();
static Il2CppArray* GetLogicalDrivesInternal();
static void Exit(int32_t exitCode);
static void FailFast(Il2CppString* message, Il2CppException* exception, Il2CppString* errorSource);
static void InternalSetEnvironmentVariable(Il2CppChar* variable, int32_t variable_length, Il2CppChar* value, int32_t value_length);
static void set_ExitCode(int32_t value);
#if IL2CPP_TINY
static Il2CppString* GetStackTrace_internal();
static void FailFast_internal(Il2CppString* message);
#endif
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

19
Libraries/libil2cpp/include/icalls/mscorlib/System/Exception.h Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Exception
{
public:
static void ReportUnhandledException(Il2CppException* exception);
};
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

35
Libraries/libil2cpp/include/icalls/mscorlib/System/GC.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppObject;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API GC
{
public:
static int32_t GetCollectionCount(int32_t generation);
static int32_t GetGeneration(Il2CppObject* obj);
static int32_t GetMaxGeneration();
static int64_t GetAllocatedBytesForCurrentThread();
static int64_t GetTotalMemory(bool forceFullCollection);
static Il2CppObject* get_ephemeron_tombstone();
static void _ReRegisterForFinalize(Il2CppObject* o);
static void _SuppressFinalize(Il2CppObject* o);
static void InternalCollect(int32_t generation);
static void RecordPressure(int64_t bytesAllocated);
static void register_ephemeron_array(Il2CppArray* array);
static void WaitForPendingFinalizers();
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

28
Libraries/libil2cpp/include/icalls/mscorlib/System/MonoCustomAttrs.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppObject;
struct Il2CppReflectionType;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API MonoCustomAttrs
{
public:
static Il2CppArray* GetCustomAttributesDataInternal(Il2CppObject* obj);
static Il2CppArray * GetCustomAttributesInternal(Il2CppObject* obj, Il2CppReflectionType* type, bool pseudoAttrs);
static bool IsDefinedInternal(Il2CppObject *obj, Il2CppReflectionType *attr_type);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

27
Libraries/libil2cpp/include/icalls/mscorlib/System/NumberFormatter.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API NumberFormatter
{
public:
static void GetFormatterTables(uint64_t * * mantissas,
int32_t * * exponents,
int16_t * * digitLowerTable,
int16_t * * digitUpperTable,
int64_t * * tenPowersList,
int32_t * * decHexDigits);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

27
Libraries/libil2cpp/include/icalls/mscorlib/System/Object.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppObject;
struct Il2CppReflectionType;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Object
{
public:
static int InternalGetHashCode(Il2CppObject* obj);
static Il2CppObject* MemberwiseClone(Il2CppObject* obj);
static Il2CppReflectionType* GetType(Il2CppObject* obj);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

22
Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeFieldHandle.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API RuntimeFieldHandle
{
public:
static Il2CppObject* GetValueDirect(Il2CppObject* field, Il2CppReflectionRuntimeType* fieldType, void* pTypedRef, Il2CppReflectionRuntimeType* contextType);
static void SetValueDirect(Il2CppReflectionField* field, Il2CppObject* fieldType, Il2CppTypedRef* typedRef, Il2CppObject* value, Il2CppObject* contextType);
static void SetValueInternal(Il2CppReflectionField* fi, Il2CppObject* obj, Il2CppObject* value);
};
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

35
Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeMethodHandle.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <stdint.h>
#include "il2cpp-object-internals.h"
#include "il2cpp-config.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API RuntimeMethodHandle
{
public:
static intptr_t GetFunctionPointer(intptr_t m);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

77
Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeType.h Normal file
View File

@@ -0,0 +1,77 @@
#pragma once
struct Il2CppReflectionRuntimeType;
struct mscorlib_System_Reflection_MethodInfo;
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
enum
{
BFLAGS_IgnoreCase = 1,
BFLAGS_DeclaredOnly = 2,
BFLAGS_Instance = 4,
BFLAGS_Static = 8,
BFLAGS_Public = 0x10,
BFLAGS_NonPublic = 0x20,
BFLAGS_FlattenHierarchy = 0x40,
BFLAGS_InvokeMethod = 0x100,
BFLAGS_CreateInstance = 0x200,
BFLAGS_GetField = 0x400,
BFLAGS_SetField = 0x800,
BFLAGS_GetProperty = 0x1000,
BFLAGS_SetProperty = 0x2000,
BFLAGS_ExactBinding = 0x10000,
BFLAGS_SuppressChangeType = 0x20000,
BFLAGS_OptionalParamBinding = 0x40000,
BFLAGS_MatchAll = 0xFFFFF
};
enum
{
MLISTTYPE_All = 0,
MLISTTYPE_CaseSensitive = 1,
MLISTTYPE_CaseInsensitive = 2,
MLISTTYPE_HandleToInfo = 3
};
class LIBIL2CPP_CODEGEN_API RuntimeType
{
public:
static int32_t GetGenericParameterPosition(Il2CppReflectionRuntimeType* thisPtr);
static intptr_t GetConstructors_native(Il2CppReflectionRuntimeType* thisPtr, int32_t bindingAttr);
static intptr_t GetEvents_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t listType);
static intptr_t GetFields_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr, int32_t listType);
static intptr_t GetMethodsByName_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t namePtr, int32_t bindingAttr, int32_t listType);
static intptr_t GetNestedTypes_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr, int32_t listType);
static intptr_t GetPropertiesByName_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr, int32_t listType);
static Il2CppObject* CreateInstanceInternal(Il2CppReflectionType* type);
static Il2CppObject* GetCorrespondingInflatedConstructor(Il2CppReflectionRuntimeType* thisPtr, Il2CppObject* generic);
static Il2CppObject* get_DeclaringMethod(Il2CppReflectionRuntimeType* thisPtr);
static Il2CppObject* GetCorrespondingInflatedMethod(Il2CppReflectionRuntimeType* thisPtr, Il2CppObject* generic);
static Il2CppString* get_Name(Il2CppReflectionRuntimeType* thisPtr);
static Il2CppString* get_Namespace(Il2CppReflectionRuntimeType* thisPtr);
static Il2CppString* getFullName(Il2CppReflectionRuntimeType* thisPtr, bool full_name, bool assembly_qualified);
static Il2CppReflectionType* get_DeclaringType(Il2CppReflectionRuntimeType* thisPtr);
static Il2CppReflectionType* make_array_type(Il2CppReflectionRuntimeType* thisPtr, int32_t rank);
static Il2CppReflectionType* make_byref_type(Il2CppReflectionRuntimeType* thisPtr);
static Il2CppReflectionType* MakeGenericType(Il2CppReflectionType* type, Il2CppArray* types);
static Il2CppReflectionType* MakePointerType(Il2CppReflectionType* type);
static Il2CppArray* GetGenericArgumentsInternal(Il2CppReflectionRuntimeType* thisPtr, bool runtimeArray);
static Il2CppArray* GetInterfaces(Il2CppReflectionRuntimeType* thisPtr);
static int32_t GetTypeCodeImplInternal(Il2CppReflectionType* type);
static void GetInterfaceMapData(Il2CppReflectionType* type, Il2CppReflectionType* iface, Il2CppArray** targets, Il2CppArray** methods);
static void GetPacking(Il2CppReflectionType* type, int32_t* packing, int32_t* size);
static void GetGUID(Il2CppReflectionType* type, Il2CppArray* types);
};
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

40
Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeTypeHandle.h Normal file
View File

@@ -0,0 +1,40 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API RuntimeTypeHandle
{
public:
static bool HasInstantiation(Il2CppReflectionRuntimeType* type);
static bool HasReferences(Il2CppReflectionRuntimeType* type);
static bool is_subclass_of(Il2CppType* childType, Il2CppType* baseType);
static bool IsByRefLike(Il2CppReflectionRuntimeType* type);
static bool IsComObject(Il2CppReflectionRuntimeType* type);
static bool IsGenericTypeDefinition(Il2CppReflectionRuntimeType* type);
static bool IsGenericVariable(Il2CppReflectionRuntimeType* type);
static bool IsInstanceOfType(Il2CppReflectionRuntimeType* type, Il2CppObject* o);
static bool type_is_assignable_from(Il2CppReflectionType* a, Il2CppReflectionType* b);
static int32_t GetArrayRank(Il2CppReflectionRuntimeType* type);
static int32_t GetMetadataToken(Il2CppReflectionRuntimeType* type);
static intptr_t GetGenericParameterInfo(Il2CppReflectionRuntimeType* type);
static uint8_t GetCorElementType(Il2CppReflectionRuntimeType* type);
static Il2CppReflectionAssembly* GetAssembly(Il2CppReflectionRuntimeType* type);
static Il2CppReflectionModule* GetModule(Il2CppReflectionRuntimeType* type);
static int32_t GetAttributes(Il2CppReflectionRuntimeType* type);
static Il2CppReflectionRuntimeType* GetBaseType(Il2CppReflectionRuntimeType* type);
static Il2CppReflectionRuntimeType* GetElementType(Il2CppReflectionRuntimeType* type);
static Il2CppReflectionType* internal_from_name(Il2CppString* name, int32_t* stackMark, Il2CppObject* callerAssembly, bool throwOnError, bool ignoreCase, bool reflectionOnly);
static Il2CppReflectionType* GetGenericTypeDefinition_impl(Il2CppReflectionRuntimeType* type);
};
} // namespace System
} // namespace mscorlib
} // namespace icalls
} // namespace il2cpp

28
Libraries/libil2cpp/include/icalls/mscorlib/System/String.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppString;
struct Il2CppArray;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API String
{
public:
static Il2CppString* FastAllocateString(int32_t length);
static Il2CppString* InternalIntern(Il2CppString* str);
static Il2CppString* InternalIsInterned(Il2CppString* str);
static void RedirectToCreateString();
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

21
Libraries/libil2cpp/include/icalls/mscorlib/System/Type.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include "il2cpp-object-internals.h"
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API Type
{
public:
static Il2CppReflectionType* internal_from_handle(intptr_t ptr);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

36
Libraries/libil2cpp/include/icalls/mscorlib/System/TypedReference.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
struct Il2CppObject;
struct Il2CppDelegate;
struct Il2CppReflectionType;
struct Il2CppReflectionMethod;
struct Il2CppReflectionField;
struct Il2CppArray;
struct Il2CppException;
struct Il2CppReflectionModule;
struct Il2CppAssembly;
struct Il2CppAssemblyName;
struct Il2CppAppDomain;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API TypedReference
{
public:
static Il2CppObject* InternalToObject(Il2CppTypedRef* value);
static void InternalMakeTypedReference(Il2CppTypedRef* res, Il2CppObject* target, Il2CppArray* flds, Il2CppReflectionRuntimeType* lastFieldType);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

26
Libraries/libil2cpp/include/icalls/mscorlib/System/ValueType.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#include <stdint.h>
#include "il2cpp-config.h"
struct Il2CppArray;
struct Il2CppObject;
namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
class LIBIL2CPP_CODEGEN_API ValueType
{
public:
static bool InternalEquals(Il2CppObject * thisPtr, Il2CppObject * that, Il2CppArray** fields);
static int InternalGetHashCode(Il2CppObject *, Il2CppArray * *);
};
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */