18936 lines
506 KiB
C
18936 lines
506 KiB
C
// 00114e68 _init
|
|
|
|
int _init(EVP_PKEY_CTX *ctx)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = call_gmon_start();
|
|
return iVar1;
|
|
}
|
|
|
|
|
|
// 00114e80 FUN_00114e80
|
|
|
|
void FUN_00114e80(void)
|
|
|
|
{
|
|
(*(code *)(undefined *)0x0)();
|
|
return;
|
|
}
|
|
|
|
|
|
// 00115a10 VR_ShutdownInternal.cold
|
|
|
|
void VR_ShutdownInternal_cold(void)
|
|
|
|
{
|
|
long unaff_RBX;
|
|
|
|
if (unaff_RBX != 0) {
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115ba3 VR_GetRuntimePath.cold
|
|
|
|
void VR_GetRuntimePath_cold(void)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115bf7 Path_GetWorkingDirectory
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetWorkingDirectory() [clone .cold] */
|
|
|
|
void Path_GetWorkingDirectory(void)
|
|
|
|
{
|
|
allocator *unaff_RBX;
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115c18 Path_FixSlashes
|
|
|
|
/* Path_FixSlashes(std::string const&, char) [clone .cold] */
|
|
|
|
void Path_FixSlashes(string *param_1,char param_2)
|
|
|
|
{
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115c3a Path_Join
|
|
|
|
/* Path_Join(std::string const&, std::string const&, char) [clone .cold] */
|
|
|
|
void Path_Join(string *param_1,string *param_2,char param_3)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
allocator *unaff_RBX;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x48) + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x40) + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115c84 Path_Join
|
|
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, char) [clone .cold] */
|
|
|
|
void Path_Join(string *param_1,string *param_2,string *param_3,char param_4)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x28) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115ca6 Path_Join
|
|
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, std::string const&, char)
|
|
[clone .cold] */
|
|
|
|
void Path_Join(string *param_1,string *param_2,string *param_3,string *param_4,char param_5)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x40) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115ce0 Path_Join
|
|
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, std::string const&,
|
|
std::string const&, char) [clone .cold] */
|
|
|
|
void Path_Join(string *param_1,string *param_2,string *param_3,string *param_4,string *param_5,
|
|
char param_6)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x40) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x48) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115d30 Path_RemoveTrailingSlash
|
|
|
|
/* Path_RemoveTrailingSlash(std::string const&, char) [clone .cold] */
|
|
|
|
void Path_RemoveTrailingSlash(string *param_1,char param_2)
|
|
|
|
{
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115d52 Path_Compact
|
|
|
|
/* Path_Compact(std::string const&, char) [clone .cold] */
|
|
|
|
void Path_Compact(string *param_1,char param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x40) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115d8d Path_MakeAbsolute
|
|
|
|
/* Path_MakeAbsolute(std::string const&, std::string const&) [clone .cold] */
|
|
|
|
void Path_MakeAbsolute(string *param_1,string *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x28) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115dcc Path_IsSamePath
|
|
|
|
/* Path_IsSamePath(std::string const&, std::string const&) [clone .cold] */
|
|
|
|
void Path_IsSamePath(string *param_1,string *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x30) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115dee Path_IsDirectory
|
|
|
|
/* Path_IsDirectory(std::string const&) [clone .cold] */
|
|
|
|
void Path_IsDirectory(string *param_1)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0xb8) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115e16 Path_WriteStringToTextFileAtomic
|
|
|
|
/* Path_WriteStringToTextFileAtomic(std::string const&, char const*) [clone .cold] */
|
|
|
|
void Path_WriteStringToTextFileAtomic(string *param_1,char *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x28) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115e5a Path_FilePathToUrl
|
|
|
|
/* Path_FilePathToUrl(std::string const&, std::string const&) [clone .cold] */
|
|
|
|
void Path_FilePathToUrl(string *param_1,string *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x40) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x48) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x50) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x58) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115f19 Path_UrlToFilePath
|
|
|
|
/* Path_UrlToFilePath(std::string const&) [clone .cold] */
|
|
|
|
void Path_UrlToFilePath(string *param_1)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x30) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115f3b Path_SanitizeFilename
|
|
|
|
/* Path_SanitizeFilename(std::string const&) [clone .cold] */
|
|
|
|
void Path_SanitizeFilename(string *param_1)
|
|
|
|
{
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115f5d Path_ReadBinaryFile
|
|
|
|
/* Path_ReadBinaryFile(std::string const&) [clone .cold] */
|
|
|
|
void Path_ReadBinaryFile(string *param_1)
|
|
|
|
{
|
|
undefined8 *unaff_R12;
|
|
|
|
if ((void *)*unaff_R12 != (void *)0x0) {
|
|
operator_delete((void *)*unaff_R12);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115f73 Path_FindParentSubDirectoryRecursively
|
|
|
|
/* Path_FindParentSubDirectoryRecursively(std::string const&, std::string const&) [clone .cold] */
|
|
|
|
void Path_FindParentSubDirectoryRecursively(string *param_1,string *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
allocator *unaff_R13;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x48) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x50) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00115fbc Path_FindParentDirectoryRecursively
|
|
|
|
/* Path_FindParentDirectoryRecursively(std::string const&, std::string const&) [clone .cold] */
|
|
|
|
void Path_FindParentDirectoryRecursively(string *param_1,string *param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
allocator *unaff_R13;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x48) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x50) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x58) + -0x18);
|
|
if (paVar1 != unaff_R13) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011602d UTF16to8
|
|
|
|
/* UTF16to8(wchar_t const*) [clone .cold] */
|
|
|
|
void UTF16to8(wchar_t *param_1)
|
|
|
|
{
|
|
void *unaff_R12;
|
|
|
|
operator_delete(unaff_R12,0x28);
|
|
__cxa_guard_abort(&UTF16to8(wchar_t_const*)::s_converter);
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011608c UTF8to16
|
|
|
|
/* UTF8to16(char const*) [clone .cold] */
|
|
|
|
void UTF8to16(char *param_1)
|
|
|
|
{
|
|
void *unaff_R12;
|
|
|
|
operator_delete(unaff_R12,0x28);
|
|
__cxa_guard_abort(&UTF8to16(char_const*)::s_converter);
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011610f StringToUpper
|
|
|
|
/* StringToUpper(std::string const&) [clone .cold] */
|
|
|
|
void StringToUpper(string *param_1)
|
|
|
|
{
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00116131 StringToLower
|
|
|
|
/* StringToLower(std::string const&) [clone .cold] */
|
|
|
|
void StringToLower(string *param_1)
|
|
|
|
{
|
|
long *unaff_R12;
|
|
|
|
if ((allocator *)(*unaff_R12 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*unaff_R12 + -0x18));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00116153 V_URLEncode
|
|
|
|
/* V_URLEncode(char*, int, char const*, int) [clone .cold] */
|
|
|
|
void V_URLEncode(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
long unaff_RBP;
|
|
|
|
if (*(code **)(unaff_RBP + -0x30) != (code *)0x0) {
|
|
(**(code **)(unaff_RBP + -0x30))();
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 00116171 V_URLEncodeNoPlusForSpace
|
|
|
|
/* V_URLEncodeNoPlusForSpace(char*, int, char const*, int) [clone .cold] */
|
|
|
|
void V_URLEncodeNoPlusForSpace(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
long unaff_RBP;
|
|
|
|
if (*(code **)(unaff_RBP + -0x30) != (code *)0x0) {
|
|
(**(code **)(unaff_RBP + -0x30))();
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011618f V_URLEncodeFullPath
|
|
|
|
/* V_URLEncodeFullPath(char*, int, char const*, int) [clone .cold] */
|
|
|
|
void V_URLEncodeFullPath(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
long unaff_RBP;
|
|
|
|
if (*(code **)(unaff_RBP + -0x30) != (code *)0x0) {
|
|
(**(code **)(unaff_RBP + -0x30))();
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 001161d0 Format
|
|
|
|
/* Format(char const*, ...) [clone .cold] */
|
|
|
|
void Format(char *param_1,...)
|
|
|
|
{
|
|
long unaff_RBP;
|
|
|
|
if (*(void **)(unaff_RBP + -0x1110) != (void *)0x0) {
|
|
operator_delete(*(void **)(unaff_RBP + -0x1110));
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 001161e9 TokenizeString
|
|
|
|
/* TokenizeString(std::string const&, char) [clone .cold] */
|
|
|
|
void TokenizeString(string *param_1,char param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long *plVar2;
|
|
long *plVar3;
|
|
long unaff_RBP;
|
|
undefined8 *unaff_R12;
|
|
ios *unaff_R13;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x1a8) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x1b0) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
std::ios::~ios(unaff_R13);
|
|
plVar2 = (long *)unaff_R12[1];
|
|
for (plVar3 = (long *)*unaff_R12; plVar2 != plVar3; plVar3 = plVar3 + 1) {
|
|
if ((allocator *)(*plVar3 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose((allocator *)(*plVar3 + -0x18));
|
|
}
|
|
}
|
|
if ((void *)*unaff_R12 != (void *)0x0) {
|
|
operator_delete((void *)*unaff_R12);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011636c StringListToJson
|
|
|
|
/* StringListToJson(std::vector<std::string, std::allocator<std::string > > const&, Json::Value&,
|
|
char const*) [clone .cold] */
|
|
|
|
void StringListToJson(vector *param_1,Value *param_2,char *param_3)
|
|
|
|
{
|
|
Value *unaff_R12;
|
|
|
|
Json::Value::~Value(unaff_R12);
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 001164e0 ParseStringListFromJson
|
|
|
|
/* ParseStringListFromJson(std::vector<std::string, std::allocator<std::string > >*, Json::Value
|
|
const&, char const*) [clone .cold] */
|
|
|
|
void ParseStringListFromJson(vector *param_1,Value *param_2,char *param_3)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 001194a2 BCreateDirectoryRecursive
|
|
|
|
/* BCreateDirectoryRecursive(char const*) [clone .cold] */
|
|
|
|
void BCreateDirectoryRecursive(char *param_1)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long unaff_RBP;
|
|
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x38) + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011954c GetEnvironmentVariableAsBool
|
|
|
|
/* GetEnvironmentVariableAsBool(char const*, bool) [clone .cold] */
|
|
|
|
void GetEnvironmentVariableAsBool(char *param_1,bool param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
long *plVar2;
|
|
allocator *unaff_RBX;
|
|
long unaff_RBP;
|
|
long lVar3;
|
|
long unaff_R13;
|
|
|
|
lVar3 = *(long *)(unaff_RBP + -0xa0);
|
|
do {
|
|
plVar2 = (long *)(lVar3 + -8);
|
|
lVar3 = lVar3 + -8;
|
|
paVar1 = (allocator *)(*plVar2 + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
} while (lVar3 != unaff_R13);
|
|
lVar3 = *(long *)(unaff_RBP + -0x98);
|
|
do {
|
|
plVar2 = (long *)(lVar3 + -8);
|
|
lVar3 = lVar3 + -8;
|
|
paVar1 = (allocator *)(*plVar2 + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
} while (lVar3 != *(long *)(unaff_RBP + -0xb0));
|
|
paVar1 = (allocator *)(*(long *)(unaff_RBP + -0x80) + -0x18);
|
|
if (paVar1 != unaff_RBX) {
|
|
std::string::_Rep::_M_dispose(paVar1);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_Resume();
|
|
}
|
|
|
|
|
|
// 0011979b read_encoded_value_with_base
|
|
|
|
/* read_encoded_value_with_base(unsigned char, unsigned long, unsigned char const*, unsigned long*)
|
|
[clone .cold] */
|
|
|
|
void read_encoded_value_with_base(uchar param_1,ulong param_2,uchar *param_3,ulong *param_4)
|
|
|
|
{
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001197a0 get_ttype_entry
|
|
|
|
/* get_ttype_entry(lsda_header_info*, unsigned long) [clone .cold] */
|
|
|
|
void get_ttype_entry(lsda_header_info *param_1,ulong param_2)
|
|
|
|
{
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001197a5 base_of_encoded_value
|
|
|
|
/* base_of_encoded_value(unsigned char, _Unwind_Context*) [clone .cold] */
|
|
|
|
void base_of_encoded_value(uchar param_1,_Unwind_Context *param_2)
|
|
|
|
{
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001197aa __gxx_personality_v0.cold
|
|
|
|
void __gxx_personality_v0_cold(void)
|
|
|
|
{
|
|
__cxa_begin_catch();
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 0011986a __cxa_guard_acquire.cold
|
|
|
|
void __cxa_guard_acquire_cold(void)
|
|
|
|
{
|
|
recursive_init_error *this;
|
|
|
|
this = (recursive_init_error *)__cxa_allocate_exception(8);
|
|
__gnu_cxx::recursive_init_error::recursive_init_error(this);
|
|
/* WARNING: Subroutine does not return */
|
|
__cxa_throw(this,&__gnu_cxx::recursive_init_error::typeinfo,
|
|
__gnu_cxx::recursive_init_error::~recursive_init_error);
|
|
}
|
|
|
|
|
|
// 0011991c FUN_0011991c
|
|
|
|
void FUN_0011991c(void)
|
|
|
|
{
|
|
void *unaff_R12;
|
|
|
|
free(unaff_R12);
|
|
/* WARNING: Subroutine does not return */
|
|
__cxa_rethrow();
|
|
}
|
|
|
|
|
|
// 0011a8dd d_type.cold
|
|
|
|
void d_type_cold(void)
|
|
|
|
{
|
|
code *pcVar1;
|
|
undefined8 uStack0000000000000008;
|
|
|
|
uStack0000000000000008 = 0;
|
|
/* WARNING: Does not return */
|
|
pcVar1 = (code *)invalidInstructionException();
|
|
(*pcVar1)();
|
|
}
|
|
|
|
|
|
// 0011aa22 operator.new[]
|
|
|
|
/* operator new[](unsigned long, std::nothrow_t const&) [clone .cold] */
|
|
|
|
void * operator_new__(ulong param_1,nothrow_t *param_2)
|
|
|
|
{
|
|
__cxa_begin_catch();
|
|
__cxa_end_catch();
|
|
return (void *)0x0;
|
|
}
|
|
|
|
|
|
// 0011afd2 _txnal_cow_string_C1_for_exceptions
|
|
|
|
/* _txnal_cow_string_C1_for_exceptions(void*, char const*, void*) [clone .cold] */
|
|
|
|
void _txnal_cow_string_C1_for_exceptions(void *param_1,char *param_2,void *param_3)
|
|
|
|
{
|
|
__cxa_begin_catch();
|
|
/* WARNING: Subroutine does not return */
|
|
__cxa_rethrow();
|
|
}
|
|
|
|
|
|
// 0011b1e0 _GLOBAL__sub_I_openvr_api.cpp
|
|
|
|
void _GLOBAL__sub_I_openvr_api_cpp(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b1f0 _GLOBAL__sub_I_openvr_api_headers.cpp
|
|
|
|
void _GLOBAL__sub_I_openvr_api_headers_cpp(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b200 _GLOBAL__sub_I_strtools_public.cpp
|
|
|
|
void _GLOBAL__sub_I_strtools_public_cpp(void)
|
|
|
|
{
|
|
__gnu_cxx::stdio_sync_filebuf<wchar_t,std::char_traits<wchar_t>>::
|
|
stdio_sync_filebuf<wchar_t,std::char_traits<wchar_t>>
|
|
((stdio_sync_filebuf<wchar_t,std::char_traits<wchar_t>> *)&std::__ioinit);
|
|
__cxa_atexit(std::ios_base::Init::~Init,&std::__ioinit,&__dso_handle);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b230 _GLOBAL__sub_I_eh_alloc.cc
|
|
|
|
void _GLOBAL__sub_I_eh_alloc_cc(void)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
|
|
(anonymous_namespace)::emergency_pool._32_8_ = 0;
|
|
(anonymous_namespace)::emergency_pool._56_8_ = 0x11c00;
|
|
(anonymous_namespace)::emergency_pool._0_16_ = (undefined1 [16])0x0;
|
|
(anonymous_namespace)::emergency_pool._16_16_ = (undefined1 [16])0x0;
|
|
puVar1 = malloc(0x11c00);
|
|
(anonymous_namespace)::emergency_pool._48_8_ = puVar1;
|
|
if (puVar1 == (undefined8 *)0x0) {
|
|
(anonymous_namespace)::emergency_pool._56_8_ = 0;
|
|
(anonymous_namespace)::emergency_pool._40_8_ = 0;
|
|
}
|
|
else {
|
|
(anonymous_namespace)::emergency_pool._40_8_ = puVar1;
|
|
*puVar1 = 0x11c00;
|
|
puVar1[1] = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b2b0 _GLOBAL__sub_I_locale_inst.cc
|
|
|
|
void _GLOBAL__sub_I_locale_inst_cc(void)
|
|
|
|
{
|
|
if (std::moneypunct<char,false>::id == '\0') {
|
|
std::moneypunct<char,false>::id = '\x01';
|
|
}
|
|
if (std::moneypunct<char,true>::id == '\0') {
|
|
std::moneypunct<char,true>::id = '\x01';
|
|
}
|
|
if (std::money_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::money_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::money_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::money_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::numpunct<char>::id == '\0') {
|
|
std::numpunct<char>::id = '\x01';
|
|
}
|
|
if (std::num_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::num_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::num_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::num_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::__timepunct<char>::id == '\0') {
|
|
std::__timepunct<char>::id = '\x01';
|
|
}
|
|
if (std::time_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::time_put<char,std::ostreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::time_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id == '\0') {
|
|
std::time_get<char,std::istreambuf_iterator<char,std::char_traits<char>>>::id = '\x01';
|
|
}
|
|
if (std::messages<char>::id == '\0') {
|
|
std::messages<char>::id = '\x01';
|
|
}
|
|
if (std::collate<char>::id == '\0') {
|
|
std::collate<char>::id = '\x01';
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b370 _GLOBAL__sub_I_system_error.cc
|
|
|
|
void _GLOBAL__sub_I_system_error_cc(void)
|
|
|
|
{
|
|
__cxa_atexit((anonymous_namespace)::generic_error_category::~generic_error_category,
|
|
&(anonymous_namespace)::generic_category_instance,&__dso_handle);
|
|
__cxa_atexit((anonymous_namespace)::system_error_category::~system_error_category,
|
|
&(anonymous_namespace)::system_category_instance,&__dso_handle);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b3b0 _GLOBAL__sub_I_wlocale_inst.cc
|
|
|
|
void _GLOBAL__sub_I_wlocale_inst_cc(void)
|
|
|
|
{
|
|
if (std::moneypunct<wchar_t,false>::id == '\0') {
|
|
std::moneypunct<wchar_t,false>::id = '\x01';
|
|
}
|
|
if (std::moneypunct<wchar_t,true>::id == '\0') {
|
|
std::moneypunct<wchar_t,true>::id = '\x01';
|
|
}
|
|
if (std::money_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id ==
|
|
'\0') {
|
|
std::money_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01'
|
|
;
|
|
}
|
|
if (std::money_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id ==
|
|
'\0') {
|
|
std::money_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01'
|
|
;
|
|
}
|
|
if (std::numpunct<wchar_t>::id == '\0') {
|
|
std::numpunct<wchar_t>::id = '\x01';
|
|
}
|
|
if (std::num_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id == '\0')
|
|
{
|
|
std::num_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01';
|
|
}
|
|
if (std::num_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id == '\0')
|
|
{
|
|
std::num_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01';
|
|
}
|
|
if (std::__timepunct<wchar_t>::id == '\0') {
|
|
std::__timepunct<wchar_t>::id = '\x01';
|
|
}
|
|
if (std::time_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id == '\0'
|
|
) {
|
|
std::time_put<wchar_t,std::ostreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01';
|
|
}
|
|
if (std::time_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id == '\0'
|
|
) {
|
|
std::time_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t>>>::id = '\x01';
|
|
}
|
|
if (std::messages<wchar_t>::id == '\0') {
|
|
std::messages<wchar_t>::id = '\x01';
|
|
}
|
|
if (std::collate<wchar_t>::id == '\0') {
|
|
std::collate<wchar_t>::id = '\x01';
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b468 call_gmon_start
|
|
|
|
void call_gmon_start(void)
|
|
|
|
{
|
|
__gmon_start__();
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b490 deregister_tm_clones
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011b4a3) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011b4af) */
|
|
|
|
void deregister_tm_clones(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b4c0 register_tm_clones
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011b4e4) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011b4f0) */
|
|
|
|
void register_tm_clones(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b500 __do_global_dtors_aux
|
|
|
|
void __do_global_dtors_aux(void)
|
|
|
|
{
|
|
if (completed_7953 != '\0') {
|
|
return;
|
|
}
|
|
__cxa_finalize(__dso_handle);
|
|
deregister_tm_clones();
|
|
completed_7953 = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b550 VRControlPanel
|
|
|
|
void VRControlPanel(void)
|
|
|
|
{
|
|
if (vr::g_pVRControlPanel != 0) {
|
|
return;
|
|
}
|
|
vr::g_pVRControlPanel = VR_GetGenericInterface("IVRControlPanel_006",0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b580 VRVirtualDisplay
|
|
|
|
void VRVirtualDisplay(void)
|
|
|
|
{
|
|
if (vr::g_pVRVirtualDisplay != 0) {
|
|
return;
|
|
}
|
|
vr::g_pVRVirtualDisplay = VR_GetGenericInterface("IVRVirtualDisplay_002",0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b5b0 LiquidVR
|
|
|
|
void LiquidVR(void)
|
|
|
|
{
|
|
if (vr::g_pLiquidVR != 0) {
|
|
return;
|
|
}
|
|
vr::g_pLiquidVR = VR_GetGenericInterface("ILiquidVR_001",0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b5e0 VRPaths
|
|
|
|
void VRPaths(void)
|
|
|
|
{
|
|
if (vr::g_pVRPaths != 0) {
|
|
return;
|
|
}
|
|
vr::g_pVRPaths = VR_GetGenericInterface("IVRPaths_001",0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011b6a0 VR_GetInitToken
|
|
|
|
undefined4 VR_GetInitToken(void)
|
|
|
|
{
|
|
return vr::g_nVRToken;
|
|
}
|
|
|
|
|
|
// 0011b6b0 VR_ShutdownInternal
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011b730) */
|
|
|
|
void VR_ShutdownInternal(void)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
vr::CleanupInternalInterfaces();
|
|
if (vr::g_pHmdSystem != (long *)0x0) {
|
|
(**(code **)(*vr::g_pHmdSystem + 8))();
|
|
vr::g_pHmdSystem = (long *)0x0;
|
|
}
|
|
if (vr::g_pVRModule != (void *)0x0) {
|
|
SharedLib_Unload(vr::g_pVRModule);
|
|
vr::g_pVRModule = (void *)0x0;
|
|
}
|
|
vr::g_nVRToken = vr::g_nVRToken + 1;
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011bbb0 VR_InitInternal2
|
|
|
|
int VR_InitInternal2(int *param_1,undefined4 param_2,undefined8 param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
iVar1 = vr::VR_LoadHmdSystemInternal();
|
|
if (iVar1 == 0) {
|
|
iVar1 = (**(code **)*vr::g_pHmdSystem)(vr::g_pHmdSystem,param_2,param_3);
|
|
if (param_1 != (int *)0x0) {
|
|
LAB_0011bc04:
|
|
*param_1 = iVar1;
|
|
}
|
|
if (iVar1 == 0) {
|
|
vr::g_nVRToken = vr::g_nVRToken + 1;
|
|
iVar1 = vr::g_nVRToken;
|
|
goto LAB_0011bc1b;
|
|
}
|
|
}
|
|
else if (param_1 != (int *)0x0) goto LAB_0011bc04;
|
|
SharedLib_Unload(vr::g_pVRModule);
|
|
vr::g_pHmdSystem = (undefined8 *)0x0;
|
|
iVar1 = 0;
|
|
vr::g_pVRModule = (void *)0x0;
|
|
LAB_0011bc1b:
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return iVar1;
|
|
}
|
|
|
|
|
|
// 0011bc80 VR_InitInternal
|
|
|
|
void VR_InitInternal(undefined8 param_1,undefined8 param_2)
|
|
|
|
{
|
|
VR_InitInternal2(param_1,param_2,0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011bc90 VR_GetGenericInterface
|
|
|
|
undefined8 VR_GetGenericInterface(undefined8 param_1,undefined4 *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
if (vr::g_pHmdSystem == (long *)0x0) {
|
|
uVar2 = 0;
|
|
if (param_2 != (undefined4 *)0x0) {
|
|
*param_2 = 0x6d;
|
|
}
|
|
}
|
|
else {
|
|
uVar2 = (**(code **)(*vr::g_pHmdSystem + 0x18))(vr::g_pHmdSystem,param_1,param_2);
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar2;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011bd20 VR_IsInterfaceVersionValid
|
|
|
|
ulong VR_IsInterfaceVersionValid(undefined8 param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
ulong uVar2;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
if (vr::g_pHmdSystem == (long *)0x0) {
|
|
uVar2 = 0;
|
|
}
|
|
else {
|
|
iVar1 = (**(code **)(*vr::g_pHmdSystem + 0x10))(vr::g_pHmdSystem,param_1);
|
|
uVar2 = CONCAT71((int7)((ulong)param_1 >> 8),iVar1 == 0);
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar2 & 0xffffffff;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011bda0 VR_IsHmdPresent
|
|
|
|
undefined4 VR_IsHmdPresent(void)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined4 uVar2;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
if (vr::g_pHmdSystem == (long *)0x0) {
|
|
iVar1 = vr::VR_LoadHmdSystemInternal();
|
|
if (iVar1 == 0) {
|
|
uVar2 = (**(code **)(*vr::g_pHmdSystem + 0x20))();
|
|
vr::g_pHmdSystem = (long *)0x0;
|
|
SharedLib_Unload(vr::g_pVRModule);
|
|
vr::g_pVRModule = (void *)0x0;
|
|
}
|
|
else {
|
|
uVar2 = 0;
|
|
}
|
|
}
|
|
else {
|
|
uVar2 = (**(code **)(*vr::g_pHmdSystem + 0x20))();
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar2;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011be50 VR_IsRuntimeInstalled
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011bfa8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011bfb8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011bf98) */
|
|
|
|
undefined4 VR_IsRuntimeInstalled(void)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
undefined4 uVar3;
|
|
undefined1 *local_40;
|
|
undefined1 *local_38;
|
|
undefined1 *local_30;
|
|
|
|
iVar2 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar2 == 0) {
|
|
uVar3 = 1;
|
|
if (vr::g_pHmdSystem == 0) {
|
|
local_40 = &DAT_001f8498;
|
|
local_38 = &DAT_001f8498;
|
|
local_30 = &DAT_001f8498;
|
|
uVar3 = CVRPathRegistry_Public::GetPaths
|
|
((string *)&local_40,(string *)&local_38,(string *)&local_30,(char *)0x0,
|
|
(char *)0x0,(vector *)0x0);
|
|
if ((char)uVar3 != '\0') {
|
|
uVar3 = Path_IsDirectory((string *)&local_40);
|
|
}
|
|
if ((allocator *)(local_30 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_30 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_38 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_38 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_38 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_40 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_40 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar3;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar2);
|
|
}
|
|
|
|
|
|
// 0011bfe0 VR_GetRuntimePath
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011c0c0) */
|
|
|
|
undefined4 VR_GetRuntimePath(char *param_1,uint param_2,int *param_3)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
undefined4 uVar3;
|
|
char *local_40 [2];
|
|
|
|
*param_3 = 0;
|
|
local_40[0] = &DAT_001f8498;
|
|
uVar3 = CVRPathRegistry_Public::GetPaths
|
|
((string *)local_40,(string *)0x0,(string *)0x0,(char *)0x0,(char *)0x0,
|
|
(vector *)0x0);
|
|
if (((char)uVar3 != '\0') && (uVar3 = Path_IsDirectory((string *)local_40), (char)uVar3 != '\0'))
|
|
{
|
|
*param_3 = *(int *)(local_40[0] + -0x18) + 1;
|
|
if (*(ulong *)(local_40[0] + -0x18) < (ulong)param_2) {
|
|
strcpy_safe(param_1,(ulong)param_2,local_40[0]);
|
|
}
|
|
else {
|
|
*param_1 = '\0';
|
|
}
|
|
}
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 0011c0e0 VR_RuntimePath
|
|
|
|
undefined1 * VR_RuntimePath(void)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined1 *puVar2;
|
|
uint local_c;
|
|
|
|
cVar1 = VR_GetRuntimePath(VR_RuntimePath::rchBuffer,0x400,&local_c);
|
|
if (cVar1 != '\0') {
|
|
puVar2 = VR_RuntimePath::rchBuffer;
|
|
if (0x3ff < local_c) {
|
|
puVar2 = (undefined1 *)0x0;
|
|
}
|
|
return puVar2;
|
|
}
|
|
return (undefined1 *)0x0;
|
|
}
|
|
|
|
|
|
// 0011c130 VR_GetVRInitErrorAsSymbol
|
|
|
|
undefined8 VR_GetVRInitErrorAsSymbol(undefined4 param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
if (vr::g_pHmdSystem == (long *)0x0) {
|
|
uVar2 = GetIDForVRInitError(param_1);
|
|
}
|
|
else {
|
|
uVar2 = (**(code **)(*vr::g_pHmdSystem + 0x30))(vr::g_pHmdSystem,param_1);
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar2;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011c1b0 VR_GetVRInitErrorAsEnglishDescription
|
|
|
|
undefined8 VR_GetVRInitErrorAsEnglishDescription(undefined4 param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
|
|
iVar1 = pthread_mutex_lock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
if (iVar1 == 0) {
|
|
if (vr::g_pHmdSystem == (long *)0x0) {
|
|
uVar2 = GetEnglishStringForHmdError(param_1);
|
|
}
|
|
else {
|
|
uVar2 = (**(code **)(*vr::g_pHmdSystem + 0x28))(vr::g_pHmdSystem,param_1);
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)vr::g_mutexSystem);
|
|
return uVar2;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_system_error(iVar1);
|
|
}
|
|
|
|
|
|
// 0011c240 Path_GetThisModulePath
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetThisModulePath() */
|
|
|
|
void Path_GetThisModulePath(void)
|
|
|
|
{
|
|
string *in_RDI;
|
|
allocator local_39;
|
|
char *local_38 [5];
|
|
|
|
dladdr(Path_GetThisModulePath,local_38);
|
|
std::string::string(in_RDI,local_38[0],&local_39);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011c2c0 Path_GetExecutablePath
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetExecutablePath() */
|
|
|
|
void Path_GetExecutablePath(void)
|
|
|
|
{
|
|
ssize_t sVar1;
|
|
string *in_RDI;
|
|
long in_FS_OFFSET;
|
|
allocator local_429;
|
|
char local_428 [1032];
|
|
long local_20;
|
|
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
sVar1 = readlink("/proc/self/exe",local_428,0x3ff);
|
|
if (sVar1 == -1) {
|
|
std::string::string(in_RDI,"",&local_429);
|
|
}
|
|
else {
|
|
local_428[sVar1] = '\0';
|
|
std::string::string(in_RDI,local_428,&local_429);
|
|
}
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011c360 Path_GetWorkingDirectory
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetWorkingDirectory() */
|
|
|
|
void Path_GetWorkingDirectory(void)
|
|
|
|
{
|
|
char *__s;
|
|
size_t sVar1;
|
|
string *in_RDI;
|
|
long in_FS_OFFSET;
|
|
char local_438 [1032];
|
|
long local_30;
|
|
|
|
local_30 = *(long *)(in_FS_OFFSET + 0x28);
|
|
*(undefined1 **)in_RDI = &DAT_001f8498;
|
|
__s = getcwd(local_438,0x400);
|
|
sVar1 = strlen(__s);
|
|
std::string::assign(in_RDI,__s,sVar1);
|
|
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011c3f0 Path_SetWorkingDirectory
|
|
|
|
/* Path_SetWorkingDirectory(std::string const&) */
|
|
|
|
bool Path_SetWorkingDirectory(string *param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = chdir(*(char **)param_1);
|
|
return iVar1 == 0;
|
|
}
|
|
|
|
|
|
// 0011c410 Path_GetTemporaryDirectory
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetTemporaryDirectory() */
|
|
|
|
void Path_GetTemporaryDirectory(void)
|
|
|
|
{
|
|
char *pcVar1;
|
|
string *in_RDI;
|
|
allocator local_19 [9];
|
|
|
|
pcVar1 = getenv("TMPDIR");
|
|
if (pcVar1 != (char *)0x0) {
|
|
std::string::string(in_RDI,pcVar1,local_19);
|
|
return;
|
|
}
|
|
std::string::string(in_RDI,"/tmp",local_19);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011c470 Path_IsAbsolute
|
|
|
|
/* Path_IsAbsolute(std::string const&) */
|
|
|
|
bool Path_IsAbsolute(string *param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
bool bVar2;
|
|
|
|
bVar2 = false;
|
|
if (*(long *)(*(char **)param_1 + -0x18) != 0) {
|
|
cVar1 = **(char **)param_1;
|
|
bVar2 = cVar1 == '/' || cVar1 == '\\';
|
|
}
|
|
return bVar2;
|
|
}
|
|
|
|
|
|
// 0011c490 Path_FixSlashes
|
|
|
|
/* Path_FixSlashes(std::string const&, char) */
|
|
|
|
string * Path_FixSlashes(string *param_1,char param_2)
|
|
|
|
{
|
|
char *pcVar1;
|
|
char in_DL;
|
|
char *pcVar2;
|
|
char *pcVar3;
|
|
undefined7 in_register_00000031;
|
|
char cVar4;
|
|
|
|
cVar4 = '/';
|
|
if (in_DL != '\0') {
|
|
cVar4 = in_DL;
|
|
}
|
|
std::string::string(param_1,(string *)CONCAT71(in_register_00000031,param_2));
|
|
pcVar1 = *(char **)param_1;
|
|
pcVar3 = pcVar1;
|
|
if (-1 < *(int *)(pcVar1 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar1 = *(char **)param_1;
|
|
pcVar3 = pcVar1;
|
|
}
|
|
while( true ) {
|
|
if (*(int *)(pcVar1 + -8) < 0) {
|
|
pcVar2 = pcVar1 + *(long *)(pcVar1 + -0x18);
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar1 = *(char **)param_1;
|
|
pcVar2 = pcVar1 + *(long *)(pcVar1 + -0x18);
|
|
}
|
|
if (pcVar3 == pcVar2) break;
|
|
if ((*pcVar3 == '\\') || (*pcVar3 == '/')) {
|
|
*pcVar3 = cVar4;
|
|
pcVar1 = *(char **)param_1;
|
|
}
|
|
pcVar3 = pcVar3 + 1;
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011c540 Path_GetSlash
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* Path_GetSlash() */
|
|
|
|
undefined8 Path_GetSlash(void)
|
|
|
|
{
|
|
return 0x2f;
|
|
}
|
|
|
|
|
|
// 0011c550 Path_Join
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011c750) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011c760) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011c770) */
|
|
/* Path_Join(std::string const&, std::string const&, char) */
|
|
|
|
string * Path_Join(string *param_1,string *param_2,char param_3)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char cVar3;
|
|
long *plVar4;
|
|
undefined8 *puVar5;
|
|
char in_CL;
|
|
ulong uVar6;
|
|
undefined7 in_register_00000011;
|
|
allocator local_52 [2];
|
|
char *local_50;
|
|
long local_48;
|
|
long local_40 [2];
|
|
|
|
if (in_CL == '\0') {
|
|
in_CL = '/';
|
|
}
|
|
uVar6 = *(ulong *)(*(long *)param_2 + -0x18);
|
|
if (uVar6 == 0) {
|
|
std::string::string(param_1,(string *)CONCAT71(in_register_00000011,param_3));
|
|
}
|
|
else {
|
|
cVar3 = *(char *)(*(long *)param_2 + -1 + uVar6);
|
|
if ((cVar3 == '\\') || (cVar3 == '/')) {
|
|
uVar6 = uVar6 - 1;
|
|
}
|
|
std::string::string((string *)&local_48,1,in_CL,local_52);
|
|
std::string::string((string *)&local_50,param_2,0,uVar6);
|
|
uVar6 = *(long *)(local_48 + -0x18) + *(ulong *)(local_50 + -0x18);
|
|
if ((*(ulong *)(local_50 + -0x10) < uVar6) && (uVar6 <= *(ulong *)(local_48 + -0x10))) {
|
|
plVar4 = (long *)std::string::insert((string *)&local_48,0,local_50,
|
|
*(ulong *)(local_50 + -0x18));
|
|
}
|
|
else {
|
|
plVar4 = (long *)std::string::append((string *)&local_50,(string *)&local_48);
|
|
}
|
|
local_40[0] = *plVar4;
|
|
*plVar4 = (long)&DAT_001f8498;
|
|
puVar5 = (undefined8 *)
|
|
std::string::append((string *)local_40,(string *)CONCAT71(in_register_00000011,param_3)
|
|
);
|
|
*(undefined8 *)param_1 = *puVar5;
|
|
*puVar5 = &DAT_001f8498;
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011c7b0 Path_Join
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011c838) */
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, char) */
|
|
|
|
string * Path_Join(string *param_1,string *param_2,string *param_3,char param_4)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
long local_30;
|
|
|
|
Path_Join((string *)&local_30,param_2,(char)param_3);
|
|
Path_Join(param_1,(string *)&local_30,param_4);
|
|
if ((allocator *)(local_30 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_30 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011c850 Path_Join
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011c940) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011c930) */
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, std::string const&, char)
|
|
*/
|
|
|
|
string * Path_Join(string *param_1,string *param_2,string *param_3,string *param_4,char param_5)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
long local_48;
|
|
long local_40 [2];
|
|
|
|
Path_Join((string *)&local_48,param_2,(char)param_3);
|
|
Path_Join((string *)local_40,(string *)&local_48,(char)param_4);
|
|
Path_Join(param_1,(string *)local_40,param_5);
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011c970 Path_Join
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011cac8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011cad8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011cab8) */
|
|
/* Path_Join(std::string const&, std::string const&, std::string const&, std::string const&,
|
|
std::string const&, char) */
|
|
|
|
string * Path_Join(string *param_1,string *param_2,string *param_3,string *param_4,string *param_5,
|
|
char param_6)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
long local_50;
|
|
long local_48;
|
|
long local_40 [2];
|
|
|
|
Path_Join((string *)&local_50,param_2,(char)param_3);
|
|
Path_Join((string *)&local_48,(string *)&local_50,(char)param_4);
|
|
Path_Join((string *)local_40,(string *)&local_48,(char)param_5);
|
|
Path_Join(param_1,(string *)local_40,param_6);
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011cb10 Path_RemoveTrailingSlash
|
|
|
|
/* Path_RemoveTrailingSlash(std::string const&, char) */
|
|
|
|
string * Path_RemoveTrailingSlash(string *param_1,char param_2)
|
|
|
|
{
|
|
long lVar1;
|
|
long lVar2;
|
|
char in_DL;
|
|
char cVar3;
|
|
undefined7 in_register_00000031;
|
|
ulong uVar4;
|
|
|
|
cVar3 = '/';
|
|
if (in_DL != '\0') {
|
|
cVar3 = in_DL;
|
|
}
|
|
std::string::string(param_1,(string *)CONCAT71(in_register_00000031,param_2));
|
|
lVar1 = *(long *)CONCAT71(in_register_00000031,param_2);
|
|
lVar2 = *(long *)(lVar1 + -0x18);
|
|
if ((lVar2 != 0) && (lVar2 = lVar2 + -1, lVar2 != 0)) {
|
|
uVar4 = 0xffffffffffffffff;
|
|
do {
|
|
if (*(char *)(lVar1 + lVar2) != cVar3) break;
|
|
uVar4 = (ulong)(int)lVar2;
|
|
lVar2 = lVar2 + -1;
|
|
} while (lVar2 != 0);
|
|
if (-1 < (int)uVar4) {
|
|
if (*(ulong *)(*(long *)param_1 + -0x18) < uVar4) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_out_of_range_fmt
|
|
("%s: __pos (which is %zu) > this->size() (which is %zu)","basic_string::erase",
|
|
uVar4);
|
|
}
|
|
std::string::_M_mutate(param_1,uVar4,*(ulong *)(*(long *)param_1 + -0x18) - uVar4,0);
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011cbb0 Path_Compact
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011cfd4) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011cfe2) */
|
|
/* Path_Compact(std::string const&, char) */
|
|
|
|
string * Path_Compact(string *param_1,char param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char cVar3;
|
|
char *pcVar4;
|
|
char in_DL;
|
|
ulong uVar5;
|
|
ulong uVar6;
|
|
ulong uVar7;
|
|
allocator local_49;
|
|
char *local_48;
|
|
char *local_40 [2];
|
|
|
|
if (in_DL == '\0') {
|
|
in_DL = '/';
|
|
}
|
|
Path_FixSlashes((string *)&local_48,param_2);
|
|
std::string::string((string *)local_40,1,in_DL,&local_49);
|
|
uVar5 = 0;
|
|
uVar6 = *(ulong *)(local_48 + -0x18);
|
|
pcVar4 = local_48;
|
|
if (3 < uVar6) {
|
|
do {
|
|
if (*(int *)(pcVar4 + -8) < 0) {
|
|
if (pcVar4[uVar5] == in_DL) goto LAB_0011cc4f;
|
|
LAB_0011cc22:
|
|
uVar5 = uVar5 + 1;
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
if (local_48[uVar5] != in_DL) goto LAB_0011cc22;
|
|
LAB_0011cc4f:
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (pcVar4[uVar5 + 1] != '.') goto LAB_0011cc22;
|
|
if (*(int *)(pcVar4 + -8) < 0) {
|
|
cVar3 = pcVar4[uVar5 + 2];
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
cVar3 = local_48[uVar5 + 2];
|
|
pcVar4 = local_48;
|
|
}
|
|
if (cVar3 != in_DL) goto LAB_0011cc22;
|
|
std::string::replace
|
|
((string *)&local_48,uVar5,3,local_40[0],*(ulong *)(local_40[0] + -0x18));
|
|
pcVar4 = local_48;
|
|
}
|
|
uVar6 = *(ulong *)(pcVar4 + -0x18);
|
|
} while (uVar5 + 3 < uVar6);
|
|
}
|
|
if (2 < uVar6) {
|
|
if (*(int *)(pcVar4 + -8) < 0) {
|
|
cVar3 = pcVar4[uVar6 - 1];
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
cVar3 = local_48[uVar6 - 1];
|
|
pcVar4 = local_48;
|
|
}
|
|
if (cVar3 == '.') {
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
uVar5 = *(ulong *)(pcVar4 + -0x18);
|
|
if (pcVar4[uVar6 - 2] != in_DL) goto LAB_0011cca6;
|
|
if (uVar5 < uVar5 - 1) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_out_of_range_fmt
|
|
("%s: __pos (which is %zu) > this->size() (which is %zu)","basic_string::erase",
|
|
0xffffffffffffffff);
|
|
}
|
|
std::string::_M_mutate((string *)&local_48,uVar5 - 1,1,0);
|
|
pcVar4 = local_48;
|
|
}
|
|
}
|
|
uVar5 = *(ulong *)(pcVar4 + -0x18);
|
|
LAB_0011cca6:
|
|
if (2 < uVar5) {
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (*pcVar4 == '.') {
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (pcVar4[1] == in_DL) {
|
|
std::string::replace((string *)&local_48,0,2,"",0);
|
|
pcVar4 = local_48;
|
|
}
|
|
}
|
|
uVar5 = *(ulong *)(pcVar4 + -0x18);
|
|
}
|
|
uVar6 = 0;
|
|
if (uVar5 != 0) {
|
|
LAB_0011cccd:
|
|
uVar7 = uVar6;
|
|
uVar6 = uVar7 + 1;
|
|
if (uVar6 < uVar5) {
|
|
if ((uVar6 != 0) && (uVar5 - uVar6 != 1)) {
|
|
if (*(int *)(pcVar4 + -8) < 0) {
|
|
cVar3 = pcVar4[uVar6];
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
cVar3 = local_48[uVar6];
|
|
pcVar4 = local_48;
|
|
}
|
|
if (cVar3 == '.') {
|
|
if (*(int *)(pcVar4 + -8) < 0) {
|
|
cVar3 = pcVar4[uVar7 + 2];
|
|
uVar5 = *(ulong *)(pcVar4 + -0x18);
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
cVar3 = local_48[uVar7 + 2];
|
|
uVar5 = *(ulong *)(local_48 + -0x18);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (cVar3 != '.') goto LAB_0011cccd;
|
|
if (uVar7 + 3 != uVar5) {
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (pcVar4[uVar7 + 3] != in_DL) goto LAB_0011ccc6;
|
|
}
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
if (pcVar4[uVar7] == in_DL) {
|
|
if (uVar6 == 1) {
|
|
std::string::string(param_1,"",&local_49);
|
|
goto LAB_0011cdb6;
|
|
}
|
|
uVar6 = uVar7 - 1;
|
|
do {
|
|
uVar5 = uVar6;
|
|
if (uVar5 == 0) break;
|
|
if (-1 < *(int *)(pcVar4 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_48);
|
|
pcVar4 = local_48;
|
|
}
|
|
uVar6 = uVar5 - 1;
|
|
} while (pcVar4[uVar5 - 1] != in_DL);
|
|
std::string::replace((string *)&local_48,uVar5,(uVar7 + 4) - uVar5,"",0);
|
|
uVar5 = *(ulong *)(local_48 + -0x18);
|
|
pcVar4 = local_48;
|
|
if (uVar5 == 0) goto LAB_0011cda0;
|
|
uVar6 = 0;
|
|
goto LAB_0011cccd;
|
|
}
|
|
}
|
|
LAB_0011ccc6:
|
|
uVar5 = *(ulong *)(pcVar4 + -0x18);
|
|
}
|
|
goto LAB_0011cccd;
|
|
}
|
|
}
|
|
LAB_0011cda0:
|
|
*(char **)param_1 = pcVar4;
|
|
local_48 = &DAT_001f8498;
|
|
LAB_0011cdb6:
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011d080 Path_MakeAbsolute
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011d1e5) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011d1da) */
|
|
/* Path_MakeAbsolute(std::string const&, std::string const&) */
|
|
|
|
string * Path_MakeAbsolute(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char cVar3;
|
|
string *in_RDX;
|
|
char *local_38;
|
|
long local_30 [2];
|
|
|
|
if ((*(long *)(*(char **)param_2 + -0x18) != 0) &&
|
|
((cVar3 = **(char **)param_2, cVar3 == '/' || (cVar3 == '\\')))) {
|
|
Path_Compact(param_1,(char)param_2);
|
|
return param_1;
|
|
}
|
|
if ((*(long *)(*(char **)in_RDX + -0x18) == 0) ||
|
|
((cVar3 = **(char **)in_RDX, cVar3 != '/' && (cVar3 != '\\')))) {
|
|
std::string::string(param_1,"",(allocator *)local_30);
|
|
}
|
|
else {
|
|
Path_Join((string *)local_30,in_RDX,(char)param_2);
|
|
Path_Compact((string *)&local_38,(char)(string *)local_30);
|
|
if ((allocator *)(local_30[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_30[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30[0] + -0x18));
|
|
}
|
|
}
|
|
if ((*(long *)(local_38 + -0x18) == 0) || ((*local_38 != '/' && (*local_38 != '\\')))) {
|
|
std::string::string(param_1,"",(allocator *)local_30);
|
|
if ((allocator *)(local_38 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_38 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_38 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
*(char **)param_1 = local_38;
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011d200 Path_IsSamePath
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011d2d0) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011d2c0) */
|
|
/* Path_IsSamePath(std::string const&, std::string const&) */
|
|
|
|
ulong Path_IsSamePath(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
undefined4 extraout_var;
|
|
ulong uVar4;
|
|
char *pcVar5;
|
|
char *local_38;
|
|
char *local_30 [2];
|
|
|
|
Path_Compact((string *)&local_38,(char)param_1);
|
|
Path_Compact((string *)local_30,(char)param_2);
|
|
pcVar5 = local_38;
|
|
iVar3 = strcmp(local_38,local_30[0]);
|
|
uVar4 = CONCAT71((int7)(CONCAT44(extraout_var,iVar3) >> 8),iVar3 == 0);
|
|
if ((allocator *)(local_30[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_30[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
pcVar5 = local_38;
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30[0] + -0x18));
|
|
uVar4 = (ulong)(iVar3 == 0);
|
|
pcVar5 = local_38;
|
|
}
|
|
}
|
|
if ((allocator *)(pcVar5 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(pcVar5 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(pcVar5 + -0x18));
|
|
uVar4 = uVar4 & 0xff;
|
|
}
|
|
}
|
|
return uVar4;
|
|
}
|
|
|
|
|
|
// 0011d310 Path_IsDirectory
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011d4a0) */
|
|
/* Path_IsDirectory(std::string const&) */
|
|
|
|
ulong Path_IsDirectory(string *param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
long lVar2;
|
|
int iVar3;
|
|
ulong uVar4;
|
|
char *pcVar5;
|
|
char *local_c0;
|
|
stat local_b8;
|
|
|
|
pcVar5 = (char *)0x0;
|
|
Path_FixSlashes((string *)&local_c0,(char)param_1);
|
|
lVar2 = *(long *)(local_c0 + -0x18);
|
|
if (lVar2 != 0) {
|
|
if (-1 < *(int *)(local_c0 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_c0);
|
|
}
|
|
if ((local_c0[lVar2 + -1] == '/') || (local_c0[lVar2 + -1] == '\\')) {
|
|
if (*(int *)(local_c0 + -8) < 0) {
|
|
iVar3 = *(int *)(local_c0 + -8);
|
|
pcVar5 = local_c0 + *(long *)(local_c0 + -0x18);
|
|
}
|
|
else {
|
|
std::string::_M_leak_hard((string *)&local_c0);
|
|
iVar3 = *(int *)(local_c0 + -8);
|
|
pcVar5 = local_c0 + *(long *)(local_c0 + -0x18);
|
|
}
|
|
if (-1 < iVar3) {
|
|
std::string::_M_leak_hard((string *)&local_c0);
|
|
}
|
|
std::string::erase((string *)&local_c0,local_c0 + *(long *)(local_c0 + -0x18) + -1,pcVar5);
|
|
}
|
|
iVar3 = __xstat(1,local_c0,&local_b8);
|
|
if (iVar3 != -1) {
|
|
uVar4 = CONCAT71((int7)((ulong)pcVar5 >> 8),(local_b8.st_mode & 0xf000) == 0x4000);
|
|
goto joined_r0x0011d3cd;
|
|
}
|
|
}
|
|
uVar4 = 0;
|
|
joined_r0x0011d3cd:
|
|
if ((allocator *)(local_c0 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_c0 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_c0 + -0x18));
|
|
}
|
|
}
|
|
return uVar4 & 0xffffffff;
|
|
}
|
|
|
|
|
|
// 0011d4c0 Path_IsAppBundle
|
|
|
|
/* Path_IsAppBundle(std::string const&) */
|
|
|
|
undefined8 Path_IsAppBundle(string *param_1)
|
|
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0011d4d0 Path_Exists
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011d568) */
|
|
/* Path_Exists(std::string const&) */
|
|
|
|
ulong Path_Exists(string *param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
undefined4 extraout_var;
|
|
ulong uVar3;
|
|
char *local_a0;
|
|
stat local_98;
|
|
|
|
Path_FixSlashes((string *)&local_a0,(char)param_1);
|
|
uVar3 = 0;
|
|
if (*(long *)(local_a0 + -0x18) != 0) {
|
|
iVar2 = __xstat(1,local_a0,&local_98);
|
|
uVar3 = CONCAT71((int7)(CONCAT44(extraout_var,iVar2) >> 8),iVar2 != -1);
|
|
}
|
|
if ((allocator *)(local_a0 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_a0 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_a0 + -0x18));
|
|
return uVar3 & 0xff;
|
|
}
|
|
}
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 0011d580 Path_ReadBinaryFile
|
|
|
|
/* Path_ReadBinaryFile(std::string const&, int*) */
|
|
|
|
void * Path_ReadBinaryFile(string *param_1,int *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
FILE *__stream;
|
|
long lVar2;
|
|
void *__ptr;
|
|
size_t sVar3;
|
|
void *pvVar4;
|
|
|
|
pvVar4 = (void *)0x0;
|
|
__stream = fopen(*(char **)param_1,"rb");
|
|
if (__stream != (FILE *)0x0) {
|
|
fseek(__stream,0,2);
|
|
lVar2 = ftell(__stream);
|
|
iVar1 = (int)lVar2;
|
|
if (0 < iVar1) {
|
|
fseek(__stream,0,0);
|
|
__ptr = operator_new__((long)iVar1);
|
|
sVar3 = fread(__ptr,(long)iVar1,1,__stream);
|
|
if (sVar3 == 1) {
|
|
pvVar4 = __ptr;
|
|
if (param_2 != (int *)0x0) {
|
|
*param_2 = iVar1;
|
|
}
|
|
}
|
|
else {
|
|
pvVar4 = (void *)0x0;
|
|
operator_delete__(__ptr);
|
|
}
|
|
}
|
|
fclose(__stream);
|
|
}
|
|
return pvVar4;
|
|
}
|
|
|
|
|
|
// 0011d640 Path_ReadBinaryFile
|
|
|
|
/* Path_ReadBinaryFile(std::string const&, unsigned char*, unsigned int) */
|
|
|
|
ulong Path_ReadBinaryFile(string *param_1,uchar *param_2,uint param_3)
|
|
|
|
{
|
|
FILE *__stream;
|
|
ulong uVar1;
|
|
size_t sVar2;
|
|
ulong uVar3;
|
|
|
|
__stream = fopen(*(char **)param_1,"rb");
|
|
if (__stream == (FILE *)0x0) {
|
|
return 0;
|
|
}
|
|
fseek(__stream,0,2);
|
|
uVar1 = ftell(__stream);
|
|
if (0 < (int)(uint)uVar1) {
|
|
uVar3 = uVar1 & 0xffffffff;
|
|
fseek(__stream,0,0);
|
|
if (((param_3 < (uint)uVar1) || (param_2 == (uchar *)0x0)) ||
|
|
(sVar2 = fread(param_2,uVar1 & 0xffffffff,1,__stream), sVar2 == 1)) goto LAB_0011d691;
|
|
}
|
|
uVar3 = 0;
|
|
LAB_0011d691:
|
|
fclose(__stream);
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 0011d6f0 Path_WriteBinaryFile
|
|
|
|
/* Path_WriteBinaryFile(std::string const&, unsigned char*, unsigned int) */
|
|
|
|
bool Path_WriteBinaryFile(string *param_1,uchar *param_2,uint param_3)
|
|
|
|
{
|
|
FILE *__s;
|
|
size_t sVar1;
|
|
|
|
sVar1 = 0;
|
|
__s = fopen(*(char **)param_1,"wb");
|
|
if (__s != (FILE *)0x0) {
|
|
sVar1 = fwrite(param_2,1,(ulong)param_3,__s);
|
|
fclose(__s);
|
|
}
|
|
return sVar1 == param_3;
|
|
}
|
|
|
|
|
|
// 0011d750 Path_ReadTextFile
|
|
|
|
/* Path_ReadTextFile(std::string const&) */
|
|
|
|
string * Path_ReadTextFile(string *param_1)
|
|
|
|
{
|
|
char *pcVar1;
|
|
long lVar2;
|
|
string *in_RSI;
|
|
ulong uVar3;
|
|
allocator local_25;
|
|
int local_24;
|
|
undefined8 local_20;
|
|
|
|
pcVar1 = (char *)Path_ReadBinaryFile(in_RSI,&local_24);
|
|
if (pcVar1 == (char *)0x0) {
|
|
std::string::string(param_1,"",(allocator *)&local_20);
|
|
return param_1;
|
|
}
|
|
if (local_24 < 2) {
|
|
uVar3 = 1;
|
|
}
|
|
else {
|
|
lVar2 = 1;
|
|
uVar3 = 1;
|
|
do {
|
|
while ((pcVar1[lVar2] == '\n' && (pcVar1[lVar2 + -1] == '\r'))) {
|
|
pcVar1[uVar3 - 1] = '\n';
|
|
lVar2 = lVar2 + 1;
|
|
if (local_24 <= (int)lVar2) goto LAB_0011d7c1;
|
|
}
|
|
pcVar1[uVar3] = pcVar1[lVar2];
|
|
lVar2 = lVar2 + 1;
|
|
uVar3 = uVar3 + 1;
|
|
} while ((int)lVar2 < local_24);
|
|
}
|
|
LAB_0011d7c1:
|
|
std::string::string((string *)&local_20,pcVar1,uVar3,&local_25);
|
|
operator_delete__(pcVar1);
|
|
*(undefined8 *)param_1 = local_20;
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011d830 Path_MakeWritable
|
|
|
|
/* Path_MakeWritable(std::string const&) */
|
|
|
|
undefined8 Path_MakeWritable(string *param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined4 extraout_var;
|
|
stat local_a8;
|
|
|
|
iVar1 = __xstat(1,*(char **)param_1,&local_a8);
|
|
if ((iVar1 == 0) && ((local_a8.st_mode & 0x80) == 0)) {
|
|
iVar1 = chmod(*(char **)param_1,local_a8.st_mode | 0x80);
|
|
return CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),iVar1 == 0);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 0011d8a0 Path_WriteStringToTextFile
|
|
|
|
/* Path_WriteStringToTextFile(std::string const&, char const*) */
|
|
|
|
uint Path_WriteStringToTextFile(string *param_1,char *param_2)
|
|
|
|
{
|
|
uint uVar1;
|
|
FILE *__stream;
|
|
|
|
uVar1 = 0;
|
|
__stream = fopen(*(char **)param_1,"w");
|
|
if (__stream != (FILE *)0x0) {
|
|
uVar1 = fputs(param_2,__stream);
|
|
uVar1 = ~uVar1 >> 0x1f;
|
|
fclose(__stream);
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 0011d900 Path_WriteStringToTextFileAtomic
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011d9a8) */
|
|
/* Path_WriteStringToTextFileAtomic(std::string const&, char const*) */
|
|
|
|
ulong Path_WriteStringToTextFileAtomic(string *param_1,char *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
ulong uVar3;
|
|
undefined4 extraout_var;
|
|
char *local_30 [2];
|
|
|
|
std::string::string((string *)local_30,param_1);
|
|
std::string::append((string *)local_30,".tmp",4);
|
|
uVar3 = Path_WriteStringToTextFile((string *)local_30,param_2);
|
|
if ((char)uVar3 != '\0') {
|
|
iVar2 = rename(local_30[0],*(char **)param_1);
|
|
uVar3 = CONCAT71((int7)(CONCAT44(extraout_var,iVar2) >> 8),iVar2 != -1);
|
|
}
|
|
if ((allocator *)(local_30[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_30[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30[0] + -0x18));
|
|
uVar3 = uVar3 & 0xff;
|
|
}
|
|
}
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 0011d9d0 Path_FilePathToUrl
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011de1a) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011dd30) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011dd10) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011ddb0) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011dd20) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011de25) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011dd00) */
|
|
/* Path_FilePathToUrl(std::string const&, std::string const&) */
|
|
|
|
string * Path_FilePathToUrl(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
uint *puVar2;
|
|
int iVar3;
|
|
long lVar4;
|
|
long lVar5;
|
|
long lVar6;
|
|
string *psVar7;
|
|
char *pcVar8;
|
|
char cVar9;
|
|
uint uVar10;
|
|
uint uVar11;
|
|
undefined8 *puVar12;
|
|
uint *puVar13;
|
|
uint *puVar14;
|
|
string **ppsVar15;
|
|
allocator *paVar16;
|
|
long in_FS_OFFSET;
|
|
undefined8 uStack_80;
|
|
string *local_78;
|
|
uint local_70 [2];
|
|
allocator local_65;
|
|
allocator local_64;
|
|
allocator local_63;
|
|
allocator local_62 [2];
|
|
long local_60;
|
|
long local_58;
|
|
char *local_50;
|
|
long local_48;
|
|
long local_40;
|
|
|
|
local_40 = *(long *)(in_FS_OFFSET + 0x28);
|
|
uStack_80 = 0x11da11;
|
|
std::string::string((string *)&local_60,"http://",&local_65);
|
|
uStack_80 = 0x11da1c;
|
|
cVar9 = StringHasPrefix(param_2,(string *)&local_60);
|
|
if (cVar9 == '\0') {
|
|
uStack_80 = 0x11da87;
|
|
std::string::string((string *)&local_58,"https://",&local_64);
|
|
uStack_80 = 0x11da92;
|
|
cVar9 = StringHasPrefix(param_2,(string *)&local_58);
|
|
if (cVar9 == '\0') {
|
|
uStack_80 = 0x11dc37;
|
|
std::string::string((string *)&local_50,"vr-input-workshop://",&local_63);
|
|
uStack_80 = 0x11dc42;
|
|
cVar9 = StringHasPrefix(param_2,(string *)&local_50);
|
|
if (cVar9 == '\0') {
|
|
local_78 = (string *)&local_48;
|
|
uStack_80 = 0x11dd5b;
|
|
std::string::string(local_78,"file://",local_62);
|
|
uStack_80 = 0x11dd67;
|
|
cVar9 = StringHasPrefix(param_2,local_78);
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage
|
|
) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
uStack_80 = 0x11dda7;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
uStack_80 = 0x11dc8e;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
if ((allocator *)(local_58 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_58 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
uStack_80 = 0x11dcf5;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_58 + -0x18));
|
|
}
|
|
}
|
|
paVar16 = (allocator *)(local_60 + -0x18);
|
|
if (paVar16 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) goto LAB_0011dc9b;
|
|
LAB_0011dac6:
|
|
if (cVar9 == '\0') {
|
|
uStack_80 = 0x11dae2;
|
|
Path_MakeAbsolute((string *)&local_50,param_2);
|
|
if (*(long *)(local_50 + -0x18) == 0) {
|
|
*(char **)param_1 = local_50;
|
|
ppsVar15 = &local_78;
|
|
}
|
|
else {
|
|
uStack_80 = 0x11db1b;
|
|
local_78 = (string *)&local_48;
|
|
Path_FixSlashes((string *)&local_48,(char)(string *)&local_50);
|
|
uStack_80 = 0x11db26;
|
|
std::string::swap((string *)&local_50,(string *)&local_48);
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage
|
|
) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
uStack_80 = 0x11de15;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
pcVar8 = local_50;
|
|
lVar4 = *(long *)(local_50 + -0x18);
|
|
lVar6 = lVar4 * 3;
|
|
lVar5 = -(lVar6 + 0x17U & 0xfffffffffffffff0);
|
|
puVar2 = (uint *)((long)local_70 + lVar5);
|
|
*(undefined8 *)((long)&uStack_80 + lVar5) = 0x11db5f;
|
|
V_URLEncodeFullPath((char *)puVar2,(int)lVar6,pcVar8,(int)lVar4);
|
|
psVar7 = local_78;
|
|
*(undefined8 *)((long)&uStack_80 + lVar5) = 0x11db72;
|
|
std::string::string(psVar7,"file://",(allocator *)&local_60);
|
|
psVar7 = local_78;
|
|
puVar14 = puVar2;
|
|
do {
|
|
puVar13 = puVar14;
|
|
uVar10 = *puVar13 + 0xfefefeff & ~*puVar13;
|
|
uVar11 = uVar10 & 0x80808080;
|
|
puVar14 = puVar13 + 1;
|
|
} while (uVar11 == 0);
|
|
if ((uVar10 & 0x8080) == 0) {
|
|
puVar14 = (uint *)((long)puVar13 + 6);
|
|
uVar11 = uVar11 >> 0x10;
|
|
}
|
|
*(undefined8 *)((long)&uStack_80 + lVar5) = 0x11dbb8;
|
|
puVar12 = (undefined8 *)
|
|
std::string::append(psVar7,(char *)puVar2,
|
|
(ulong)((long)puVar14 +
|
|
((-3 - (ulong)CARRY1((byte)uVar11,(byte)uVar11)) -
|
|
(long)puVar2)));
|
|
*(undefined8 *)param_1 = *puVar12;
|
|
*puVar12 = &DAT_001f8498;
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage
|
|
) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
*(undefined8 *)((long)&uStack_80 + lVar5) = 0x11dde5;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
ppsVar15 = (string **)((long)local_70 + lVar5 + -8);
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage
|
|
) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
ppsVar15 = (string **)((long)local_70 + lVar5 + -8);
|
|
if (iVar3 < 1) {
|
|
*(undefined8 *)((long)&uStack_80 + lVar5) = 0x11dc11;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
ppsVar15 = (string **)((long)local_70 + lVar5 + -8);
|
|
}
|
|
}
|
|
}
|
|
goto LAB_0011da43;
|
|
}
|
|
}
|
|
else {
|
|
paVar16 = (allocator *)(local_60 + -0x18);
|
|
if (paVar16 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LAB_0011dc9b:
|
|
LOCK();
|
|
piVar1 = (int *)(local_60 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
uStack_80 = 0x11dcc4;
|
|
std::string::_Rep::_M_destroy(paVar16);
|
|
}
|
|
goto LAB_0011dac6;
|
|
}
|
|
}
|
|
uStack_80 = 0x11da43;
|
|
std::string::string(param_1,param_2);
|
|
ppsVar15 = &local_78;
|
|
LAB_0011da43:
|
|
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return param_1;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
*(undefined **)((long)ppsVar15 + -8) = &UNK_0011de35;
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011de80 Path_UrlToFilePath
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011df80) */
|
|
/* Path_UrlToFilePath(std::string const&) */
|
|
|
|
string * Path_UrlToFilePath(string *param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
int iVar4;
|
|
undefined1 *puVar5;
|
|
long *in_RSI;
|
|
long in_FS_OFFSET;
|
|
undefined8 uStack_50;
|
|
undefined1 auStack_48 [8];
|
|
char acStack_40 [6];
|
|
allocator local_3a [2];
|
|
long local_38;
|
|
long local_30;
|
|
|
|
puVar5 = auStack_48;
|
|
local_30 = *(long *)(in_FS_OFFSET + 0x28);
|
|
uStack_50 = 0x11deb8;
|
|
iVar4 = strnicmp((char *)*in_RSI,"file://",7);
|
|
if (iVar4 == 0) {
|
|
lVar2 = *in_RSI;
|
|
lVar3 = *(long *)(lVar2 + -0x18);
|
|
iVar4 = (int)lVar3;
|
|
lVar3 = -(lVar3 + 0x17U & 0xfffffffffffffff0);
|
|
*(undefined8 *)(auStack_48 + lVar3 + -8) = 0x11deee;
|
|
V_URLDecodeNoPlusForSpace(acStack_40 + lVar3,iVar4,(char *)(lVar2 + 7),iVar4 + -7);
|
|
*(undefined8 *)(auStack_48 + lVar3 + -8) = 0x11defd;
|
|
std::string::string((string *)&local_38,acStack_40 + lVar3,local_3a);
|
|
*(undefined8 *)(auStack_48 + lVar3 + -8) = 0x11df0a;
|
|
Path_FixSlashes(param_1,(char)(string *)&local_38);
|
|
puVar5 = auStack_48 + lVar3;
|
|
if ((allocator *)(local_38 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_38 + -8);
|
|
iVar4 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
puVar5 = auStack_48 + lVar3;
|
|
if (iVar4 < 1) {
|
|
*(undefined8 *)(auStack_48 + lVar3 + -8) = 0x11df79;
|
|
std::string::_Rep::_M_destroy((allocator *)(local_38 + -0x18));
|
|
puVar5 = auStack_48 + lVar3;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
uStack_50 = 0x11df53;
|
|
std::string::string(param_1,"",(allocator *)&local_38);
|
|
}
|
|
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
|
|
/* WARNING: Subroutine does not return */
|
|
*(undefined **)(puVar5 + -8) = &UNK_0011df90;
|
|
__stack_chk_fail();
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011dfa0 GetUserDocumentsPath
|
|
|
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
|
|
/* GetUserDocumentsPath() */
|
|
|
|
void GetUserDocumentsPath(void)
|
|
|
|
{
|
|
char *pcVar1;
|
|
string *in_RDI;
|
|
allocator local_19 [9];
|
|
|
|
pcVar1 = getenv("HOME");
|
|
if (pcVar1 != (char *)0x0) {
|
|
std::string::string(in_RDI,pcVar1,local_19);
|
|
return;
|
|
}
|
|
std::string::string(in_RDI,"",local_19);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011e000 Path_UnlinkFile
|
|
|
|
/* Path_UnlinkFile(std::string const&) */
|
|
|
|
bool Path_UnlinkFile(string *param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = unlink(*(char **)param_1);
|
|
return iVar1 == 0;
|
|
}
|
|
|
|
|
|
// 0011e020 Path_SanitizeFilename
|
|
|
|
/* Path_SanitizeFilename(std::string const&) */
|
|
|
|
string * Path_SanitizeFilename(string *param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
char *pcVar2;
|
|
char *pcVar3;
|
|
string *in_RSI;
|
|
char *pcVar4;
|
|
char *pcVar5;
|
|
|
|
std::string::string(param_1,in_RSI);
|
|
pcVar2 = *(char **)param_1;
|
|
if (-1 < *(int *)(pcVar2 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
pcVar4 = pcVar2 + *(long *)(pcVar2 + -0x18);
|
|
if (-1 < *(int *)(pcVar2 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
pcVar3 = pcVar2;
|
|
if (-1 < *(int *)(pcVar2 + -8)) goto LAB_0011e0b5;
|
|
LAB_0011e070:
|
|
pcVar5 = pcVar4;
|
|
if (pcVar3 == pcVar2 + *(long *)(pcVar2 + -0x18)) {
|
|
LAB_0011e0cd:
|
|
if (-1 < *(int *)(pcVar2 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
if (pcVar4 != pcVar2 + *(long *)(pcVar2 + -0x18)) {
|
|
if (-1 < *(int *)(pcVar2 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
if (pcVar4 != pcVar2) {
|
|
if (-1 < *(int *)(pcVar2 + -8)) {
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
if (pcVar2 + *(long *)(pcVar2 + -0x18) != pcVar4 + 1) {
|
|
*pcVar4 = '.';
|
|
}
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
do {
|
|
cVar1 = *pcVar3;
|
|
pcVar4 = pcVar3;
|
|
if ((cVar1 == '.') || (pcVar4 = pcVar5, cVar1 == '\0')) {
|
|
switchD_0011e09e_caseD_22:
|
|
*pcVar3 = '_';
|
|
pcVar2 = *(char **)param_1;
|
|
}
|
|
else {
|
|
switch(cVar1) {
|
|
case '\"':
|
|
case '$':
|
|
case '%':
|
|
case '&':
|
|
case '*':
|
|
case '.':
|
|
case '/':
|
|
case ':':
|
|
case '<':
|
|
case '>':
|
|
case '?':
|
|
case '@':
|
|
case '\\':
|
|
case '|':
|
|
goto switchD_0011e09e_caseD_22;
|
|
default:
|
|
if (cVar1 < ' ') goto switchD_0011e09e_caseD_22;
|
|
}
|
|
}
|
|
pcVar3 = pcVar3 + 1;
|
|
if (*(int *)(pcVar2 + -8) < 0) goto LAB_0011e070;
|
|
LAB_0011e0b5:
|
|
std::string::_M_leak_hard(param_1);
|
|
pcVar2 = *(char **)param_1;
|
|
pcVar5 = pcVar4;
|
|
if (pcVar3 == pcVar2 + *(long *)(pcVar2 + -0x18)) goto LAB_0011e0cd;
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 0011e1a0 Path_DeleteDirectory
|
|
|
|
/* Path_DeleteDirectory(std::string const&, bool) */
|
|
|
|
undefined8 Path_DeleteDirectory(string *param_1,bool param_2)
|
|
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0011e1b0 Path_ReadBinaryFile
|
|
|
|
/* Path_ReadBinaryFile(std::string const&) */
|
|
|
|
string * Path_ReadBinaryFile(string *param_1)
|
|
|
|
{
|
|
FILE *__stream;
|
|
long lVar1;
|
|
size_t sVar2;
|
|
ulong uVar3;
|
|
undefined8 *in_RSI;
|
|
void *__ptr;
|
|
ulong __size;
|
|
|
|
__stream = fopen((char *)*in_RSI,"rb");
|
|
*(undefined1 (*) [16])param_1 = (undefined1 [16])0x0;
|
|
*(undefined8 *)(param_1 + 0x10) = 0;
|
|
if (__stream != (FILE *)0x0) {
|
|
fseek(__stream,0,2);
|
|
lVar1 = ftell(__stream);
|
|
if (0 < (int)lVar1) {
|
|
fseek(__stream,0,0);
|
|
__size = (ulong)(int)lVar1;
|
|
__ptr = *(void **)param_1;
|
|
uVar3 = *(long *)(param_1 + 8) - (long)__ptr;
|
|
if (uVar3 < __size) {
|
|
std::vector<unsigned_char,std::allocator<unsigned_char>>::_M_default_append
|
|
((vector<unsigned_char,std::allocator<unsigned_char>> *)param_1,__size - uVar3);
|
|
__ptr = *(void **)param_1;
|
|
}
|
|
else if ((__size < uVar3) && (*(long *)(param_1 + 8) != (long)__ptr + __size)) {
|
|
*(ulong *)(param_1 + 8) = (long)__ptr + __size;
|
|
}
|
|
sVar2 = fread(__ptr,__size,1,__stream);
|
|
if ((sVar2 != 1) && (*(long *)param_1 != *(long *)(param_1 + 8))) {
|
|
*(long *)(param_1 + 8) = *(long *)param_1;
|
|
}
|
|
}
|
|
fclose(__stream);
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011e2a0 Path_StripFilename
|
|
|
|
/* Path_StripFilename(std::string const&, char) */
|
|
|
|
string * Path_StripFilename(string *param_1,char param_2)
|
|
|
|
{
|
|
long lVar1;
|
|
char *pcVar2;
|
|
char in_DL;
|
|
undefined7 in_register_00000031;
|
|
string *this;
|
|
undefined1 local_19;
|
|
|
|
this = (string *)CONCAT71(in_register_00000031,param_2);
|
|
if (in_DL == '\0') {
|
|
in_DL = '/';
|
|
}
|
|
lVar1 = std::string::rfind(this,in_DL,0xffffffffffffffff);
|
|
if (lVar1 != -1) {
|
|
pcVar2 = std::string::_S_construct<__gnu_cxx::__normal_iterator<char_const*,std::string>>
|
|
(*(long *)this,*(long *)this + lVar1,&local_19);
|
|
*(char **)param_1 = pcVar2;
|
|
return param_1;
|
|
}
|
|
std::string::string(param_1,this);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011e320 Path_FindParentSubDirectoryRecursively
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011e5a4) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e560) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e550) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e5db) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e599) */
|
|
/* Path_FindParentSubDirectoryRecursively(std::string const&, std::string const&) */
|
|
|
|
string * Path_FindParentSubDirectoryRecursively(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char cVar3;
|
|
char cVar4;
|
|
char in_DL;
|
|
undefined1 *local_58;
|
|
long local_50;
|
|
long local_48;
|
|
long local_40 [2];
|
|
|
|
std::string::string((string *)&local_58,"",(allocator *)local_40);
|
|
Path_FixSlashes((string *)&local_50,(char)param_2);
|
|
if (*(long *)(local_50 + -0x18) == 0) {
|
|
std::string::string(param_1,"",(allocator *)local_40);
|
|
}
|
|
else {
|
|
cVar3 = Path_Exists((string *)&local_50);
|
|
do {
|
|
if ((cVar3 == '\0') || (*(long *)(local_50 + -0x18) == 0)) goto LAB_0011e4ca;
|
|
Path_StripFilename((string *)&local_48,(char)(string *)&local_50);
|
|
std::string::swap((string *)&local_50,(string *)&local_48);
|
|
if ((allocator *)(local_48 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
cVar3 = Path_Exists((string *)&local_50);
|
|
Path_Join((string *)local_40,(string *)&local_50,in_DL);
|
|
cVar4 = Path_Exists((string *)local_40);
|
|
if ((allocator *)(local_40[0] + -0x18) !=
|
|
(allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
} while (cVar4 == '\0');
|
|
Path_Join((string *)local_40,(string *)&local_50,in_DL);
|
|
std::string::swap((string *)&local_58,(string *)local_40);
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
LAB_0011e4ca:
|
|
*(undefined1 **)param_1 = local_58;
|
|
local_58 = &DAT_001f8498;
|
|
}
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_58 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_58 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_58 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011e610 Path_StripDirectory
|
|
|
|
/* Path_StripDirectory(std::string const&, char) */
|
|
|
|
string * Path_StripDirectory(string *param_1,char param_2)
|
|
|
|
{
|
|
long lVar1;
|
|
long lVar2;
|
|
char *pcVar3;
|
|
char in_DL;
|
|
undefined7 in_register_00000031;
|
|
string *this;
|
|
undefined1 local_19;
|
|
|
|
this = (string *)CONCAT71(in_register_00000031,param_2);
|
|
if (in_DL == '\0') {
|
|
in_DL = '/';
|
|
}
|
|
lVar2 = std::string::rfind(this,in_DL,0xffffffffffffffff);
|
|
if (lVar2 != -1) {
|
|
lVar1 = *(long *)this;
|
|
pcVar3 = std::string::_S_construct<__gnu_cxx::__normal_iterator<char_const*,std::string>>
|
|
(lVar1 + 1 + lVar2,*(long *)(lVar1 + -0x18) + lVar1,&local_19);
|
|
*(char **)param_1 = pcVar3;
|
|
return param_1;
|
|
}
|
|
std::string::string(param_1,this);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011e690 Path_FindParentDirectoryRecursively
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011e97d) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e8d8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e8e8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e96f) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011e988) */
|
|
/* Path_FindParentDirectoryRecursively(std::string const&, std::string const&) */
|
|
|
|
string * Path_FindParentDirectoryRecursively(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
char cVar2;
|
|
int iVar3;
|
|
undefined8 *in_RDX;
|
|
char cVar4;
|
|
long local_60;
|
|
undefined1 *local_58;
|
|
char *local_50;
|
|
long local_48;
|
|
long local_40 [2];
|
|
|
|
std::string::string((string *)&local_60,"",(allocator *)local_40);
|
|
Path_FixSlashes((string *)&local_58,(char)param_2);
|
|
if (*(long *)(local_58 + -0x18) == 0) {
|
|
std::string::string(param_1,"",(allocator *)local_40);
|
|
}
|
|
else {
|
|
cVar2 = Path_Exists((string *)&local_58);
|
|
cVar4 = (char)(string *)&local_58;
|
|
Path_StripDirectory((string *)&local_50,cVar4);
|
|
if (cVar2 == '\0') {
|
|
LAB_0011e760:
|
|
std::string::string(param_1,"",(allocator *)local_40);
|
|
}
|
|
else {
|
|
iVar3 = stricmp(local_50,(char *)*in_RDX);
|
|
if (iVar3 == 0) {
|
|
*(undefined1 **)param_1 = local_58;
|
|
local_58 = &DAT_001f8498;
|
|
}
|
|
else {
|
|
do {
|
|
if (*(long *)(local_58 + -0x18) == 0) goto LAB_0011e760;
|
|
Path_StripFilename((string *)&local_48,cVar4);
|
|
std::string::swap((string *)&local_58,(string *)&local_48);
|
|
if ((allocator *)(local_48 + -0x18) !=
|
|
(allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_48 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_48 + -0x18));
|
|
}
|
|
}
|
|
Path_StripDirectory((string *)local_40,cVar4);
|
|
std::string::swap((string *)&local_50,(string *)local_40);
|
|
if ((allocator *)(local_40[0] + -0x18) !=
|
|
(allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
cVar2 = Path_Exists((string *)&local_58);
|
|
if (cVar2 == '\0') goto LAB_0011e760;
|
|
iVar3 = stricmp(local_50,(char *)*in_RDX);
|
|
} while (iVar3 != 0);
|
|
*(undefined1 **)param_1 = local_58;
|
|
local_58 = &DAT_001f8498;
|
|
}
|
|
}
|
|
if ((allocator *)(local_50 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_50 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_50 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
if ((allocator *)(local_58 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_58 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_58 + -0x18));
|
|
}
|
|
}
|
|
if ((allocator *)(local_60 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_60 + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_60 + -0x18));
|
|
}
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011e9c0 Path_StripExtension
|
|
|
|
/* Path_StripExtension(std::string const&) */
|
|
|
|
string * Path_StripExtension(string *param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
char *pcVar4;
|
|
string *in_RSI;
|
|
undefined1 local_19 [9];
|
|
|
|
lVar2 = *(long *)in_RSI;
|
|
for (lVar3 = *(long *)(lVar2 + -0x18) + lVar2; lVar3 != lVar2; lVar3 = lVar3 + -1) {
|
|
cVar1 = *(char *)(lVar3 + -1);
|
|
if (cVar1 == '.') {
|
|
pcVar4 = std::string::_S_construct<__gnu_cxx::__normal_iterator<char_const*,std::string>>
|
|
(lVar2,lVar3 + -1,local_19);
|
|
*(char **)param_1 = pcVar4;
|
|
return param_1;
|
|
}
|
|
if ((cVar1 == '/') || (cVar1 == '\\')) break;
|
|
}
|
|
std::string::string(param_1,in_RSI);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011ea40 Path_GetExtension
|
|
|
|
/* Path_GetExtension(std::string const&) */
|
|
|
|
string * Path_GetExtension(string *param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
long lVar2;
|
|
char *pcVar3;
|
|
long *in_RSI;
|
|
long lVar4;
|
|
long lVar5;
|
|
allocator local_19 [9];
|
|
|
|
lVar2 = *in_RSI;
|
|
lVar4 = *(long *)(lVar2 + -0x18) + lVar2;
|
|
for (lVar5 = lVar4; lVar5 != lVar2; lVar5 = lVar5 + -1) {
|
|
cVar1 = *(char *)(lVar5 + -1);
|
|
if (cVar1 == '.') {
|
|
pcVar3 = std::string::_S_construct<__gnu_cxx::__normal_iterator<char_const*,std::string>>
|
|
(lVar5,lVar4,local_19);
|
|
*(char **)param_1 = pcVar3;
|
|
return param_1;
|
|
}
|
|
if ((cVar1 == '/') || (cVar1 == '\\')) break;
|
|
}
|
|
std::string::string(param_1,"",local_19);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011eca0 SharedLib_Load
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011ed3c) */
|
|
/* SharedLib_Load(char const*, std::string*) */
|
|
|
|
long SharedLib_Load(char *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
long lVar3;
|
|
char *pcVar4;
|
|
allocator local_32 [2];
|
|
long local_30 [2];
|
|
|
|
lVar3 = dlopen(param_1,2);
|
|
if (((lVar3 == 0) && (param_2 != (string *)0x0)) &&
|
|
(pcVar4 = (char *)dlerror(), pcVar4 != (char *)0x0)) {
|
|
std::string::string((string *)local_30,pcVar4,local_32);
|
|
std::string::swap(param_2,(string *)local_30);
|
|
if ((allocator *)(local_30[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_30[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30[0] + -0x18));
|
|
}
|
|
}
|
|
}
|
|
return lVar3;
|
|
}
|
|
|
|
|
|
// 0011ed50 SharedLib_GetFunction
|
|
|
|
/* SharedLib_GetFunction(void*, char const*) */
|
|
|
|
void SharedLib_GetFunction(void *param_1,char *param_2)
|
|
|
|
{
|
|
dlsym();
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011ed60 SharedLib_Unload
|
|
|
|
/* SharedLib_Unload(void*) */
|
|
|
|
void SharedLib_Unload(void *param_1)
|
|
|
|
{
|
|
if (param_1 != (void *)0x0) {
|
|
dlclose();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011ed80 CharNeedsEscape_Component
|
|
|
|
/* CharNeedsEscape_Component(char) */
|
|
|
|
uint CharNeedsEscape_Component(char param_1)
|
|
|
|
{
|
|
uint uVar1;
|
|
|
|
uVar1 = 0;
|
|
if (0x19 < (byte)((param_1 & 0xdfU) + 0xbf)) {
|
|
uVar1 = 1;
|
|
if ((byte)(param_1 - 0x2dU) < 0x33) {
|
|
uVar1 = ~(uint)(0x4000000001ffb >> (param_1 - 0x2dU & 0x3f)) & 1;
|
|
}
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 0011edb0 CharNeedsEscape_FullPath
|
|
|
|
/* CharNeedsEscape_FullPath(char) */
|
|
|
|
uint CharNeedsEscape_FullPath(char param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
uint uVar2;
|
|
int iVar3;
|
|
undefined3 in_register_00000039;
|
|
|
|
uVar2 = 0;
|
|
iVar3 = (CONCAT31(in_register_00000039,param_1) & 0xffffffdf) - 0x41;
|
|
if (0x19 < (byte)iVar3) {
|
|
iVar1 = CONCAT31(in_register_00000039,param_1) - 0x2d;
|
|
uVar2 = CONCAT31((int3)((uint)iVar1 >> 8),0xd < (byte)iVar1) &
|
|
CONCAT31((int3)((uint)iVar3 >> 8),param_1 != '_');
|
|
}
|
|
return uVar2;
|
|
}
|
|
|
|
|
|
// 0011ede0 V_URLDecodeInternal
|
|
|
|
/* V_URLDecodeInternal(char*, int, char const*, int, bool) [clone .part.0] */
|
|
|
|
long V_URLDecodeInternal(char *param_1,int param_2,char *param_3,int param_4,bool param_5)
|
|
|
|
{
|
|
int iVar1;
|
|
char cVar2;
|
|
byte bVar3;
|
|
byte bVar4;
|
|
int iVar5;
|
|
int iVar6;
|
|
uint uVar7;
|
|
long lVar8;
|
|
int iVar9;
|
|
uint uVar10;
|
|
|
|
if (param_4 < 1) {
|
|
lVar8 = 0;
|
|
iVar9 = 0;
|
|
}
|
|
else {
|
|
iVar9 = 0;
|
|
iVar5 = 0;
|
|
lVar8 = 0;
|
|
LAB_0011ee21:
|
|
do {
|
|
cVar2 = param_3[iVar5];
|
|
if ((param_5) && (cVar2 == '+')) {
|
|
param_1[lVar8] = ' ';
|
|
}
|
|
else {
|
|
if (cVar2 == '%') {
|
|
if (iVar5 < param_4 + -2) {
|
|
bVar3 = param_3[(long)iVar5 + 1];
|
|
bVar4 = param_3[(long)iVar5 + 2];
|
|
uVar10 = (int)(char)bVar3 - 0x30;
|
|
if (((uVar10 < 10) ||
|
|
((iVar6 = (int)(char)(bVar3 | 0x20), iVar6 - 0x61U < 6 &&
|
|
(uVar10 = iVar6 - 0x57, iVar6 != 0x56)))) &&
|
|
((uVar7 = (int)(char)bVar4 - 0x30, uVar7 < 10 ||
|
|
((iVar6 = (int)(char)(bVar4 | 0x20), iVar6 - 0x61U < 6 &&
|
|
(uVar7 = iVar6 - 0x57, iVar6 != 0x56)))))) {
|
|
iVar9 = iVar9 + 1;
|
|
param_1[lVar8] = (char)(uVar10 << 4) + (char)uVar7;
|
|
lVar8 = (long)iVar9;
|
|
}
|
|
else {
|
|
param_1[lVar8] = '%';
|
|
iVar6 = iVar9 + 1;
|
|
iVar1 = iVar9 + 2;
|
|
iVar9 = iVar9 + 3;
|
|
param_1[iVar6] = bVar3;
|
|
param_1[iVar1] = bVar4;
|
|
lVar8 = (long)iVar9;
|
|
}
|
|
}
|
|
iVar5 = iVar5 + 3;
|
|
if (param_4 <= iVar5) break;
|
|
goto LAB_0011ee21;
|
|
}
|
|
param_1[lVar8] = cVar2;
|
|
}
|
|
iVar9 = iVar9 + 1;
|
|
lVar8 = (long)iVar9;
|
|
iVar5 = iVar5 + 1;
|
|
} while (iVar5 < param_4);
|
|
}
|
|
if (iVar9 < param_2) {
|
|
param_1[lVar8] = '\0';
|
|
}
|
|
return lVar8;
|
|
}
|
|
|
|
|
|
// 0011ef30 stricmp
|
|
|
|
/* stricmp(char const*, char const*) */
|
|
|
|
void stricmp(char *param_1,char *param_2)
|
|
|
|
{
|
|
strcasecmp(param_1,param_2);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011ef40 strnicmp
|
|
|
|
/* strnicmp(char const*, char const*, unsigned long) */
|
|
|
|
void strnicmp(char *param_1,char *param_2,ulong param_3)
|
|
|
|
{
|
|
strncasecmp(param_1,param_2,param_3);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011ef50 StringHasPrefix
|
|
|
|
/* StringHasPrefix(std::string const&, std::string const&) */
|
|
|
|
bool StringHasPrefix(string *param_1,string *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = strncasecmp(*(char **)param_1,*(char **)param_2,*(size_t *)(*(char **)param_2 + -0x18));
|
|
return iVar1 == 0;
|
|
}
|
|
|
|
|
|
// 0011ef70 StringHasPrefixCaseSensitive
|
|
|
|
/* StringHasPrefixCaseSensitive(std::string const&, std::string const&) */
|
|
|
|
bool StringHasPrefixCaseSensitive(string *param_1,string *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = strncmp(*(char **)param_1,*(char **)param_2,*(size_t *)(*(char **)param_2 + -0x18));
|
|
return iVar1 == 0;
|
|
}
|
|
|
|
|
|
// 0011ef90 StringHasSuffix
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011f030) */
|
|
/* StringHasSuffix(std::string const&, std::string const&) */
|
|
|
|
ulong StringHasSuffix(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
undefined4 extraout_var;
|
|
ulong uVar4;
|
|
char *local_20;
|
|
|
|
uVar4 = *(ulong *)(*(long *)param_2 + -0x18);
|
|
if (uVar4 <= *(ulong *)(*(long *)param_1 + -0x18)) {
|
|
std::string::string((string *)&local_20,param_1,*(ulong *)(*(long *)param_1 + -0x18) - uVar4,
|
|
uVar4);
|
|
iVar3 = strcasecmp(local_20,*(char **)param_2);
|
|
uVar4 = CONCAT71((int7)(CONCAT44(extraout_var,iVar3) >> 8),iVar3 == 0);
|
|
if ((allocator *)(local_20 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_20 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_20 + -0x18));
|
|
uVar4 = (ulong)(iVar3 == 0);
|
|
}
|
|
}
|
|
return uVar4;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0011f040 StringHasSuffixCaseSensitive
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0011f0e0) */
|
|
/* StringHasSuffixCaseSensitive(std::string const&, std::string const&) */
|
|
|
|
ulong StringHasSuffixCaseSensitive(string *param_1,string *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
ulong __n;
|
|
int iVar3;
|
|
undefined4 extraout_var;
|
|
ulong uVar4;
|
|
char *local_30 [2];
|
|
|
|
__n = *(ulong *)(*(long *)param_2 + -0x18);
|
|
uVar4 = 0;
|
|
if (__n <= *(ulong *)(*(long *)param_1 + -0x18)) {
|
|
std::string::string((string *)local_30,param_1,*(ulong *)(*(long *)param_1 + -0x18) - __n,__n);
|
|
iVar3 = strncmp(local_30[0],*(char **)param_2,__n);
|
|
uVar4 = CONCAT71((int7)(CONCAT44(extraout_var,iVar3) >> 8),iVar3 == 0);
|
|
if ((allocator *)(local_30[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_30[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_30[0] + -0x18));
|
|
uVar4 = (ulong)(iVar3 == 0);
|
|
}
|
|
}
|
|
}
|
|
return uVar4;
|
|
}
|
|
|
|
|
|
// 0011f4e0 UTF16to8
|
|
|
|
/* UTF16to8(std::wstring const&) */
|
|
|
|
wstring * UTF16to8(wstring *param_1)
|
|
|
|
{
|
|
std::codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0>::
|
|
codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0>
|
|
((codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0> *)param_1);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011f8d0 UTF8to16
|
|
|
|
/* UTF8to16(std::string const&) */
|
|
|
|
string * UTF8to16(string *param_1)
|
|
|
|
{
|
|
std::codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0>::
|
|
codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0>
|
|
((codecvt_utf8<wchar_t,1114111ul,(std::codecvt_mode)0> *)param_1);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011f8f0 strcpy_safe
|
|
|
|
/* strcpy_safe(char*, unsigned long, char const*) */
|
|
|
|
void strcpy_safe(char *param_1,ulong param_2,char *param_3)
|
|
|
|
{
|
|
char *pcVar1;
|
|
|
|
pcVar1 = strncpy(param_1,param_3,param_2 - 1);
|
|
pcVar1[param_2 - 1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011f920 StringToUpper
|
|
|
|
/* StringToUpper(std::string const&) */
|
|
|
|
string * StringToUpper(string *param_1)
|
|
|
|
{
|
|
ulong uVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
undefined1 *puVar4;
|
|
int iVar5;
|
|
char *pcVar6;
|
|
long *in_RSI;
|
|
|
|
*(undefined1 **)param_1 = &DAT_001f8498;
|
|
std::string::reserve(param_1,*(long *)(*in_RSI + -0x18) + 1);
|
|
pcVar6 = (char *)*in_RSI;
|
|
if (*(long *)(pcVar6 + -0x18) != 0) {
|
|
do {
|
|
iVar5 = toupper((int)*pcVar6);
|
|
lVar2 = *(long *)param_1;
|
|
lVar3 = *(long *)(lVar2 + -0x18);
|
|
uVar1 = lVar3 + 1;
|
|
if ((*(ulong *)(lVar2 + -0x10) < uVar1) || (0 < *(int *)(lVar2 + -8))) {
|
|
std::string::reserve(param_1,uVar1);
|
|
}
|
|
*(char *)(*(long *)param_1 + *(long *)(*(long *)param_1 + -0x18)) = (char)iVar5;
|
|
puVar4 = *(undefined1 **)param_1;
|
|
if (puVar4 != &DAT_001f8498) {
|
|
*(undefined4 *)(puVar4 + -8) = 0;
|
|
*(ulong *)(puVar4 + -0x18) = uVar1;
|
|
puVar4[lVar3 + 1] = 0;
|
|
}
|
|
pcVar6 = pcVar6 + 1;
|
|
} while ((char *)(*in_RSI + *(long *)(*in_RSI + -0x18)) != pcVar6);
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011fa00 StringToLower
|
|
|
|
/* StringToLower(std::string const&) */
|
|
|
|
string * StringToLower(string *param_1)
|
|
|
|
{
|
|
ulong uVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
undefined1 *puVar4;
|
|
int iVar5;
|
|
char *pcVar6;
|
|
long *in_RSI;
|
|
|
|
*(undefined1 **)param_1 = &DAT_001f8498;
|
|
std::string::reserve(param_1,*(long *)(*in_RSI + -0x18) + 1);
|
|
pcVar6 = (char *)*in_RSI;
|
|
if (*(long *)(pcVar6 + -0x18) != 0) {
|
|
do {
|
|
iVar5 = tolower((int)*pcVar6);
|
|
lVar2 = *(long *)param_1;
|
|
lVar3 = *(long *)(lVar2 + -0x18);
|
|
uVar1 = lVar3 + 1;
|
|
if ((*(ulong *)(lVar2 + -0x10) < uVar1) || (0 < *(int *)(lVar2 + -8))) {
|
|
std::string::reserve(param_1,uVar1);
|
|
}
|
|
*(char *)(*(long *)param_1 + *(long *)(*(long *)param_1 + -0x18)) = (char)iVar5;
|
|
puVar4 = *(undefined1 **)param_1;
|
|
if (puVar4 != &DAT_001f8498) {
|
|
*(undefined4 *)(puVar4 + -8) = 0;
|
|
*(ulong *)(puVar4 + -0x18) = uVar1;
|
|
puVar4[lVar3 + 1] = 0;
|
|
}
|
|
pcVar6 = pcVar6 + 1;
|
|
} while ((char *)(*in_RSI + *(long *)(*in_RSI + -0x18)) != pcVar6);
|
|
}
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 0011fae0 ReturnStdString
|
|
|
|
/* ReturnStdString(std::string const&, char*, unsigned int) */
|
|
|
|
uint ReturnStdString(string *param_1,char *param_2,uint param_3)
|
|
|
|
{
|
|
uint uVar1;
|
|
|
|
uVar1 = *(int *)((long)*(void **)param_1 + -0x18) + 1;
|
|
if ((param_2 != (char *)0x0) && (param_3 != 0)) {
|
|
if (uVar1 <= param_3) {
|
|
memcpy(param_2,*(void **)param_1,(ulong)uVar1);
|
|
return uVar1;
|
|
}
|
|
*param_2 = '\0';
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 0011fb40 Uint64ToString
|
|
|
|
/* Uint64ToString(unsigned long) */
|
|
|
|
ulong Uint64ToString(ulong param_1)
|
|
|
|
{
|
|
long in_FS_OFFSET;
|
|
allocator local_39;
|
|
char local_38 [24];
|
|
long local_20;
|
|
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
__snprintf_chk(local_38,0x16,1,0x16,&DAT_001b4358);
|
|
std::string::string((string *)param_1,local_38,&local_39);
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return param_1;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011fbc0 StringToUint64
|
|
|
|
/* StringToUint64(std::string const&) */
|
|
|
|
void StringToUint64(string *param_1)
|
|
|
|
{
|
|
strtoull(*(char **)param_1,(char **)0x0,0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011fbd0 cIntToHexDigit
|
|
|
|
/* cIntToHexDigit(int) */
|
|
|
|
char cIntToHexDigit(int param_1)
|
|
|
|
{
|
|
return "0123456789ABCDEF"[param_1 & 0xf];
|
|
}
|
|
|
|
|
|
// 0011fbe0 iHexCharToInt
|
|
|
|
/* iHexCharToInt(char) */
|
|
|
|
uint iHexCharToInt(char param_1)
|
|
|
|
{
|
|
uint uVar1;
|
|
|
|
uVar1 = (int)param_1 - 0x30U;
|
|
if (9 < (int)param_1 - 0x30U) {
|
|
uVar1 = 0xffffffff;
|
|
if ((int)(char)(param_1 | 0x20) - 0x61U < 6) {
|
|
uVar1 = (int)(char)(param_1 | 0x20) - 0x57;
|
|
}
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 0011fc10 V_URLEncodeInternal
|
|
|
|
/* V_URLEncodeInternal(char*, int, char const*, int, bool, std::function<bool (char)>) */
|
|
|
|
void V_URLEncodeInternal(bad_function_call *param_1,int param_2,byte *param_3,int param_4,
|
|
char param_5,bad_function_call *param_6)
|
|
|
|
{
|
|
byte *pbVar1;
|
|
byte bVar2;
|
|
byte bVar3;
|
|
char cVar4;
|
|
byte *pbVar5;
|
|
char *pcVar6;
|
|
bad_function_call *this;
|
|
int iVar7;
|
|
int iVar8;
|
|
int iVar9;
|
|
byte local_39 [9];
|
|
|
|
if (param_4 < 1) {
|
|
iVar8 = 0;
|
|
LAB_0011fcf6:
|
|
if (iVar8 < param_2) {
|
|
*(undefined1 *)((long)¶m_1->vftablePtr + (long)iVar8) = 0;
|
|
return;
|
|
}
|
|
}
|
|
else if (2 < param_2) {
|
|
iVar8 = 0;
|
|
pbVar1 = param_3 + (param_4 - 1);
|
|
iVar7 = 2;
|
|
this = param_1;
|
|
iVar9 = iVar8;
|
|
if (param_5 == '\0') {
|
|
do {
|
|
local_39[0] = *param_3;
|
|
if (param_6[2].vftablePtr == (bad_function_call_vftable *)0x0) {
|
|
LAB_0011fdfb:
|
|
/* WARNING: Subroutine does not return */
|
|
std::bad_function_call::~bad_function_call(this);
|
|
}
|
|
this = param_6;
|
|
cVar4 = (*(code *)param_6[3].vftablePtr)(param_6,local_39);
|
|
pbVar5 = (byte *)((long)¶m_1->vftablePtr + (long)iVar8);
|
|
if (cVar4 == '\0') {
|
|
*pbVar5 = *param_3;
|
|
iVar8 = iVar8 + 1;
|
|
}
|
|
else {
|
|
*pbVar5 = 0x25;
|
|
bVar2 = *param_3;
|
|
pcVar6 = (char *)((long)¶m_1->vftablePtr + (long)(iVar8 + 1));
|
|
pbVar5 = (byte *)((long)¶m_1->vftablePtr + (long)iVar7);
|
|
iVar8 = iVar8 + 3;
|
|
if (bVar2 == 0) {
|
|
*pcVar6 = '0';
|
|
*pbVar5 = 0x30;
|
|
}
|
|
else {
|
|
bVar3 = "0123456789ABCDEF"[bVar2 & 0xf];
|
|
this = (bad_function_call *)(ulong)bVar3;
|
|
*pcVar6 = "0123456789ABCDEF"[bVar2 >> 4];
|
|
*pbVar5 = bVar3;
|
|
}
|
|
}
|
|
if (param_3 == pbVar1) goto LAB_0011fcf6;
|
|
iVar7 = iVar8 + 2;
|
|
param_3 = param_3 + 1;
|
|
} while (iVar7 < param_2);
|
|
}
|
|
else {
|
|
do {
|
|
local_39[0] = *param_3;
|
|
if (param_6[2].vftablePtr == (bad_function_call_vftable *)0x0) goto LAB_0011fdfb;
|
|
this = param_6;
|
|
cVar4 = (*(code *)param_6[3].vftablePtr)(param_6,local_39);
|
|
iVar8 = iVar9 + 1;
|
|
pbVar5 = (byte *)((long)¶m_1->vftablePtr + (long)iVar9);
|
|
if (cVar4 == '\0') {
|
|
*pbVar5 = *param_3;
|
|
}
|
|
else if (*param_3 == 0x20) {
|
|
*pbVar5 = 0x2b;
|
|
}
|
|
else {
|
|
*pbVar5 = 0x25;
|
|
bVar2 = *param_3;
|
|
pcVar6 = (char *)((long)¶m_1->vftablePtr + (long)iVar8);
|
|
pbVar5 = (byte *)((long)¶m_1->vftablePtr + (long)iVar7);
|
|
iVar8 = iVar9 + 3;
|
|
if (bVar2 == 0) {
|
|
*pcVar6 = '0';
|
|
*pbVar5 = 0x30;
|
|
}
|
|
else {
|
|
bVar3 = "0123456789ABCDEF"[bVar2 & 0xf];
|
|
this = (bad_function_call *)(ulong)bVar3;
|
|
*pcVar6 = "0123456789ABCDEF"[bVar2 >> 4];
|
|
*pbVar5 = bVar3;
|
|
}
|
|
}
|
|
if (param_3 == pbVar1) goto LAB_0011fcf6;
|
|
iVar7 = iVar8 + 2;
|
|
param_3 = param_3 + 1;
|
|
iVar9 = iVar8;
|
|
} while (iVar7 < param_2);
|
|
}
|
|
}
|
|
*(undefined1 *)¶m_1->vftablePtr = 0;
|
|
return;
|
|
}
|
|
|
|
|
|
// 0011fe00 V_URLDecodeInternal
|
|
|
|
/* V_URLDecodeInternal(char*, int, char const*, int, bool) */
|
|
|
|
undefined8 V_URLDecodeInternal(char *param_1,int param_2,char *param_3,int param_4,bool param_5)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if (param_4 <= param_2) {
|
|
uVar1 = V_URLDecodeInternal(param_1,param_2,param_3,param_4,param_5);
|
|
return uVar1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0011fe20 V_URLEncode
|
|
|
|
/* V_URLEncode(char*, int, char const*, int) */
|
|
|
|
void V_URLEncode(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
undefined4 in_register_00000034;
|
|
long in_FS_OFFSET;
|
|
code *local_48 [2];
|
|
code *local_38;
|
|
code *pcStack_30;
|
|
long local_20;
|
|
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
local_48[0] = CharNeedsEscape_Component;
|
|
local_38 = std::_Function_base::_Base_manager<bool(*)(char)>::_M_manager;
|
|
pcStack_30 = std::_Function_handler<bool(char),bool(*)(char)>::_M_invoke;
|
|
V_URLEncodeInternal(param_1,CONCAT44(in_register_00000034,param_2),param_3,param_4,1,local_48);
|
|
if (local_38 != (code *)0x0) {
|
|
(*local_38)(local_48,local_48,3);
|
|
}
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011feb0 V_URLEncodeNoPlusForSpace
|
|
|
|
/* V_URLEncodeNoPlusForSpace(char*, int, char const*, int) */
|
|
|
|
void V_URLEncodeNoPlusForSpace(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
undefined4 in_register_00000034;
|
|
long in_FS_OFFSET;
|
|
code *local_48 [2];
|
|
code *local_38;
|
|
code *pcStack_30;
|
|
long local_20;
|
|
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
local_48[0] = CharNeedsEscape_Component;
|
|
local_38 = std::_Function_base::_Base_manager<bool(*)(char)>::_M_manager;
|
|
pcStack_30 = std::_Function_handler<bool(char),bool(*)(char)>::_M_invoke;
|
|
V_URLEncodeInternal(param_1,CONCAT44(in_register_00000034,param_2),param_3,param_4,0,local_48);
|
|
if (local_38 != (code *)0x0) {
|
|
(*local_38)(local_48,local_48,3);
|
|
}
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011ff40 V_URLEncodeFullPath
|
|
|
|
/* V_URLEncodeFullPath(char*, int, char const*, int) */
|
|
|
|
void V_URLEncodeFullPath(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
undefined4 in_register_00000034;
|
|
long in_FS_OFFSET;
|
|
code *local_48 [2];
|
|
code *local_38;
|
|
code *pcStack_30;
|
|
long local_20;
|
|
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
local_48[0] = CharNeedsEscape_FullPath;
|
|
local_38 = std::_Function_base::_Base_manager<bool(*)(char)>::_M_manager;
|
|
pcStack_30 = std::_Function_handler<bool(char),bool(*)(char)>::_M_invoke;
|
|
V_URLEncodeInternal(param_1,CONCAT44(in_register_00000034,param_2),param_3,param_4,0,local_48);
|
|
if (local_38 != (code *)0x0) {
|
|
(*local_38)(local_48,local_48,3);
|
|
}
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 0011ffd0 V_URLDecode
|
|
|
|
/* V_URLDecode(char*, int, char const*, int) */
|
|
|
|
undefined8 V_URLDecode(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if (param_4 <= param_2) {
|
|
uVar1 = V_URLDecodeInternal(param_1,param_2,param_3,param_4,true);
|
|
return uVar1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0011fff0 V_URLDecodeNoPlusForSpace
|
|
|
|
/* V_URLDecodeNoPlusForSpace(char*, int, char const*, int) */
|
|
|
|
undefined8 V_URLDecodeNoPlusForSpace(char *param_1,int param_2,char *param_3,int param_4)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if (param_4 <= param_2) {
|
|
uVar1 = V_URLDecodeInternal(param_1,param_2,param_3,param_4,false);
|
|
return uVar1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 00120010 V_StripExtension
|
|
|
|
/* V_StripExtension(std::string&) */
|
|
|
|
void V_StripExtension(string *param_1)
|
|
|
|
{
|
|
ulong uVar1;
|
|
ulong uVar2;
|
|
|
|
uVar1 = std::string::rfind(param_1,'.',0xffffffffffffffff);
|
|
if (uVar1 != 0xffffffffffffffff) {
|
|
uVar2 = std::string::rfind(param_1,'\\',0xffffffffffffffff);
|
|
if (uVar2 < uVar1) {
|
|
uVar2 = std::string::rfind(param_1,'/',0xffffffffffffffff);
|
|
if (uVar2 < uVar1) {
|
|
std::string::resize(param_1,uVar1,'\0');
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001203c0 RepairUTF8
|
|
|
|
/* RepairUTF8(std::string const&, std::string&) */
|
|
|
|
void RepairUTF8(string *param_1,string *param_2)
|
|
|
|
{
|
|
codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0> *this;
|
|
|
|
this = *(codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0> **)param_1;
|
|
std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>::
|
|
~codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>
|
|
(this,(char *)((long)&this->vftablePtr +
|
|
(long)&(this[-3].vftablePtr)->
|
|
~codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>),param_2);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001203e0 TrimTrailingWhitespace
|
|
|
|
/* TrimTrailingWhitespace(std::string const&) */
|
|
|
|
string * TrimTrailingWhitespace(string *param_1)
|
|
|
|
{
|
|
long lVar1;
|
|
string *in_RSI;
|
|
|
|
lVar1 = std::string::find_last_not_of(in_RSI," \t\n\r",0xffffffffffffffff,4);
|
|
if (lVar1 != -1) {
|
|
std::string::string(param_1,in_RSI,0,lVar1 + 1);
|
|
return param_1;
|
|
}
|
|
std::string::string(param_1,in_RSI);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 00120450 Format
|
|
|
|
/* Format(char const*, ...) */
|
|
|
|
char * Format(char *param_1,...)
|
|
|
|
{
|
|
char in_AL;
|
|
int iVar1;
|
|
char *pcVar2;
|
|
undefined8 in_RCX;
|
|
undefined8 in_RDX;
|
|
undefined8 in_RSI;
|
|
undefined8 in_R8;
|
|
undefined8 in_R9;
|
|
long in_FS_OFFSET;
|
|
undefined8 in_XMM0_Qa;
|
|
undefined8 in_XMM1_Qa;
|
|
undefined8 in_XMM2_Qa;
|
|
undefined8 in_XMM3_Qa;
|
|
undefined8 in_XMM4_Qa;
|
|
undefined8 in_XMM5_Qa;
|
|
undefined8 in_XMM6_Qa;
|
|
undefined8 in_XMM7_Qa;
|
|
allocator local_1119;
|
|
undefined1 local_1118 [16];
|
|
undefined8 local_1108;
|
|
undefined4 local_1100;
|
|
undefined4 local_10fc;
|
|
undefined1 *local_10f8;
|
|
undefined1 *local_10f0;
|
|
char local_10e8 [4104];
|
|
long local_e0;
|
|
undefined1 local_d8 [16];
|
|
undefined8 local_c8;
|
|
undefined8 local_c0;
|
|
undefined8 local_b8;
|
|
undefined8 local_b0;
|
|
undefined8 local_a8;
|
|
undefined8 local_98;
|
|
undefined8 local_88;
|
|
undefined8 local_78;
|
|
undefined8 local_68;
|
|
undefined8 local_58;
|
|
undefined8 local_48;
|
|
undefined8 local_38;
|
|
|
|
if (in_AL != '\0') {
|
|
local_a8 = in_XMM0_Qa;
|
|
local_98 = in_XMM1_Qa;
|
|
local_88 = in_XMM2_Qa;
|
|
local_78 = in_XMM3_Qa;
|
|
local_68 = in_XMM4_Qa;
|
|
local_58 = in_XMM5_Qa;
|
|
local_48 = in_XMM6_Qa;
|
|
local_38 = in_XMM7_Qa;
|
|
}
|
|
local_e0 = *(long *)(in_FS_OFFSET + 0x28);
|
|
local_10f8 = &stack0x00000008;
|
|
local_1100 = 0x10;
|
|
local_10f0 = local_d8;
|
|
local_10fc = 0x30;
|
|
local_c8 = in_RDX;
|
|
local_c0 = in_RCX;
|
|
local_b8 = in_R8;
|
|
local_b0 = in_R9;
|
|
iVar1 = __vsnprintf_chk(local_10e8,0x1000,1,0x1000,in_RSI,&local_1100);
|
|
if (iVar1 < 0) {
|
|
pcVar2 = (char *)CAssert::GetInstance();
|
|
CAssert::AssertMsgImpl(pcVar2,0x1b56f0,true,0,1,"Format string parse failure");
|
|
std::string::string((string *)param_1,"",(allocator *)local_1118);
|
|
}
|
|
else if (iVar1 < 0x1000) {
|
|
std::string::string((string *)param_1,local_10e8,(allocator *)local_1118);
|
|
}
|
|
else {
|
|
local_1108 = 0;
|
|
local_1118 = (undefined1 [16])0x0;
|
|
std::vector<char,std::allocator<char>>::_M_default_append
|
|
((vector<char,std::allocator<char>> *)local_1118,(long)(iVar1 + 1));
|
|
local_10f8 = &stack0x00000008;
|
|
local_10f0 = local_d8;
|
|
local_1100 = 0x10;
|
|
local_10fc = 0x30;
|
|
iVar1 = __vsnprintf_chk(local_1118._0_8_,local_1118._8_8_ - local_1118._0_8_,1,
|
|
0xffffffffffffffff,in_RSI,&local_1100);
|
|
if (iVar1 < 0) {
|
|
pcVar2 = (char *)CAssert::GetInstance();
|
|
CAssert::AssertMsgImpl(pcVar2,0x1b56f0,true,0,1,"Format string parse failure");
|
|
std::string::string((string *)param_1,"",&local_1119);
|
|
}
|
|
else {
|
|
std::string::string((string *)param_1,(char *)local_1118._0_8_,&local_1119);
|
|
}
|
|
if ((void *)local_1118._0_8_ != (void *)0x0) {
|
|
operator_delete((void *)local_1118._0_8_);
|
|
}
|
|
}
|
|
if (local_e0 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return param_1;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 001206c0 IpToString
|
|
|
|
/* IpToString(unsigned int) */
|
|
|
|
undefined8 IpToString(uint param_1)
|
|
|
|
{
|
|
uint in_ESI;
|
|
undefined4 in_register_0000003c;
|
|
|
|
Format((char *)CONCAT44(in_register_0000003c,param_1),"%d.%d.%d.%d",(ulong)(in_ESI >> 0x18),
|
|
(ulong)(in_ESI >> 0x10 & 0xff),(ulong)(in_ESI >> 8 & 0xff),(ulong)(in_ESI & 0xff));
|
|
return CONCAT44(in_register_0000003c,param_1);
|
|
}
|
|
|
|
|
|
// 00120700 IpAndPortToString
|
|
|
|
/* IpAndPortToString(unsigned int, unsigned short) */
|
|
|
|
undefined8 IpAndPortToString(uint param_1,ushort param_2)
|
|
|
|
{
|
|
ushort in_DX;
|
|
uint6 in_register_00000032;
|
|
undefined4 in_register_0000003c;
|
|
|
|
Format((char *)CONCAT44(in_register_0000003c,param_1),"%d.%d.%d.%d:%u",
|
|
((ulong)in_register_00000032 & 0xff00) >> 8,(ulong)(byte)in_register_00000032,
|
|
(ulong)(byte)(param_2 >> 8),(ulong)param_2 & 0xff,(ulong)in_DX);
|
|
return CONCAT44(in_register_0000003c,param_1);
|
|
}
|
|
|
|
|
|
// 00120750 TokenizeString
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x00120b78) */
|
|
/* WARNING: Removing unreachable block (ram,0x00120bd7) */
|
|
/* WARNING: Removing unreachable block (ram,0x00120b6d) */
|
|
/* TokenizeString(std::string const&, char) */
|
|
|
|
void * __thiscall TokenizeString(void *this,char param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char *pcVar3;
|
|
string *this_00;
|
|
long lVar4;
|
|
long lVar5;
|
|
long *plVar6;
|
|
istream *piVar7;
|
|
char in_DL;
|
|
undefined7 in_register_00000031;
|
|
allocator local_1ba [2];
|
|
undefined1 *local_1b8;
|
|
long local_1b0;
|
|
undefined **local_1a8;
|
|
undefined8 local_1a0;
|
|
stringbuf_vftable *local_198;
|
|
undefined8 local_190;
|
|
undefined8 local_188;
|
|
undefined8 local_180;
|
|
undefined8 local_178;
|
|
undefined8 local_170;
|
|
undefined8 local_168;
|
|
locale local_160 [8];
|
|
undefined4 local_158;
|
|
char *local_150;
|
|
undefined1 local_148 [248];
|
|
undefined1 local_50 [16];
|
|
|
|
*(undefined1 (*) [16])this = (undefined1 [16])0x0;
|
|
*(undefined8 *)((long)this + 0x10) = 0;
|
|
std::ios_base::ios_base((ios_base *)local_148);
|
|
local_148._232_16_ = (undefined1 [16])0x0;
|
|
local_148._216_8_ = 0;
|
|
local_50 = (undefined1 [16])0x0;
|
|
local_148._224_2_ = 0;
|
|
local_1a8 = std::istream-in-std::istringstream::construction_vftable;
|
|
local_148._0_8_ = std::istream-in-std::istringstream::internal_construction_vftable;
|
|
local_1a0 = 0;
|
|
std::ios::init((ios *)local_148,(streambuf *)0x0);
|
|
local_190 = 0;
|
|
local_188 = 0;
|
|
local_180 = 0;
|
|
local_178 = 0;
|
|
local_170 = 0;
|
|
local_1a8 = std::istringstream::vftable;
|
|
local_168 = 0;
|
|
local_148._0_8_ = std::istringstream::internal_vftable;
|
|
local_198 = (stringbuf_vftable *)&std::streambuf::vftable;
|
|
std::locale::locale(local_160);
|
|
local_158 = 0;
|
|
pcVar3 = *(char **)CONCAT71(in_register_00000031,param_1);
|
|
local_198 = &std::stringbuf::vftable;
|
|
std::string::string((string *)&local_150,pcVar3,*(ulong *)(pcVar3 + -0x18),(allocator *)&local_1b0
|
|
);
|
|
local_158 = 8;
|
|
if (-1 < *(int *)(local_150 + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_150);
|
|
}
|
|
std::stringbuf::_M_sync((stringbuf *)&local_198,local_150,0,0);
|
|
std::ios::init((ios *)local_148,(streambuf *)&local_198);
|
|
local_1b8 = &DAT_001f8498;
|
|
while (piVar7 = std::getline<char,std::char_traits<char>,std::allocator<char>>
|
|
((istream *)&local_1a8,(string *)&local_1b8,in_DL),
|
|
((byte)piVar7[*(long *)(*(long *)piVar7 + -0x18) + 0x20] & 5) == 0) {
|
|
while (this_00 = *(string **)((long)this + 8), this_00 != *(string **)((long)this + 0x10)) {
|
|
std::string::string(this_00,(string *)&local_1b8);
|
|
*(long *)((long)this + 8) = *(long *)((long)this + 8) + 8;
|
|
piVar7 = std::getline<char,std::char_traits<char>,std::allocator<char>>
|
|
((istream *)&local_1a8,(string *)&local_1b8,in_DL);
|
|
if (((byte)piVar7[*(long *)(*(long *)piVar7 + -0x18) + 0x20] & 5) != 0) goto LAB_001209ac;
|
|
}
|
|
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string_const&>
|
|
(this,this_00,(string *)&local_1b8);
|
|
}
|
|
LAB_001209ac:
|
|
lVar4 = *(long *)CONCAT71(in_register_00000031,param_1);
|
|
lVar5 = *(long *)(lVar4 + -0x18);
|
|
if ((lVar5 != 0) && (*(char *)(lVar4 + -1 + lVar5) == in_DL)) {
|
|
std::string::string((string *)&local_1b0,"",local_1ba);
|
|
plVar6 = *(long **)((long)this + 8);
|
|
if (plVar6 == *(long **)((long)this + 0x10)) {
|
|
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
|
|
(this,plVar6,(allocator *)&local_1b0);
|
|
if ((allocator *)(local_1b0 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage)
|
|
{
|
|
LOCK();
|
|
piVar1 = (int *)(local_1b0 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_1b0 + -0x18));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
*plVar6 = local_1b0;
|
|
*(long *)((long)this + 8) = *(long *)((long)this + 8) + 8;
|
|
}
|
|
}
|
|
if ((allocator *)(local_1b8 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_1b8 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_1b8 + -0x18));
|
|
}
|
|
}
|
|
local_1a8 = std::istringstream::vftable;
|
|
local_148._0_8_ = std::istringstream::internal_vftable;
|
|
local_198 = &std::stringbuf::vftable;
|
|
if ((allocator *)(local_150 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_150 + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_150 + -0x18));
|
|
}
|
|
}
|
|
local_198 = (stringbuf_vftable *)&std::streambuf::vftable;
|
|
std::locale::~locale(local_160);
|
|
local_1a8 = std::istream-in-std::istringstream::construction_vftable;
|
|
local_1a0 = 0;
|
|
local_148._0_8_ = &std::ios::vftable;
|
|
std::ios_base::~ios_base((ios_base *)local_148);
|
|
return this;
|
|
}
|
|
|
|
|
|
// 00121460 StringListToJson
|
|
|
|
/* StringListToJson(std::vector<std::string, std::allocator<std::string > > const&, Json::Value&,
|
|
char const*) */
|
|
|
|
void StringListToJson(vector *param_1,Value *param_2,char *param_3)
|
|
|
|
{
|
|
Value *this;
|
|
string *psVar1;
|
|
Value local_58 [48];
|
|
|
|
this = (Value *)Json::Value::operator[](param_2,param_3);
|
|
psVar1 = *(string **)param_1;
|
|
if (psVar1 != *(string **)(param_1 + 8)) {
|
|
do {
|
|
Json::Value::Value(local_58,psVar1);
|
|
Json::Value::append(this,local_58);
|
|
psVar1 = psVar1 + 8;
|
|
Json::Value::~Value(local_58);
|
|
} while (*(string **)(param_1 + 8) != psVar1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 00121f30 ParseStringListFromJson
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x001220f0) */
|
|
/* WARNING: Removing unreachable block (ram,0x001220f8) */
|
|
/* WARNING: Removing unreachable block (ram,0x001222b0) */
|
|
/* WARNING: Removing unreachable block (ram,0x001222c3) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122109) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122112) */
|
|
/* WARNING: Removing unreachable block (ram,0x0012200b) */
|
|
/* WARNING: Removing unreachable block (ram,0x001220a6) */
|
|
/* WARNING: Removing unreachable block (ram,0x001220b7) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122080) */
|
|
/* WARNING: Removing unreachable block (ram,0x001220d7) */
|
|
/* WARNING: Removing unreachable block (ram,0x0012208d) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122170) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122181) */
|
|
/* WARNING: Removing unreachable block (ram,0x001220a2) */
|
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
|
|
/* ParseStringListFromJson(std::vector<std::string, std::allocator<std::string > >*, Json::Value
|
|
const&, char const*) */
|
|
|
|
void ParseStringListFromJson(vector *param_1,Value *param_2,char *param_3)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
int *piVar2;
|
|
int iVar3;
|
|
long *plVar4;
|
|
long *plVar5;
|
|
string *this;
|
|
undefined8 uVar6;
|
|
char cVar7;
|
|
uint uVar8;
|
|
uint uVar9;
|
|
stringbuf *this_00;
|
|
ulong uVar10;
|
|
undefined8 *puVar11;
|
|
ulong uVar12;
|
|
ulong uVar13;
|
|
undefined8 *puVar14;
|
|
undefined8 *puVar15;
|
|
long lVar16;
|
|
undefined8 *puVar17;
|
|
long *plVar18;
|
|
long lVar19;
|
|
long local_40 [2];
|
|
|
|
cVar7 = Json::Value::isMember(param_2,param_3);
|
|
if (cVar7 != '\0') {
|
|
this_00 = (stringbuf *)Json::Value::operator[](param_2,param_3);
|
|
cVar7 = Json::Value::operator!((Value *)this_00);
|
|
if (cVar7 != '\0') {
|
|
__fprintf_chk(_stderr,1,"VR Path Registry node %s is not an array\n",param_3);
|
|
return;
|
|
}
|
|
plVar4 = *(long **)param_1;
|
|
plVar5 = *(long **)(param_1 + 8);
|
|
plVar18 = plVar4;
|
|
if (plVar4 != plVar5) {
|
|
do {
|
|
paVar1 = (allocator *)(*plVar18 + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(*plVar18 + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar1);
|
|
}
|
|
}
|
|
plVar18 = plVar18 + 1;
|
|
} while (plVar5 != plVar18);
|
|
*(long **)(param_1 + 8) = plVar4;
|
|
}
|
|
uVar8 = Json::Value::size((Value *)this_00);
|
|
puVar17 = *(undefined8 **)param_1;
|
|
uVar10 = (ulong)uVar8;
|
|
if ((ulong)(*(long *)(param_1 + 0x10) - (long)puVar17 >> 3) < uVar10) {
|
|
puVar15 = *(undefined8 **)(param_1 + 8);
|
|
puVar11 = (undefined8 *)0x0;
|
|
lVar19 = (long)puVar15 - (long)puVar17;
|
|
if (uVar10 != 0) {
|
|
puVar11 = operator_new(uVar10 * 8);
|
|
puVar15 = *(undefined8 **)(param_1 + 8);
|
|
puVar17 = *(undefined8 **)param_1;
|
|
}
|
|
if (puVar15 != puVar17) {
|
|
uVar12 = (long)puVar15 + (-8 - (long)puVar17);
|
|
puVar14 = puVar11;
|
|
if (((ulong)((long)puVar11 + (0xf - (long)puVar17)) < 0x1f) || (uVar12 < 0x21)) {
|
|
do {
|
|
uVar6 = *puVar17;
|
|
puVar17 = puVar17 + 1;
|
|
*puVar14 = uVar6;
|
|
puVar14 = puVar14 + 1;
|
|
} while (puVar15 != puVar17);
|
|
}
|
|
else {
|
|
uVar12 = (uVar12 >> 3) + 1;
|
|
lVar16 = 0;
|
|
do {
|
|
uVar6 = ((undefined8 *)((long)puVar17 + lVar16))[1];
|
|
*(undefined8 *)((long)puVar11 + lVar16) = *(undefined8 *)((long)puVar17 + lVar16);
|
|
((undefined8 *)((long)puVar11 + lVar16))[1] = uVar6;
|
|
lVar16 = lVar16 + 0x10;
|
|
} while ((uVar12 >> 1) * 0x10 != lVar16);
|
|
uVar13 = uVar12 & 0xfffffffffffffffe;
|
|
if (uVar12 != uVar13) {
|
|
puVar11[uVar13] = puVar17[uVar13];
|
|
}
|
|
}
|
|
puVar17 = *(undefined8 **)param_1;
|
|
}
|
|
if (puVar17 != (undefined8 *)0x0) {
|
|
operator_delete(puVar17);
|
|
}
|
|
*(undefined8 **)param_1 = puVar11;
|
|
*(long *)(param_1 + 8) = lVar19 + (long)puVar11;
|
|
*(undefined8 **)(param_1 + 0x10) = puVar11 + uVar10;
|
|
}
|
|
for (uVar8 = 0; uVar9 = Json::Value::size((Value *)this_00), uVar8 < uVar9; uVar8 = uVar8 + 1) {
|
|
std::stringbuf::stringbuf(this_00,uVar8);
|
|
Json::Value::asString();
|
|
this = *(string **)(param_1 + 8);
|
|
if (this == *(string **)(param_1 + 0x10)) {
|
|
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string_const&>
|
|
((vector<std::string,std::allocator<std::string>> *)param_1,this,
|
|
(string *)local_40);
|
|
}
|
|
else {
|
|
std::string::string(this,(string *)local_40);
|
|
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 8;
|
|
}
|
|
if ((allocator *)(local_40[0] + -0x18) !=
|
|
(allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(local_40[0] + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 00122860 FUN_00122860
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x00122950) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122a0e) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122a03) */
|
|
/* WARNING: Removing unreachable block (ram,0x00122870) */
|
|
|
|
undefined8 FUN_00122860(void)
|
|
|
|
{
|
|
int *piVar1;
|
|
allocator *paVar2;
|
|
int iVar3;
|
|
ios_base *this;
|
|
long unaff_RBP;
|
|
allocator *unaff_R13;
|
|
|
|
paVar2 = (allocator *)(*(long *)(unaff_RBP + -0x230) + -0x18);
|
|
if (paVar2 != unaff_R13) {
|
|
LOCK();
|
|
piVar1 = (int *)(*(long *)(unaff_RBP + -0x230) + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar2);
|
|
}
|
|
}
|
|
*(undefined ***)(unaff_RBP + -0x1a0) = std::istringstream::vftable;
|
|
*(undefined ***)(unaff_RBP + -0x140) = std::istringstream::internal_vftable;
|
|
*(stringbuf_vftable **)(unaff_RBP + -400) = &std::stringbuf::vftable;
|
|
paVar2 = (allocator *)(*(long *)(unaff_RBP + -0x148) + -0x18);
|
|
if (paVar2 != unaff_R13) {
|
|
LOCK();
|
|
piVar1 = (int *)(*(long *)(unaff_RBP + -0x148) + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar2);
|
|
}
|
|
}
|
|
*(streambuf_vftable **)(unaff_RBP + -400) = &std::streambuf::vftable;
|
|
std::locale::~locale(*(locale **)(unaff_RBP + -0x270));
|
|
this = *(ios_base **)(unaff_RBP + -0x260);
|
|
*(long *)(unaff_RBP + -0x1a0) = *(long *)(unaff_RBP + -0x278);
|
|
*(undefined8 *)(unaff_RBP + -0x1a0 + *(long *)(*(long *)(unaff_RBP + -0x278) + -0x18)) =
|
|
*(undefined8 *)(unaff_RBP + -0x280);
|
|
*(undefined8 *)(unaff_RBP + -0x198) = 0;
|
|
*(ios_vftable **)(unaff_RBP + -0x140) = &std::ios::vftable;
|
|
std::ios_base::~ios_base(this);
|
|
Json::CharReaderBuilder::~CharReaderBuilder(*(CharReaderBuilder **)(unaff_RBP + -0x268));
|
|
Json::Value::~Value(*(Value **)(unaff_RBP + -600));
|
|
paVar2 = (allocator *)(*(long *)(unaff_RBP + -0x238) + -0x18);
|
|
if (paVar2 != unaff_R13) {
|
|
LOCK();
|
|
piVar1 = (int *)(*(long *)(unaff_RBP + -0x238) + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar2);
|
|
}
|
|
}
|
|
paVar2 = (allocator *)(*(long *)(unaff_RBP + -0x240) + -0x18);
|
|
if (paVar2 != unaff_R13) {
|
|
LOCK();
|
|
piVar1 = (int *)(*(long *)(unaff_RBP + -0x240) + -8);
|
|
iVar3 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar2);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 00132ce1 FUN_00132ce1
|
|
|
|
void FUN_00132ce1(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 0013fa20 FileSelect
|
|
|
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
|
|
/* FileSelect(dirent const*) */
|
|
|
|
bool FileSelect(dirent *param_1)
|
|
|
|
{
|
|
byte bVar1;
|
|
char cVar2;
|
|
uint uVar3;
|
|
int iVar4;
|
|
int iVar5;
|
|
char cVar6;
|
|
byte *pbVar7;
|
|
char *pcVar8;
|
|
bool bVar9;
|
|
|
|
if (*(short *)param_1->d_name == 0x2e) {
|
|
return false;
|
|
}
|
|
pcVar8 = param_1->d_name;
|
|
if ((*(short *)param_1->d_name == 0x2e2e) && (param_1->d_name[2] == '\0')) {
|
|
return false;
|
|
}
|
|
if ((_selectBuf == 0x2a2e2a) || (_selectBuf == 0x2a)) {
|
|
LAB_0013fb00:
|
|
bVar9 = true;
|
|
}
|
|
else {
|
|
uVar3 = _selectBuf & 0xff;
|
|
cVar6 = param_1->d_name[0];
|
|
if ((char)_selectBuf != '\0') {
|
|
pbVar7 = &DAT_001f5cc1;
|
|
do {
|
|
if (cVar6 == '\0') {
|
|
return pbVar7[-1] == 0;
|
|
}
|
|
cVar2 = (char)uVar3;
|
|
if (cVar2 == '*') {
|
|
if (*pbVar7 == 0) goto LAB_0013fb00;
|
|
iVar4 = toupper((int)(char)*pbVar7);
|
|
while (iVar5 = toupper((int)cVar6), iVar5 != iVar4) {
|
|
cVar6 = pcVar8[1];
|
|
pcVar8 = pcVar8 + 1;
|
|
if (cVar6 == '\0') {
|
|
return false;
|
|
}
|
|
}
|
|
cVar6 = *pcVar8;
|
|
}
|
|
else if (cVar2 == '?') {
|
|
cVar6 = pcVar8[1];
|
|
pcVar8 = pcVar8 + 1;
|
|
}
|
|
else {
|
|
iVar4 = toupper((int)cVar2);
|
|
iVar5 = toupper((int)cVar6);
|
|
if (iVar4 != iVar5) {
|
|
return false;
|
|
}
|
|
cVar6 = pcVar8[1];
|
|
pcVar8 = pcVar8 + 1;
|
|
if (cVar6 == '\0' && *pbVar7 == 0) goto LAB_0013fb00;
|
|
}
|
|
bVar1 = *pbVar7;
|
|
uVar3 = (uint)bVar1;
|
|
pbVar7 = pbVar7 + 1;
|
|
} while (bVar1 != 0);
|
|
}
|
|
bVar9 = cVar6 == '\0';
|
|
}
|
|
return bVar9;
|
|
}
|
|
|
|
|
|
// 0013fb80 BCreateDirectory
|
|
|
|
/* BCreateDirectory(char const*) */
|
|
|
|
bool BCreateDirectory(char *param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
int *piVar2;
|
|
bool bVar3;
|
|
|
|
iVar1 = mkdir(param_1,0x1ff);
|
|
bVar3 = true;
|
|
if (iVar1 != 0) {
|
|
piVar2 = __errno_location();
|
|
bVar3 = *piVar2 == 0x11;
|
|
}
|
|
return bVar3;
|
|
}
|
|
|
|
|
|
// 0013fbb0 BCreateDirectoryRecursive
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x0013fdcd) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fc5f) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fd10) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fd15) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fcd0) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fda7) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fdb8) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fcfe) */
|
|
/* WARNING: Removing unreachable block (ram,0x0013fd05) */
|
|
/* BCreateDirectoryRecursive(char const*) */
|
|
|
|
undefined4 BCreateDirectoryRecursive(char *param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
char cVar3;
|
|
char cVar4;
|
|
undefined4 uVar5;
|
|
size_t sVar6;
|
|
char *__dest;
|
|
char *pcVar7;
|
|
allocator local_42 [2];
|
|
long local_40 [2];
|
|
|
|
std::string::string((string *)local_40,param_1,local_42);
|
|
uVar5 = Path_IsDirectory((string *)local_40);
|
|
if ((allocator *)(local_40[0] + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
if ((char)uVar5 == '\0') {
|
|
sVar6 = strlen(param_1);
|
|
__dest = malloc((long)((int)sVar6 + 1));
|
|
memcpy(__dest,param_1,sVar6 + 1);
|
|
pcVar7 = __dest + (long)(int)sVar6 + -1;
|
|
cVar3 = Path_GetSlash();
|
|
if (pcVar7 <= __dest) goto LAB_0013fcb4;
|
|
do {
|
|
if (*pcVar7 == cVar3) {
|
|
*pcVar7 = '\0';
|
|
std::string::string((string *)local_40,__dest,local_42);
|
|
cVar4 = Path_IsDirectory((string *)local_40);
|
|
if ((allocator *)(local_40[0] + -0x18) !=
|
|
(allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)(local_40[0] + -8);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_40[0] + -0x18));
|
|
}
|
|
}
|
|
*pcVar7 = cVar3;
|
|
if (cVar4 != '\0') goto LAB_0013fcb0;
|
|
}
|
|
pcVar7 = pcVar7 + -1;
|
|
} while (__dest != pcVar7);
|
|
cVar4 = *__dest;
|
|
pcVar7 = __dest;
|
|
while (cVar4 != '\0') {
|
|
if (cVar3 == cVar4) {
|
|
*pcVar7 = '\0';
|
|
BCreateDirectory(__dest);
|
|
*pcVar7 = cVar3;
|
|
}
|
|
LAB_0013fcb0:
|
|
pcVar7 = pcVar7 + 1;
|
|
LAB_0013fcb4:
|
|
cVar4 = *pcVar7;
|
|
}
|
|
uVar5 = BCreateDirectory(__dest);
|
|
free(__dest);
|
|
}
|
|
return uVar5;
|
|
}
|
|
|
|
|
|
// 0013ff70 FillDataStruct
|
|
|
|
/* FillDataStruct(_finddata_t*) */
|
|
|
|
undefined8 FillDataStruct(_finddata_t *param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
uint uVar2;
|
|
int iVar3;
|
|
undefined8 uVar4;
|
|
long in_FS_OFFSET;
|
|
stat local_1b8;
|
|
char local_128 [264];
|
|
long local_20;
|
|
|
|
uVar4 = 0xffffffff;
|
|
local_20 = *(long *)(in_FS_OFFSET + 0x28);
|
|
if (*(int *)(param_1 + 0x228) < *(int *)(param_1 + 0x22c)) {
|
|
strncpy((char *)param_1,
|
|
(char *)(*(long *)(*(long *)(param_1 + 0x230) + (long)*(int *)(param_1 + 0x228) * 8) +
|
|
0x13),0x104);
|
|
cVar1 = Path_GetSlash();
|
|
uVar2 = __snprintf_chk(local_128,0x104,1,0x104,"%s%c%s",param_1 + 0x104);
|
|
if (0x103 < uVar2) {
|
|
Log(1,"File path truncated\n",(int)cVar1,param_1);
|
|
}
|
|
iVar3 = __xstat(1,local_128,&local_1b8);
|
|
if (iVar3 == 0) {
|
|
*(__time_t *)(param_1 + 0x218) = local_1b8.st_mtim.tv_sec;
|
|
*(__time_t *)(param_1 + 0x220) = local_1b8.st_ctim.tv_sec;
|
|
*(__mode_t *)(param_1 + 0x210) = local_1b8.st_mode;
|
|
*(__off_t *)(param_1 + 0x208) = local_1b8.st_size;
|
|
}
|
|
else {
|
|
*(undefined4 *)(param_1 + 0x210) = 0;
|
|
*(undefined8 *)(param_1 + 0x208) = 0;
|
|
*(undefined1 (*) [16])(param_1 + 0x218) = (undefined1 [16])0x0;
|
|
}
|
|
free(*(void **)(*(long *)(param_1 + 0x230) + (long)*(int *)(param_1 + 0x228) * 8));
|
|
uVar4 = 1;
|
|
*(undefined8 *)(*(long *)(param_1 + 0x230) + (long)*(int *)(param_1 + 0x228) * 8) = 0;
|
|
*(int *)(param_1 + 0x228) = *(int *)(param_1 + 0x228) + 1;
|
|
}
|
|
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return uVar4;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 001401e0 _findfirst
|
|
|
|
/* _findfirst(char const*, _finddata_t*) */
|
|
|
|
ulong _findfirst(char *param_1,_finddata_t *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
uint uVar2;
|
|
uint uVar3;
|
|
uint *puVar4;
|
|
ulong uVar5;
|
|
uint *puVar6;
|
|
char *pcVar7;
|
|
long in_FS_OFFSET;
|
|
stat local_1c8;
|
|
uint local_138 [66];
|
|
long local_30;
|
|
|
|
local_30 = *(long *)(in_FS_OFFSET + 0x28);
|
|
strncpy((char *)local_138,param_1,0x104);
|
|
puVar4 = (uint *)strrchr((char *)local_138,0x2f);
|
|
if (puVar4 != (uint *)0x0) {
|
|
do {
|
|
*(char *)puVar4 = '\0';
|
|
if (puVar4 == local_138) {
|
|
local_138[0]._0_2_ = 0x2f;
|
|
}
|
|
iVar1 = __xstat(1,(char *)local_138,&local_1c8);
|
|
} while (((iVar1 != 0) || ((local_1c8.st_mode & 0xf000) != 0x4000)) &&
|
|
(puVar4 = (uint *)strrchr((char *)local_138,0x2f), puVar4 != (uint *)0x0));
|
|
puVar4 = local_138;
|
|
if ((char)local_138[0] != '\0') {
|
|
do {
|
|
puVar6 = puVar4;
|
|
uVar2 = *puVar6 + 0xfefefeff & ~*puVar6;
|
|
uVar3 = uVar2 & 0x80808080;
|
|
puVar4 = puVar6 + 1;
|
|
} while (uVar3 == 0);
|
|
if ((uVar2 & 0x8080) == 0) {
|
|
puVar4 = (uint *)((long)puVar6 + 6);
|
|
uVar3 = uVar3 >> 0x10;
|
|
}
|
|
pcVar7 = (char *)((long)puVar4 +
|
|
((-3 - (ulong)CARRY1((byte)uVar3,(byte)uVar3)) - (long)local_138));
|
|
if (pcVar7 == (char *)0x1) {
|
|
strncpy(&selectBuf,param_1 + 1,0x1000);
|
|
}
|
|
else {
|
|
strncpy(&selectBuf,param_1 + (long)(pcVar7 + 1),0x1000);
|
|
}
|
|
iVar1 = scandir((char *)local_138,(dirent ***)(param_2 + 0x230),FileSelect,alphasort);
|
|
if (-1 < iVar1) {
|
|
*(undefined4 *)(param_2 + 0x228) = 0;
|
|
*(int *)(param_2 + 0x22c) = iVar1;
|
|
strncpy((char *)(param_2 + 0x104),(char *)local_138,0x104);
|
|
uVar5 = FillDataStruct(param_2);
|
|
if ((int)uVar5 < 0) {
|
|
free(*(void **)(param_2 + 0x230));
|
|
uVar5 = uVar5 & 0xffffffff;
|
|
*(undefined8 *)(param_2 + 0x228) = 0;
|
|
*(undefined8 *)(param_2 + 0x230) = 0;
|
|
}
|
|
goto LAB_0014034e;
|
|
}
|
|
}
|
|
}
|
|
uVar5 = 0xffffffff;
|
|
LAB_0014034e:
|
|
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return uVar5;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
|
|
|
|
// 001406c0 _findnext
|
|
|
|
/* _findnext(long, _finddata_t*) */
|
|
|
|
undefined8 _findnext(long param_1,_finddata_t *param_2)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if (*(int *)(param_2 + 0x228) < *(int *)(param_2 + 0x22c)) {
|
|
FillDataStruct(param_2);
|
|
uVar1 = 0;
|
|
}
|
|
else {
|
|
free(*(void **)(param_2 + 0x230));
|
|
uVar1 = 0xffffffff;
|
|
*(undefined8 *)(param_2 + 0x228) = 0;
|
|
*(undefined8 *)(param_2 + 0x230) = 0;
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 00140720 _findclose
|
|
|
|
/* _findclose(long) */
|
|
|
|
undefined8 _findclose(long param_1)
|
|
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 00140770 GetEnvironmentVariable
|
|
|
|
/* GetEnvironmentVariable(char const*) */
|
|
|
|
char * GetEnvironmentVariable(char *param_1)
|
|
|
|
{
|
|
char *pcVar1;
|
|
char *in_RSI;
|
|
allocator local_19 [9];
|
|
|
|
pcVar1 = getenv(in_RSI);
|
|
if (pcVar1 != (char *)0x0) {
|
|
std::string::string((string *)param_1,pcVar1,local_19);
|
|
return param_1;
|
|
}
|
|
std::string::string((string *)param_1,"",local_19);
|
|
return param_1;
|
|
}
|
|
|
|
|
|
// 001407d0 GetEnvironmentVariableAsBool
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x00140a50) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140bb0) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140bc1) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140a66) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140a6b) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140a79) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140bd8) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140be9) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140a8f) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140a94) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140c40) */
|
|
/* WARNING: Removing unreachable block (ram,0x00140c30) */
|
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
|
|
/* GetEnvironmentVariableAsBool(char const*, bool) */
|
|
|
|
ulong GetEnvironmentVariableAsBool(char *param_1,bool param_2)
|
|
|
|
{
|
|
allocator *paVar1;
|
|
int *piVar2;
|
|
size_t __n;
|
|
int iVar3;
|
|
long lVar4;
|
|
undefined7 in_register_00000031;
|
|
char *__nptr;
|
|
string *psVar5;
|
|
string *psVar6;
|
|
ulong uVar7;
|
|
string *local_a8;
|
|
char *local_88;
|
|
long local_80;
|
|
string local_78 [8];
|
|
string local_70 [8];
|
|
string local_68 [8];
|
|
string local_60 [8];
|
|
string local_58 [8];
|
|
string local_50 [8];
|
|
string local_48 [8];
|
|
string local_40 [16];
|
|
|
|
uVar7 = CONCAT71(in_register_00000031,param_2) & 0xffffffff;
|
|
GetEnvironmentVariable((char *)&local_88);
|
|
if (*(long *)(local_88 + -0x18) != 0) {
|
|
StringToLower((string *)&local_80);
|
|
std::string::swap((string *)&local_88,(string *)&local_80);
|
|
if ((allocator *)(local_80 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(local_80 + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_80 + -0x18));
|
|
}
|
|
}
|
|
std::string::string(local_78,"y",(allocator *)local_58);
|
|
std::string::string(local_70,"yes",(allocator *)local_58);
|
|
std::string::string(local_68,"true",(allocator *)local_58);
|
|
std::string::string(local_58,"n",(allocator *)&local_80);
|
|
std::string::string(local_50,"no",(allocator *)&local_80);
|
|
std::string::string(local_48,"false",(allocator *)&local_80);
|
|
__nptr = local_88;
|
|
psVar6 = local_60;
|
|
__n = *(size_t *)(local_88 + -0x18);
|
|
psVar5 = local_78;
|
|
do {
|
|
if ((*(size_t *)((long)*(void **)psVar5 + -0x18) == __n) &&
|
|
((__n == 0 || (iVar3 = memcmp(*(void **)psVar5,__nptr,__n), iVar3 == 0)))) {
|
|
uVar7 = 1;
|
|
goto LAB_001409e2;
|
|
}
|
|
psVar5 = psVar5 + 8;
|
|
} while (psVar6 != psVar5);
|
|
psVar5 = local_58;
|
|
do {
|
|
if ((__n == *(size_t *)((long)*(void **)psVar5 + -0x18)) &&
|
|
((__n == 0 || (iVar3 = memcmp(*(void **)psVar5,__nptr,__n), iVar3 == 0)))) {
|
|
uVar7 = 0;
|
|
goto LAB_001409e2;
|
|
}
|
|
psVar5 = psVar5 + 8;
|
|
} while (psVar5 != local_40);
|
|
if (__n == 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::__throw_out_of_range_fmt
|
|
("basic_string::at: __n (which is %zu) >= this->size() (which is %zu)",0);
|
|
}
|
|
if (-1 < *(int *)(__nptr + -8)) {
|
|
std::string::_M_leak_hard((string *)&local_88);
|
|
__nptr = local_88;
|
|
}
|
|
if ((int)*__nptr - 0x30U < 10) {
|
|
lVar4 = strtol(__nptr,(char **)0x0,10);
|
|
uVar7 = CONCAT71((int7)(uVar7 >> 8),(int)lVar4 != 0);
|
|
}
|
|
else {
|
|
__fprintf_chk(_stderr,1,
|
|
"GetEnvironmentVariableAsBool(%s): Unable to parse value \'%s\', using default %d\n"
|
|
,param_1,__nptr,param_2);
|
|
}
|
|
LAB_001409e2:
|
|
local_a8 = local_40;
|
|
do {
|
|
psVar5 = local_a8 + -8;
|
|
local_a8 = local_a8 + -8;
|
|
paVar1 = (allocator *)(*(long *)psVar5 + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(*(long *)psVar5 + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar1);
|
|
}
|
|
}
|
|
} while (local_a8 != local_58);
|
|
do {
|
|
psVar5 = psVar6 + -8;
|
|
psVar6 = psVar6 + -8;
|
|
paVar1 = (allocator *)(*(long *)psVar5 + -0x18);
|
|
if (paVar1 != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(*(long *)psVar5 + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy(paVar1);
|
|
}
|
|
}
|
|
} while (psVar6 != local_78);
|
|
}
|
|
if ((allocator *)(local_88 + -0x18) != (allocator *)&std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar2 = (int *)(local_88 + -8);
|
|
iVar3 = *piVar2;
|
|
*piVar2 = *piVar2 + -1;
|
|
UNLOCK();
|
|
if (iVar3 < 1) {
|
|
std::string::_Rep::_M_destroy((allocator *)(local_88 + -0x18));
|
|
}
|
|
}
|
|
return uVar7;
|
|
}
|
|
|
|
|
|
// 00140cc0 SetEnvironmentVariable
|
|
|
|
/* SetEnvironmentVariable(char const*, char const*) */
|
|
|
|
bool SetEnvironmentVariable(char *param_1,char *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
if (param_2 != (char *)0x0) {
|
|
iVar1 = setenv(param_1,param_2,1);
|
|
return iVar1 == 0;
|
|
}
|
|
iVar1 = unsetenv(param_1);
|
|
return iVar1 == 0;
|
|
}
|
|
|
|
|
|
// 00141190 LogHelper
|
|
|
|
/* LogHelper(ELogLevel, char const*, __va_list_tag (&) [1]) */
|
|
|
|
void LogHelper(undefined4 param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
CLog *pCVar1;
|
|
|
|
pCVar1 = (CLog *)CLog::GetInstance();
|
|
if (pCVar1 != (CLog *)0x0) {
|
|
CLog::Log(pCVar1,param_1,param_2,param_3);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 00141220 Log
|
|
|
|
/* Log(ELogLevel, char const*, ...) */
|
|
|
|
void Log(undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,
|
|
undefined8 param_5,undefined8 param_6,undefined8 param_7,undefined8 param_8,
|
|
undefined8 param_9,undefined8 param_10,undefined8 param_11,undefined8 param_12,
|
|
undefined8 param_13,undefined8 param_14,...)
|
|
|
|
{
|
|
char in_AL;
|
|
undefined4 local_d0;
|
|
undefined4 local_cc;
|
|
undefined1 *local_c8;
|
|
undefined1 *local_c0;
|
|
undefined1 local_b8 [16];
|
|
undefined8 local_a8;
|
|
undefined8 local_a0;
|
|
undefined8 local_98;
|
|
undefined8 local_90;
|
|
undefined8 local_88;
|
|
undefined8 local_78;
|
|
undefined8 local_68;
|
|
undefined8 local_58;
|
|
undefined8 local_48;
|
|
undefined8 local_38;
|
|
undefined8 local_28;
|
|
undefined8 local_18;
|
|
|
|
if (in_AL != '\0') {
|
|
local_88 = param_1;
|
|
local_78 = param_2;
|
|
local_68 = param_3;
|
|
local_58 = param_4;
|
|
local_48 = param_5;
|
|
local_38 = param_6;
|
|
local_28 = param_7;
|
|
local_18 = param_8;
|
|
}
|
|
local_d0 = 0x10;
|
|
local_c8 = &stack0x00000008;
|
|
local_c0 = local_b8;
|
|
local_cc = 0x30;
|
|
local_a8 = param_11;
|
|
local_a0 = param_12;
|
|
local_98 = param_13;
|
|
local_90 = param_14;
|
|
LogHelper(param_9,param_10,&local_d0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001412b0 Log
|
|
|
|
/* Log(char const*, ...) */
|
|
|
|
void Log(char *param_1,...)
|
|
|
|
{
|
|
char in_AL;
|
|
undefined8 in_RCX;
|
|
undefined8 in_RDX;
|
|
undefined8 in_RSI;
|
|
undefined8 in_R8;
|
|
undefined8 in_R9;
|
|
undefined8 in_XMM0_Qa;
|
|
undefined8 in_XMM1_Qa;
|
|
undefined8 in_XMM2_Qa;
|
|
undefined8 in_XMM3_Qa;
|
|
undefined8 in_XMM4_Qa;
|
|
undefined8 in_XMM5_Qa;
|
|
undefined8 in_XMM6_Qa;
|
|
undefined8 in_XMM7_Qa;
|
|
undefined4 local_d0;
|
|
undefined4 local_cc;
|
|
undefined1 *local_c8;
|
|
undefined1 *local_c0;
|
|
undefined1 local_b8 [8];
|
|
undefined8 local_b0;
|
|
undefined8 local_a8;
|
|
undefined8 local_a0;
|
|
undefined8 local_98;
|
|
undefined8 local_90;
|
|
undefined8 local_88;
|
|
undefined8 local_78;
|
|
undefined8 local_68;
|
|
undefined8 local_58;
|
|
undefined8 local_48;
|
|
undefined8 local_38;
|
|
undefined8 local_28;
|
|
undefined8 local_18;
|
|
|
|
if (in_AL != '\0') {
|
|
local_88 = in_XMM0_Qa;
|
|
local_78 = in_XMM1_Qa;
|
|
local_68 = in_XMM2_Qa;
|
|
local_58 = in_XMM3_Qa;
|
|
local_48 = in_XMM4_Qa;
|
|
local_38 = in_XMM5_Qa;
|
|
local_28 = in_XMM6_Qa;
|
|
local_18 = in_XMM7_Qa;
|
|
}
|
|
local_c8 = &stack0x00000008;
|
|
local_d0 = 8;
|
|
local_c0 = local_b8;
|
|
local_cc = 0x30;
|
|
local_b0 = in_RSI;
|
|
local_a8 = in_RDX;
|
|
local_a0 = in_RCX;
|
|
local_98 = in_R8;
|
|
local_90 = in_R9;
|
|
LogHelper(3,param_1,&local_d0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00141350 LogDirect
|
|
|
|
/* LogDirect(ELogLevel, char const*, __va_list_tag (&) [1]) */
|
|
|
|
void LogDirect(undefined4 param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
CLog *pCVar1;
|
|
|
|
pCVar1 = (CLog *)CLog::GetInstance();
|
|
if (pCVar1 != (CLog *)0x0) {
|
|
CLog::Log(pCVar1,param_1,param_2,param_3);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001416a0 GetIDForVRInitError
|
|
|
|
/* GetIDForVRInitError(vr::EVRInitError) */
|
|
|
|
char * GetIDForVRInitError(uint param_1)
|
|
|
|
{
|
|
char *pcVar1;
|
|
|
|
if (param_1 < 0x45c) {
|
|
/* WARNING: Could not recover jumptable at 0x001416b8. Too many branches */
|
|
/* WARNING: Treating indirect jump as call */
|
|
pcVar1 = (char *)(*(code *)(&DAT_001ba4a0 + *(int *)(&DAT_001ba4a0 + (ulong)param_1 * 4)))();
|
|
return pcVar1;
|
|
}
|
|
if (param_1 == 2000) {
|
|
return "VRInitError_Steam_SteamInstallationNotFound";
|
|
}
|
|
__sprintf_chk(GetIDForVRInitError(vr::EVRInitError)::buf,1,0x80,"Unknown error (%d)",param_1);
|
|
return GetIDForVRInitError(vr::EVRInitError)::buf;
|
|
}
|
|
|
|
|
|
// 00141d90 GetEnglishStringForHmdError
|
|
|
|
/* GetEnglishStringForHmdError(vr::EVRInitError) */
|
|
|
|
char * GetEnglishStringForHmdError(uint param_1)
|
|
|
|
{
|
|
char *pcVar1;
|
|
|
|
switch(param_1) {
|
|
case 0:
|
|
return "No Error (0)";
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 0xb:
|
|
case 0xc:
|
|
case 0xd:
|
|
case 0xe:
|
|
case 0xf:
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
case 0x18:
|
|
case 0x19:
|
|
case 0x1a:
|
|
case 0x1b:
|
|
case 0x1c:
|
|
case 0x1d:
|
|
case 0x1e:
|
|
case 0x1f:
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2a:
|
|
case 0x2b:
|
|
case 0x2c:
|
|
case 0x2d:
|
|
case 0x2e:
|
|
case 0x2f:
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3c:
|
|
case 0x3d:
|
|
case 0x3e:
|
|
case 0x3f:
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4a:
|
|
case 0x4b:
|
|
case 0x4c:
|
|
case 0x4d:
|
|
case 0x4e:
|
|
case 0x4f:
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
case 0x58:
|
|
case 0x59:
|
|
case 0x5a:
|
|
case 0x5b:
|
|
case 0x5c:
|
|
case 0x5d:
|
|
case 0x5e:
|
|
case 0x5f:
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 99:
|
|
case 0x8d:
|
|
case 0x8e:
|
|
case 0x8f:
|
|
case 0x90:
|
|
case 0x91:
|
|
case 0x92:
|
|
case 0x93:
|
|
case 0x94:
|
|
case 0x95:
|
|
case 0x96:
|
|
case 0x97:
|
|
case 0x98:
|
|
case 0x99:
|
|
case 0x9a:
|
|
case 0x9b:
|
|
case 0x9c:
|
|
case 0x9d:
|
|
case 0x9e:
|
|
case 0x9f:
|
|
case 0xa8:
|
|
case 0xa9:
|
|
case 0xaa:
|
|
case 0xab:
|
|
case 0xac:
|
|
case 0xad:
|
|
case 0xae:
|
|
case 0xaf:
|
|
case 0xb0:
|
|
case 0xb1:
|
|
case 0xb2:
|
|
case 0xb3:
|
|
case 0xb4:
|
|
case 0xb5:
|
|
case 0xb6:
|
|
case 0xb7:
|
|
case 0xb8:
|
|
case 0xb9:
|
|
case 0xba:
|
|
case 0xbb:
|
|
case 0xbc:
|
|
case 0xbd:
|
|
case 0xbe:
|
|
case 0xbf:
|
|
case 0xc0:
|
|
case 0xc1:
|
|
case 0xc2:
|
|
case 0xc3:
|
|
case 0xc4:
|
|
case 0xc5:
|
|
case 0xc6:
|
|
case 199:
|
|
case 0xd2:
|
|
case 0xd6:
|
|
case 0xd7:
|
|
case 0xd8:
|
|
case 0xd9:
|
|
case 0xda:
|
|
case 0xdb:
|
|
case 0xdc:
|
|
case 0xdd:
|
|
case 0xde:
|
|
case 0xdf:
|
|
case 0xe0:
|
|
case 0xe1:
|
|
case 0xe2:
|
|
case 0xe3:
|
|
case 0xe4:
|
|
case 0xe5:
|
|
case 0xe6:
|
|
case 0xe7:
|
|
case 0xe8:
|
|
case 0xe9:
|
|
case 0xea:
|
|
case 0xeb:
|
|
case 0xec:
|
|
case 0xed:
|
|
case 0xee:
|
|
case 0xef:
|
|
case 0xf0:
|
|
case 0xf1:
|
|
case 0xf2:
|
|
case 0xf3:
|
|
case 0xf4:
|
|
case 0xf5:
|
|
case 0xf6:
|
|
case 0xf7:
|
|
case 0xf8:
|
|
case 0xf9:
|
|
case 0xfa:
|
|
case 0xfb:
|
|
case 0xfc:
|
|
case 0xfd:
|
|
case 0xfe:
|
|
case 0xff:
|
|
case 0x100:
|
|
case 0x101:
|
|
case 0x102:
|
|
case 0x103:
|
|
case 0x104:
|
|
case 0x105:
|
|
case 0x106:
|
|
case 0x107:
|
|
case 0x108:
|
|
case 0x109:
|
|
case 0x10a:
|
|
case 0x10b:
|
|
case 0x10c:
|
|
case 0x10d:
|
|
case 0x10e:
|
|
case 0x10f:
|
|
case 0x110:
|
|
case 0x111:
|
|
case 0x112:
|
|
case 0x113:
|
|
case 0x114:
|
|
case 0x115:
|
|
case 0x116:
|
|
case 0x117:
|
|
case 0x118:
|
|
case 0x119:
|
|
case 0x11a:
|
|
case 0x11b:
|
|
case 0x11c:
|
|
case 0x11d:
|
|
case 0x11e:
|
|
case 0x11f:
|
|
case 0x120:
|
|
case 0x121:
|
|
case 0x122:
|
|
case 0x123:
|
|
case 0x124:
|
|
case 0x125:
|
|
case 0x126:
|
|
case 0x127:
|
|
case 0x128:
|
|
case 0x129:
|
|
case 0x12a:
|
|
case 299:
|
|
case 0x137:
|
|
case 0x138:
|
|
case 0x139:
|
|
case 0x13a:
|
|
case 0x13b:
|
|
case 0x13c:
|
|
case 0x13d:
|
|
case 0x13e:
|
|
case 0x13f:
|
|
case 0x140:
|
|
case 0x141:
|
|
case 0x142:
|
|
case 0x143:
|
|
case 0x144:
|
|
case 0x145:
|
|
case 0x146:
|
|
case 0x147:
|
|
case 0x148:
|
|
case 0x149:
|
|
case 0x14a:
|
|
case 0x14b:
|
|
case 0x14c:
|
|
case 0x14d:
|
|
case 0x14e:
|
|
case 0x14f:
|
|
case 0x150:
|
|
case 0x151:
|
|
case 0x152:
|
|
case 0x153:
|
|
case 0x154:
|
|
case 0x155:
|
|
case 0x156:
|
|
case 0x157:
|
|
case 0x158:
|
|
case 0x159:
|
|
case 0x15a:
|
|
case 0x15b:
|
|
case 0x15c:
|
|
case 0x15d:
|
|
case 0x15e:
|
|
case 0x15f:
|
|
case 0x160:
|
|
case 0x161:
|
|
case 0x162:
|
|
case 0x163:
|
|
case 0x164:
|
|
case 0x165:
|
|
case 0x166:
|
|
case 0x167:
|
|
case 0x168:
|
|
case 0x169:
|
|
case 0x16a:
|
|
case 0x16b:
|
|
case 0x16c:
|
|
case 0x16d:
|
|
case 0x16e:
|
|
case 0x16f:
|
|
case 0x170:
|
|
case 0x171:
|
|
case 0x172:
|
|
case 0x173:
|
|
case 0x174:
|
|
case 0x175:
|
|
case 0x176:
|
|
case 0x177:
|
|
case 0x178:
|
|
case 0x179:
|
|
case 0x17a:
|
|
case 0x17b:
|
|
case 0x17c:
|
|
case 0x17d:
|
|
case 0x17e:
|
|
case 0x17f:
|
|
case 0x180:
|
|
case 0x181:
|
|
case 0x182:
|
|
case 0x183:
|
|
case 0x184:
|
|
case 0x185:
|
|
case 0x186:
|
|
case 0x187:
|
|
case 0x188:
|
|
case 0x189:
|
|
case 0x18a:
|
|
case 0x18b:
|
|
case 0x18c:
|
|
case 0x18d:
|
|
case 0x18e:
|
|
case 399:
|
|
goto switchD_00141da8_caseD_1;
|
|
case 100:
|
|
return "Installation Not Found (100)";
|
|
case 0x65:
|
|
return "Installation Corrupt (101)";
|
|
case 0x66:
|
|
return "vrclient Shared Lib Not Found (102)";
|
|
case 0x67:
|
|
return "File Not Found (103)";
|
|
case 0x68:
|
|
return "Factory Function Not Found (104)";
|
|
case 0x69:
|
|
return "Interface Not Found (105)";
|
|
case 0x6a:
|
|
return "Invalid Interface (106)";
|
|
case 0x6b:
|
|
return "User Config Directory Invalid (107)";
|
|
case 0x6c:
|
|
return "Hmd Not Found (108)";
|
|
case 0x6d:
|
|
return "Not Initialized (109)";
|
|
case 0x6e:
|
|
return "Installation path could not be located (110)";
|
|
case 0x6f:
|
|
return "Config path could not be located (111)";
|
|
case 0x70:
|
|
return "Log path could not be located (112)";
|
|
case 0x71:
|
|
return "Unable to write path registry (113)";
|
|
case 0x72:
|
|
return "App info manager init failed (114)";
|
|
case 0x73:
|
|
return "Internal Retry (115)";
|
|
case 0x74:
|
|
return "User Canceled Init (116)";
|
|
case 0x75:
|
|
return "Another app was already launching (117)";
|
|
case 0x76:
|
|
return "Settings manager init failed (118)";
|
|
case 0x77:
|
|
return "VR system shutting down (119)";
|
|
case 0x78:
|
|
return "Too many tracked objects (120)";
|
|
case 0x79:
|
|
return "Not starting vrserver for background app (121)";
|
|
case 0x7a:
|
|
return
|
|
"The requested interface is incompatible with the compositor and the compositor is running (122)"
|
|
;
|
|
case 0x7b:
|
|
return "This interface is not available to utility applications (123)";
|
|
case 0x7c:
|
|
return "vrserver internal error (124)";
|
|
case 0x7d:
|
|
return "Hmd DriverId is invalid (125)";
|
|
case 0x7e:
|
|
return "Hmd Not Found Presence Failed (126)";
|
|
case 0x7f:
|
|
return "VR Monitor Not Found (127)";
|
|
case 0x80:
|
|
return "VR Monitor startup failed (128)";
|
|
case 0x81:
|
|
return "Low Power Watchdog Not Supported (129)";
|
|
case 0x82:
|
|
return "Invalid Application Type (130)";
|
|
case 0x83:
|
|
return "Not available to watchdog apps (131)";
|
|
case 0x84:
|
|
return "Watchdog disabled in settings (132)";
|
|
case 0x85:
|
|
return "VR Dashboard Not Found (133)";
|
|
case 0x86:
|
|
return "VR Dashboard startup failed (134)";
|
|
case 0x87:
|
|
return "VR Home Not Found (135)";
|
|
case 0x88:
|
|
return "VR home startup failed (136)";
|
|
case 0x89:
|
|
return "Rebooting In Progress (137)";
|
|
case 0x8a:
|
|
return "Firmware Update In Progress (138)";
|
|
case 0x8b:
|
|
return "Firmware Recovery In Progress (139)";
|
|
case 0x8c:
|
|
return "USB Service Busy (140)";
|
|
case 0xa0:
|
|
return "VR Dashboard startup failed, vrservice was pending for too long (160)";
|
|
case 0xa1:
|
|
return "VR Dashboard startup failed, attempt to communicate with vrservice timed out (161)";
|
|
case 0xa2:
|
|
return "VR Dashboard startup failed, vrservice was stopped (162)";
|
|
case 0xa3:
|
|
return "VR Dashboard startup failed, vrdashboard was already running (163)";
|
|
case 0xa4:
|
|
return "VR Dashboard startup failed, required files did not copy correctly (164)";
|
|
case 0xa5:
|
|
return "VR Dashboard startup failed, unable to create appropriate token (165)";
|
|
case 0xa6:
|
|
return "VR Dashboard startup failed, unable to create appropriate environment (166)";
|
|
case 0xa7:
|
|
return "VR Dashboard startup failed, path error (167)";
|
|
case 200:
|
|
return "Driver Failed (200)";
|
|
case 0xc9:
|
|
return "Driver Not Known (201)";
|
|
case 0xca:
|
|
return "HMD Not Known (202)";
|
|
case 0xcb:
|
|
return "Driver Not Loaded (203)";
|
|
case 0xcc:
|
|
return "Driver runtime is out of date (204)";
|
|
case 0xcd:
|
|
return "HMD already in use by another application (205)";
|
|
case 0xce:
|
|
return "Device is not calibrated (206)";
|
|
case 0xcf:
|
|
return "Device Calibration is invalid (207)";
|
|
case 0xd0:
|
|
return "HMD detected over USB, but Monitor not found (208)";
|
|
case 0xd1:
|
|
return "Driver Tracked Device Interface unknown (209)";
|
|
case 0xd3:
|
|
return "Hmd DriverId is our of bounds (211)";
|
|
case 0xd4:
|
|
return "HMD detected over USB, but Monitor may be mirrored instead of extended (212)";
|
|
case 0xd5:
|
|
return "On laptop, HMD detected over USB, but Monitor not found (213)";
|
|
case 300:
|
|
return "VR Server Init Failed (300)";
|
|
case 0x12d:
|
|
return "Connect to VR Server Failed (301)";
|
|
case 0x12e:
|
|
return "Shared IPC State Init Failed (302)";
|
|
case 0x12f:
|
|
return "Shared IPC Compositor Init Failed (303)";
|
|
case 0x130:
|
|
return "Shared IPC Mutex Init Failed (304)";
|
|
case 0x131:
|
|
return "Shared IPC Failed (305)";
|
|
case 0x132:
|
|
return "Shared IPC Compositor Connect Failed (306)";
|
|
case 0x133:
|
|
return "Shared IPC Compositor Invalid Connect Response (307)";
|
|
case 0x134:
|
|
return "Shared IPC Connect Failed After Multiple Attempts (308)";
|
|
case 0x135:
|
|
return "Shared IPC Connect Failed After Target Exited (309)";
|
|
case 0x136:
|
|
return "Shared IPC Namespace Unavailable (310)";
|
|
case 400:
|
|
return "Compositor failed to initialize (400)";
|
|
case 0x191:
|
|
return "Compositor failed to find DX11 hardware (401)";
|
|
case 0x192:
|
|
return "Compositor requires mandatory firmware update (402)";
|
|
case 0x193:
|
|
return "Compositor initialization succeeded, but overlay init failed (403)";
|
|
case 0x194:
|
|
return "Compositor initialization succeeded, but screenshot init failed (404)";
|
|
case 0x195:
|
|
return "Compositor unable to create graphics device (405)";
|
|
default:
|
|
if (param_1 < 0x45c) {
|
|
if (999 < param_1) {
|
|
switch(param_1) {
|
|
case 1000:
|
|
return "Unable to connect to Oculus Runtime (1000)";
|
|
case 0x44d:
|
|
return "HMD found, but can not open device (1101)";
|
|
case 0x44e:
|
|
return "HMD found, but unable to request config (1102)";
|
|
case 0x44f:
|
|
return "HMD found, but no stored config (1103)";
|
|
case 0x450:
|
|
return "HMD found, but config too big (1104)";
|
|
case 0x451:
|
|
return "HMD found, but config too small (1105)";
|
|
case 0x452:
|
|
return "HMD found, but unable to init ZLib (1106)";
|
|
case 0x453:
|
|
return "HMD found, but problems with the data (1107)";
|
|
case 0x454:
|
|
return "HMD found, but problems with the data (1108)";
|
|
case 0x455:
|
|
return "HMD found, but problems with the data (1109)";
|
|
case 0x456:
|
|
return "HMD found, but problems with the data (1110)";
|
|
case 0x457:
|
|
return "HMD found, but problems with the data (1111)";
|
|
case 0x458:
|
|
return "HMD found, but problems with the data (1112)";
|
|
case 0x459:
|
|
return "HMD found, but failed configuration check (1113)";
|
|
case 0x45a:
|
|
return "Unable to connect to Oculus Runtime, possible bad install (1114)";
|
|
case 0x45b:
|
|
return "HMD found, but problems with the data (1115)";
|
|
}
|
|
}
|
|
}
|
|
else if (param_1 == 2000) {
|
|
return "Unable to find Steam installation (2000)";
|
|
}
|
|
switchD_00141da8_caseD_1:
|
|
pcVar1 = (char *)GetIDForVRInitError();
|
|
return pcVar1;
|
|
}
|
|
}
|
|
|
|
|
|
// 00142340 operator.delete
|
|
|
|
/* operator delete(void*) */
|
|
|
|
void operator_delete(void *param_1)
|
|
|
|
{
|
|
free(param_1);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142350 operator.delete
|
|
|
|
/* operator delete(void*, unsigned long) */
|
|
|
|
void operator_delete(void *param_1,ulong param_2)
|
|
|
|
{
|
|
free(param_1);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142360 operator.delete[]
|
|
|
|
/* operator delete[](void*) */
|
|
|
|
void operator_delete__(void *param_1)
|
|
|
|
{
|
|
free(param_1);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142370 operator.delete[]
|
|
|
|
/* operator delete[](void*, unsigned long) */
|
|
|
|
void operator_delete__(void *param_1,ulong param_2)
|
|
|
|
{
|
|
free(param_1);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142670 __cxa_allocate_exception
|
|
|
|
undefined8 * __cxa_allocate_exception(long param_1)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
ulong uVar2;
|
|
undefined8 *puVar3;
|
|
byte bVar4;
|
|
|
|
bVar4 = 0;
|
|
puVar1 = malloc(param_1 + 0x80U);
|
|
if (puVar1 == (undefined8 *)0x0) {
|
|
puVar1 = (undefined8 *)(anonymous_namespace)::pool::allocate(param_1 + 0x80U);
|
|
if (puVar1 == (undefined8 *)0x0) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
}
|
|
*puVar1 = 0;
|
|
puVar1[0xf] = 0;
|
|
puVar3 = (undefined8 *)((ulong)(puVar1 + 1) & 0xfffffffffffffff8);
|
|
for (uVar2 = (ulong)(((int)puVar1 - (int)(undefined8 *)((ulong)(puVar1 + 1) & 0xfffffffffffffff8))
|
|
+ 0x80U >> 3); uVar2 != 0; uVar2 = uVar2 - 1) {
|
|
*puVar3 = 0;
|
|
puVar3 = puVar3 + (ulong)bVar4 * -2 + 1;
|
|
}
|
|
return puVar1 + 0x10;
|
|
}
|
|
|
|
|
|
// 001426d0 __cxa_free_exception
|
|
|
|
void __cxa_free_exception(long param_1)
|
|
|
|
{
|
|
void *__ptr;
|
|
|
|
__ptr = (void *)(param_1 + -0x80);
|
|
if (((ulong)(anonymous_namespace)::emergency_pool._48_8_ < __ptr) &&
|
|
(__ptr < (void *)((anonymous_namespace)::emergency_pool._48_8_ +
|
|
(anonymous_namespace)::emergency_pool._56_8_))) {
|
|
(anonymous_namespace)::pool::free(__ptr);
|
|
return;
|
|
}
|
|
free(__ptr);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142710 __cxa_allocate_dependent_exception
|
|
|
|
undefined8 * __cxa_allocate_dependent_exception(void)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
ulong uVar2;
|
|
undefined8 *puVar3;
|
|
byte bVar4;
|
|
|
|
bVar4 = 0;
|
|
puVar1 = malloc(0x70);
|
|
if ((puVar1 == (undefined8 *)0x0) &&
|
|
(puVar1 = (undefined8 *)(anonymous_namespace)::pool::allocate(0x70),
|
|
puVar1 == (undefined8 *)0x0)) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
*puVar1 = 0;
|
|
puVar1[0xd] = 0;
|
|
puVar3 = (undefined8 *)((ulong)(puVar1 + 1) & 0xfffffffffffffff8);
|
|
for (uVar2 = (ulong)(((int)puVar1 - (int)(undefined8 *)((ulong)(puVar1 + 1) & 0xfffffffffffffff8))
|
|
+ 0x70U >> 3); uVar2 != 0; uVar2 = uVar2 - 1) {
|
|
*puVar3 = 0;
|
|
puVar3 = puVar3 + (ulong)bVar4 * -2 + 1;
|
|
}
|
|
return puVar1;
|
|
}
|
|
|
|
|
|
// 00142770 __cxa_free_dependent_exception
|
|
|
|
void __cxa_free_dependent_exception(void *param_1)
|
|
|
|
{
|
|
if (((ulong)(anonymous_namespace)::emergency_pool._48_8_ < param_1) &&
|
|
(param_1 < (void *)((anonymous_namespace)::emergency_pool._48_8_ +
|
|
(anonymous_namespace)::emergency_pool._56_8_))) {
|
|
(anonymous_namespace)::pool::free(param_1);
|
|
return;
|
|
}
|
|
free(param_1);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001427c0 __cxa_get_exception_ptr
|
|
|
|
undefined8 __cxa_get_exception_ptr(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + -8);
|
|
}
|
|
|
|
|
|
// 001427d0 __cxa_begin_catch
|
|
|
|
long __cxa_begin_catch(long *param_1)
|
|
|
|
{
|
|
long *plVar1;
|
|
long *plVar2;
|
|
int iVar3;
|
|
long *plVar4;
|
|
|
|
plVar4 = (long *)__cxa_get_globals();
|
|
plVar1 = param_1 + -10;
|
|
plVar2 = (long *)*plVar4;
|
|
if (*param_1 + 0xb8b1aabcbcd4d500U < 2) {
|
|
iVar3 = (int)param_1[-5];
|
|
if (iVar3 < 0) {
|
|
iVar3 = -iVar3;
|
|
}
|
|
*(int *)(param_1 + -5) = iVar3 + 1;
|
|
*(int *)(plVar4 + 1) = (int)plVar4[1] + -1;
|
|
if (plVar2 != plVar1) {
|
|
param_1[-6] = (long)plVar2;
|
|
*plVar4 = (long)plVar1;
|
|
}
|
|
return param_1[-1];
|
|
}
|
|
if (plVar2 == (long *)0x0) {
|
|
*plVar4 = (long)plVar1;
|
|
return 0;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 00142840 __cxa_end_catch
|
|
|
|
void __cxa_end_catch(void)
|
|
|
|
{
|
|
long lVar1;
|
|
long *plVar2;
|
|
int iVar3;
|
|
|
|
plVar2 = (long *)__cxa_get_globals_fast();
|
|
lVar1 = *plVar2;
|
|
if (lVar1 != 0) {
|
|
if (1 < *(long *)(lVar1 + 0x50) + 0xb8b1aabcbcd4d500U) {
|
|
*plVar2 = 0;
|
|
_Unwind_DeleteException(lVar1 + 0x50);
|
|
return;
|
|
}
|
|
iVar3 = *(int *)(lVar1 + 0x28);
|
|
if (iVar3 < 0) {
|
|
iVar3 = iVar3 + 1;
|
|
if (iVar3 == 0) {
|
|
*plVar2 = *(long *)(lVar1 + 0x20);
|
|
}
|
|
}
|
|
else {
|
|
iVar3 = iVar3 + -1;
|
|
if (iVar3 == 0) {
|
|
*plVar2 = *(long *)(lVar1 + 0x20);
|
|
_Unwind_DeleteException(lVar1 + 0x50);
|
|
return;
|
|
}
|
|
if (iVar3 == -1) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
}
|
|
*(int *)(lVar1 + 0x28) = iVar3;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142a40 __cxa_get_globals_fast
|
|
|
|
undefined8 __cxa_get_globals_fast(void)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
uVar1 = __tls_get_addr(&PTR_001f4c30);
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 00142a60 __cxa_get_globals
|
|
|
|
undefined8 __cxa_get_globals(void)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
uVar1 = __tls_get_addr(&PTR_001f4c30);
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 00142a80 get_adjusted_ptr
|
|
|
|
/* get_adjusted_ptr(std::type_info const*, std::type_info const*, void**) */
|
|
|
|
void get_adjusted_ptr(type_info *param_1,type_info *param_2,void **param_3)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined8 *local_20;
|
|
|
|
local_20 = *param_3;
|
|
cVar1 = (**(code **)(*(long *)param_2 + 0x10))(param_2);
|
|
if (cVar1 != '\0') {
|
|
local_20 = (undefined8 *)*local_20;
|
|
}
|
|
cVar1 = (**(code **)(*(long *)param_1 + 0x20))(param_1,param_2,&local_20,1);
|
|
if (cVar1 != '\0') {
|
|
*param_3 = local_20;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 00142af0 read_encoded_value_with_base
|
|
|
|
/* read_encoded_value_with_base(unsigned char, unsigned long, unsigned char const*, unsigned long*)
|
|
*/
|
|
|
|
ulong * read_encoded_value_with_base(uchar param_1,ulong param_2,uchar *param_3,ulong *param_4)
|
|
|
|
{
|
|
ulong uVar1;
|
|
ulong *puVar2;
|
|
byte bVar3;
|
|
byte bVar4;
|
|
uint uVar5;
|
|
ulong *puVar6;
|
|
ulong uVar7;
|
|
|
|
if (param_1 == 'P') {
|
|
*param_4 = *(ulong *)((ulong)(param_3 + 7) & 0xfffffffffffffff8);
|
|
return (ulong *)((ulong)(param_3 + 7) & 0xfffffffffffffff8) + 1;
|
|
}
|
|
puVar2 = (ulong *)param_3;
|
|
switch(param_1 & 0xf) {
|
|
case 0:
|
|
case 4:
|
|
case 0xc:
|
|
uVar7 = *(ulong *)param_3;
|
|
puVar2 = (ulong *)(param_3 + 8);
|
|
break;
|
|
case 1:
|
|
uVar7 = 0;
|
|
bVar3 = 0;
|
|
do {
|
|
uVar1 = *puVar2;
|
|
puVar2 = (ulong *)((long)puVar2 + 1);
|
|
bVar4 = bVar3 & 0x3f;
|
|
bVar3 = bVar3 + 7;
|
|
uVar7 = uVar7 | (ulong)((byte)uVar1 & 0x7f) << bVar4;
|
|
} while ((char)(byte)uVar1 < '\0');
|
|
break;
|
|
case 2:
|
|
uVar7 = (ulong)*(ushort *)param_3;
|
|
puVar2 = (ulong *)(param_3 + 2);
|
|
break;
|
|
case 3:
|
|
uVar7 = (ulong)*(uint *)param_3;
|
|
puVar2 = (ulong *)(param_3 + 4);
|
|
break;
|
|
default:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
case 9:
|
|
uVar7 = 0;
|
|
uVar5 = 0;
|
|
do {
|
|
bVar3 = (byte)*puVar2;
|
|
puVar2 = (ulong *)((long)puVar2 + 1);
|
|
bVar4 = (byte)uVar5;
|
|
uVar5 = uVar5 + 7;
|
|
uVar7 = uVar7 | (ulong)(bVar3 & 0x7f) << (bVar4 & 0x3f);
|
|
} while ((char)bVar3 < '\0');
|
|
if ((0x3f < uVar5) || ((bVar3 & 0x40) == 0)) break;
|
|
uVar7 = uVar7 | -1L << ((byte)uVar5 & 0x3f);
|
|
goto LAB_00142b2c;
|
|
case 10:
|
|
uVar7 = (ulong)*(short *)param_3;
|
|
puVar2 = (ulong *)(param_3 + 2);
|
|
break;
|
|
case 0xb:
|
|
uVar7 = (ulong)*(int *)param_3;
|
|
puVar2 = (ulong *)(param_3 + 4);
|
|
}
|
|
puVar6 = (ulong *)0x0;
|
|
if (uVar7 != 0) {
|
|
LAB_00142b2c:
|
|
if ((param_1 & 0x70) == 0x10) {
|
|
param_2 = (ulong)param_3;
|
|
}
|
|
puVar6 = (ulong *)(param_2 + uVar7);
|
|
if ((char)param_1 < '\0') {
|
|
*param_4 = *puVar6;
|
|
return puVar2;
|
|
}
|
|
}
|
|
*param_4 = (ulong)puVar6;
|
|
return puVar2;
|
|
}
|
|
|
|
|
|
// 00142c40 get_ttype_entry
|
|
|
|
/* get_ttype_entry(lsda_header_info*, unsigned long) */
|
|
|
|
ulong get_ttype_entry(lsda_header_info *param_1,ulong param_2)
|
|
|
|
{
|
|
lsda_header_info lVar1;
|
|
byte bVar2;
|
|
undefined8 uVar3;
|
|
long lVar4;
|
|
ulong local_10 [2];
|
|
|
|
lVar1 = param_1[0x28];
|
|
if (lVar1 == (lsda_header_info)0xff) {
|
|
lVar4 = 0;
|
|
}
|
|
else {
|
|
bVar2 = (byte)lVar1 & 7;
|
|
if (bVar2 == 2) {
|
|
lVar4 = param_2 * -2;
|
|
}
|
|
else {
|
|
if (bVar2 < 3) {
|
|
if (bVar2 != 0) {
|
|
uVar3 = get_ttype_entry(param_1,param_2);
|
|
return uVar3;
|
|
}
|
|
}
|
|
else {
|
|
lVar4 = param_2 * -4;
|
|
if (bVar2 == 3) goto LAB_00142c6a;
|
|
if (bVar2 != 4) {
|
|
uVar3 = get_ttype_entry(param_1,param_2);
|
|
return uVar3;
|
|
}
|
|
}
|
|
lVar4 = param_2 * -8;
|
|
}
|
|
}
|
|
LAB_00142c6a:
|
|
read_encoded_value_with_base
|
|
((uchar)lVar1,*(ulong *)(param_1 + 0x10),(uchar *)(lVar4 + *(long *)(param_1 + 0x18)),
|
|
local_10);
|
|
return local_10[0];
|
|
}
|
|
|
|
|
|
// 00142ce0 check_exception_spec
|
|
|
|
/* check_exception_spec(lsda_header_info*, std::type_info const*, void*, long) */
|
|
|
|
undefined8
|
|
check_exception_spec(lsda_header_info *param_1,type_info *param_2,void *param_3,long param_4)
|
|
|
|
{
|
|
byte bVar1;
|
|
byte bVar2;
|
|
type_info *ptVar3;
|
|
undefined8 uVar4;
|
|
byte bVar5;
|
|
byte *pbVar6;
|
|
ulong uVar7;
|
|
void *local_30 [2];
|
|
|
|
pbVar6 = (byte *)(~param_4 + *(long *)(param_1 + 0x18));
|
|
local_30[0] = param_3;
|
|
while( true ) {
|
|
uVar7 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar1 = *pbVar6;
|
|
pbVar6 = pbVar6 + 1;
|
|
bVar2 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar7 = uVar7 | (ulong)(bVar1 & 0x7f) << bVar2;
|
|
} while ((char)bVar1 < '\0');
|
|
if (uVar7 == 0) break;
|
|
ptVar3 = (type_info *)get_ttype_entry(param_1,uVar7);
|
|
uVar4 = get_adjusted_ptr(ptVar3,param_2,local_30);
|
|
if ((char)uVar4 != '\0') {
|
|
return uVar4;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 00142d70 base_of_encoded_value
|
|
|
|
/* base_of_encoded_value(unsigned char, _Unwind_Context*) */
|
|
|
|
undefined8 base_of_encoded_value(uchar param_1,_Unwind_Context *param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
undefined8 uVar2;
|
|
|
|
if (param_1 == 0xff) {
|
|
return 0;
|
|
}
|
|
bVar1 = param_1 & 0x70;
|
|
if (bVar1 == 0x30) {
|
|
uVar2 = _Unwind_GetDataRelBase(param_2);
|
|
return uVar2;
|
|
}
|
|
if (bVar1 < 0x31) {
|
|
if (bVar1 == 0x20) {
|
|
uVar2 = _Unwind_GetTextRelBase(param_2);
|
|
return uVar2;
|
|
}
|
|
if ((0x20 < bVar1) || ((param_1 & 0x60) != 0)) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
}
|
|
else {
|
|
if (bVar1 == 0x40) {
|
|
uVar2 = _Unwind_GetRegionStart(param_2);
|
|
return uVar2;
|
|
}
|
|
if (bVar1 != 0x50) {
|
|
uVar2 = base_of_encoded_value(param_1,param_2);
|
|
return uVar2;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 00142df0 parse_lsda_header
|
|
|
|
/* parse_lsda_header(_Unwind_Context*, unsigned char const*, lsda_header_info*) */
|
|
|
|
lsda_header_info *
|
|
parse_lsda_header(_Unwind_Context *param_1,uchar *param_2,lsda_header_info *param_3)
|
|
|
|
{
|
|
uchar uVar1;
|
|
lsda_header_info lVar2;
|
|
byte bVar3;
|
|
undefined8 uVar4;
|
|
byte bVar5;
|
|
lsda_header_info *plVar6;
|
|
ulong uVar7;
|
|
lsda_header_info *plVar8;
|
|
|
|
uVar4 = 0;
|
|
if (param_1 != (_Unwind_Context *)0x0) {
|
|
uVar4 = _Unwind_GetRegionStart();
|
|
}
|
|
*(undefined8 *)param_3 = uVar4;
|
|
uVar1 = *param_2;
|
|
if (uVar1 == 0xff) {
|
|
*(undefined8 *)(param_3 + 8) = uVar4;
|
|
lVar2 = *(lsda_header_info *)(param_2 + 1);
|
|
plVar6 = (lsda_header_info *)(param_2 + 2);
|
|
param_3[0x28] = lVar2;
|
|
}
|
|
else {
|
|
uVar7 = base_of_encoded_value(uVar1,param_1);
|
|
plVar6 = (lsda_header_info *)
|
|
read_encoded_value_with_base(uVar1,uVar7,param_2 + 1,(ulong *)(param_3 + 8));
|
|
lVar2 = *plVar6;
|
|
plVar6 = plVar6 + 1;
|
|
param_3[0x28] = lVar2;
|
|
}
|
|
if (lVar2 == (lsda_header_info)0xff) {
|
|
*(undefined8 *)(param_3 + 0x18) = 0;
|
|
}
|
|
else {
|
|
uVar7 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
lVar2 = *plVar6;
|
|
plVar6 = plVar6 + 1;
|
|
bVar3 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar7 = uVar7 | (ulong)((byte)lVar2 & 0x7f) << bVar3;
|
|
} while ((char)lVar2 < '\0');
|
|
*(lsda_header_info **)(param_3 + 0x18) = plVar6 + uVar7;
|
|
}
|
|
plVar8 = plVar6 + 1;
|
|
uVar7 = 0;
|
|
bVar5 = 0;
|
|
param_3[0x29] = *plVar6;
|
|
do {
|
|
lVar2 = *plVar8;
|
|
plVar8 = plVar8 + 1;
|
|
bVar3 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar7 = uVar7 | (ulong)((byte)lVar2 & 0x7f) << bVar3;
|
|
} while ((char)lVar2 < '\0');
|
|
*(lsda_header_info **)(param_3 + 0x20) = plVar8 + uVar7;
|
|
return plVar8;
|
|
}
|
|
|
|
|
|
// 00142ef0 __gxx_personality_v0
|
|
|
|
undefined8
|
|
__gxx_personality_v0(int param_1,uint param_2,long param_3,byte *param_4,_Unwind_Context *param_5)
|
|
|
|
{
|
|
_Unwind_Context _Var1;
|
|
byte bVar2;
|
|
bool bVar3;
|
|
byte bVar4;
|
|
uchar uVar5;
|
|
bool bVar6;
|
|
ulong uVar7;
|
|
long lVar8;
|
|
uchar *puVar9;
|
|
undefined8 uVar10;
|
|
ClassTypeInfoStructure *pCVar11;
|
|
type_info *ptVar12;
|
|
uint uVar13;
|
|
_Unwind_Context *p_Var14;
|
|
byte *pbVar15;
|
|
_Unwind_Context *p_Var16;
|
|
byte *pbVar17;
|
|
ulong uVar18;
|
|
_Unwind_Context *p_Var19;
|
|
ulong uVar20;
|
|
_Unwind_Context *p_Var21;
|
|
_Unwind_Context *p_Var22;
|
|
byte bVar23;
|
|
uchar *local_c0;
|
|
lsda_header_info *local_b0;
|
|
_Unwind_Context *local_a8;
|
|
byte *local_88;
|
|
ulong local_80;
|
|
ulong local_78;
|
|
ulong local_70;
|
|
long local_68;
|
|
long local_60;
|
|
undefined8 local_58;
|
|
long local_50;
|
|
byte *local_48;
|
|
uchar local_40;
|
|
uchar local_3f;
|
|
|
|
local_88 = (byte *)0x0;
|
|
if (param_1 != 1) {
|
|
return 3;
|
|
}
|
|
uVar7 = param_3 + 0xb8b1aabcbcd4d500;
|
|
bVar3 = uVar7 < 2;
|
|
bVar6 = param_2 == 6 && bVar3;
|
|
if (param_2 == 6 && bVar3) {
|
|
p_Var21 = *(_Unwind_Context **)(param_4 + -0x10);
|
|
if (p_Var21 != (_Unwind_Context *)0x0) {
|
|
p_Var19 = (_Unwind_Context *)(ulong)*(uint *)(param_4 + -0x24);
|
|
local_c0 = *(uchar **)(param_4 + -0x18);
|
|
LAB_00142f72:
|
|
if ((int)p_Var19 < 0) {
|
|
parse_lsda_header(param_5,local_c0,(lsda_header_info *)&local_68);
|
|
local_58 = base_of_encoded_value(local_40,param_5);
|
|
uVar10 = base_of_encoded_value(local_40,param_5);
|
|
*(undefined8 *)(param_4 + -0x10) = uVar10;
|
|
}
|
|
goto LAB_00142f80;
|
|
}
|
|
}
|
|
else {
|
|
local_c0 = (uchar *)_Unwind_GetLanguageSpecificData(param_5);
|
|
if (local_c0 == (uchar *)0x0) {
|
|
return 8;
|
|
}
|
|
local_b0 = (lsda_header_info *)&local_68;
|
|
pbVar15 = (byte *)parse_lsda_header(param_5,local_c0,local_b0);
|
|
local_58 = base_of_encoded_value(local_40,param_5);
|
|
lVar8 = _Unwind_GetIPInfo(param_5);
|
|
if (pbVar15 < local_48) {
|
|
do {
|
|
uVar5 = local_3f;
|
|
uVar20 = base_of_encoded_value(local_3f,(_Unwind_Context *)0x0);
|
|
puVar9 = (uchar *)read_encoded_value_with_base(uVar5,uVar20,pbVar15,&local_80);
|
|
uVar5 = local_3f;
|
|
uVar20 = base_of_encoded_value(local_3f,(_Unwind_Context *)0x0);
|
|
puVar9 = (uchar *)read_encoded_value_with_base(uVar5,uVar20,puVar9,&local_78);
|
|
uVar5 = local_3f;
|
|
uVar20 = base_of_encoded_value(local_3f,(_Unwind_Context *)0x0);
|
|
pbVar15 = (byte *)read_encoded_value_with_base(uVar5,uVar20,puVar9,&local_70);
|
|
pbVar17 = (byte *)0x0;
|
|
bVar23 = 0;
|
|
do {
|
|
bVar2 = *pbVar15;
|
|
pbVar15 = pbVar15 + 1;
|
|
bVar4 = bVar23 & 0x3f;
|
|
bVar23 = bVar23 + 7;
|
|
pbVar17 = (byte *)((ulong)pbVar17 | (ulong)(bVar2 & 0x7f) << bVar4);
|
|
} while ((char)bVar2 < '\0');
|
|
local_a8 = param_5;
|
|
if (lVar8 - 1U < local_80 + local_68) break;
|
|
if (lVar8 - 1U < local_80 + local_68 + local_78) goto LAB_00143154;
|
|
} while (pbVar15 < local_48);
|
|
}
|
|
if ((param_2 & 1) != 0) {
|
|
p_Var19 = (_Unwind_Context *)0x0;
|
|
p_Var21 = (_Unwind_Context *)0x0;
|
|
p_Var14 = (_Unwind_Context *)0x0;
|
|
LAB_00143113:
|
|
if (1 < uVar7) {
|
|
return 6;
|
|
}
|
|
*(int *)(param_4 + -0x24) = (int)p_Var19;
|
|
*(_Unwind_Context **)(param_4 + -0x20) = p_Var14;
|
|
*(uchar **)(param_4 + -0x18) = local_c0;
|
|
*(byte **)(param_4 + -8) = local_88;
|
|
*(_Unwind_Context **)(param_4 + -0x10) = p_Var21;
|
|
return 6;
|
|
}
|
|
if (((param_2 & 8) != 0) || (1 < uVar7)) {
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
}
|
|
pbVar17 = param_4;
|
|
__cxa_call_terminate();
|
|
LAB_00143154:
|
|
param_5 = local_a8;
|
|
if (local_70 == 0) {
|
|
return 8;
|
|
}
|
|
p_Var21 = (_Unwind_Context *)(local_70 + local_60);
|
|
if (pbVar17 == (byte *)0x0) {
|
|
if (p_Var21 == (_Unwind_Context *)0x0) {
|
|
return 8;
|
|
}
|
|
}
|
|
else {
|
|
p_Var19 = (_Unwind_Context *)(local_48 + -1 + (long)pbVar17);
|
|
if (p_Var21 == (_Unwind_Context *)0x0) {
|
|
return 8;
|
|
}
|
|
if (p_Var19 != (_Unwind_Context *)0x0) {
|
|
local_a8._0_4_ = param_2 & 8;
|
|
if ((param_2 & 8) == 0) {
|
|
if (uVar7 < 2) {
|
|
local_88 = param_4 + 0x20;
|
|
if ((*param_4 & 1) != 0) {
|
|
local_88 = *(byte **)(param_4 + -0x50);
|
|
}
|
|
pCVar11 = *(ClassTypeInfoStructure **)(local_88 + -0x70);
|
|
}
|
|
else {
|
|
pCVar11 = &__cxxabiv1::__foreign_exception::typeinfo;
|
|
}
|
|
}
|
|
else {
|
|
pCVar11 = &__cxxabiv1::__forced_unwind::typeinfo;
|
|
}
|
|
do {
|
|
p_Var22 = (_Unwind_Context *)0x0;
|
|
uVar13 = 0;
|
|
p_Var16 = p_Var19;
|
|
do {
|
|
_Var1 = *p_Var16;
|
|
p_Var16 = p_Var16 + 1;
|
|
bVar23 = (byte)uVar13;
|
|
uVar13 = uVar13 + 7;
|
|
p_Var22 = (_Unwind_Context *)
|
|
((ulong)p_Var22 | (ulong)((byte)_Var1 & 0x7f) << (bVar23 & 0x3f));
|
|
} while ((char)_Var1 < '\0');
|
|
if ((uVar13 < 0x40) && (((byte)_Var1 & 0x40) != 0)) {
|
|
p_Var22 = (_Unwind_Context *)((ulong)p_Var22 | -(1L << ((byte)uVar13 & 0x3f)));
|
|
}
|
|
uVar20 = 0;
|
|
uVar13 = 0;
|
|
p_Var14 = p_Var16;
|
|
do {
|
|
_Var1 = *p_Var14;
|
|
p_Var14 = p_Var14 + 1;
|
|
bVar23 = (byte)uVar13;
|
|
uVar13 = uVar13 + 7;
|
|
uVar20 = uVar20 | (ulong)((byte)_Var1 & 0x7f) << (bVar23 & 0x3f);
|
|
} while ((char)_Var1 < '\0');
|
|
if ((uVar13 < 0x40) && (((byte)_Var1 & 0x40) != 0)) {
|
|
uVar20 = uVar20 | -(1L << ((byte)uVar13 & 0x3f));
|
|
}
|
|
if (p_Var22 == (_Unwind_Context *)0x0) {
|
|
bVar6 = true;
|
|
}
|
|
else {
|
|
if ((long)p_Var22 < 1) {
|
|
if ((bVar3 && (uint)local_a8 == 0) && (pCVar11 != (ClassTypeInfoStructure *)0x0))
|
|
goto LAB_001433d0;
|
|
uVar18 = 0;
|
|
bVar23 = 0;
|
|
pbVar15 = (byte *)(~(ulong)p_Var22 + local_50);
|
|
do {
|
|
bVar2 = *pbVar15;
|
|
pbVar15 = pbVar15 + 1;
|
|
bVar4 = bVar23 & 0x3f;
|
|
bVar23 = bVar23 + 7;
|
|
uVar18 = uVar18 | (ulong)(bVar2 & 0x7f) << bVar4;
|
|
} while ((char)bVar2 < '\0');
|
|
bVar23 = uVar18 == 0;
|
|
}
|
|
else {
|
|
ptVar12 = (type_info *)get_ttype_entry(local_b0,(ulong)p_Var22);
|
|
p_Var14 = p_Var19;
|
|
if (ptVar12 == (type_info *)0x0) goto LAB_00143392;
|
|
if (pCVar11 == (ClassTypeInfoStructure *)0x0) goto LAB_0014334d;
|
|
bVar23 = get_adjusted_ptr(ptVar12,(type_info *)pCVar11,&local_88);
|
|
}
|
|
for (; p_Var14 = p_Var19, bVar23 != 0; bVar23 = bVar23 ^ 1) {
|
|
LAB_00143392:
|
|
p_Var19 = p_Var22;
|
|
if ((param_2 & 1) != 0) goto LAB_00143113;
|
|
if (((uint)local_a8 == 0) && (uVar7 < 2)) goto LAB_00142f72;
|
|
if (-1 < (int)p_Var19) goto LAB_00142f80;
|
|
std::unexpected();
|
|
p_Var16 = param_5;
|
|
p_Var22 = p_Var21;
|
|
LAB_001433d0:
|
|
bVar23 = check_exception_spec(local_b0,(type_info *)pCVar11,local_88,(long)p_Var22);
|
|
}
|
|
}
|
|
LAB_0014334d:
|
|
if (uVar20 == 0) goto LAB_001433f9;
|
|
p_Var19 = p_Var16 + uVar20;
|
|
} while( true );
|
|
}
|
|
}
|
|
goto LAB_00143176;
|
|
LAB_001433f9:
|
|
if (!bVar6) {
|
|
return 8;
|
|
}
|
|
LAB_00143176:
|
|
p_Var19 = (_Unwind_Context *)(ulong)(param_2 & 1);
|
|
if ((param_2 & 1) != 0) {
|
|
return 8;
|
|
}
|
|
LAB_00142f80:
|
|
_Unwind_SetGR(param_5,0,param_4);
|
|
_Unwind_SetGR(param_5,1,(long)(int)p_Var19);
|
|
_Unwind_SetIP(param_5,p_Var21);
|
|
return 7;
|
|
}
|
|
|
|
|
|
// 00143450 __cxa_call_unexpected
|
|
|
|
void __cxa_call_unexpected(long param_1)
|
|
|
|
{
|
|
__cxa_begin_catch();
|
|
/* WARNING: Subroutine does not return */
|
|
__cxxabiv1::__unexpected(*(_func_void **)(param_1 + -0x40));
|
|
}
|
|
|
|
|
|
// 00143590 __gxx_exception_cleanup
|
|
|
|
/* __gxx_exception_cleanup(_Unwind_Reason_Code, _Unwind_Exception*) */
|
|
|
|
void __gxx_exception_cleanup(uint param_1,long param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
|
|
if (1 < param_1) {
|
|
/* WARNING: Subroutine does not return */
|
|
__cxxabiv1::__terminate(*(_func_void **)(param_2 + -0x38));
|
|
}
|
|
LOCK();
|
|
piVar1 = (int *)(param_2 + -0x60);
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (*piVar1 == 0) {
|
|
if (*(code **)(param_2 + -0x48) != (code *)0x0) {
|
|
(**(code **)(param_2 + -0x48))(param_2 + 0x20);
|
|
}
|
|
__cxa_free_exception(param_2 + 0x20);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001435d0 __cxa_init_primary_exception
|
|
|
|
long __cxa_init_primary_exception(long param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
*(undefined4 *)(param_1 + -0x80) = 0;
|
|
*(undefined8 *)(param_1 + -0x70) = param_2;
|
|
*(undefined8 *)(param_1 + -0x68) = param_3;
|
|
uVar1 = std::get_unexpected();
|
|
*(undefined8 *)(param_1 + -0x60) = uVar1;
|
|
uVar1 = std::get_terminate();
|
|
*(undefined8 *)(param_1 + -0x58) = uVar1;
|
|
*(undefined8 *)(param_1 + -0x20) = 0x474e5543432b2b00;
|
|
*(code **)(param_1 + -0x18) = __gxx_exception_cleanup;
|
|
return param_1 + -0x80;
|
|
}
|
|
|
|
|
|
// 00143620 __cxa_throw
|
|
|
|
void __cxa_throw(undefined8 param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
long lVar1;
|
|
undefined4 *puVar2;
|
|
|
|
lVar1 = __cxa_get_globals();
|
|
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
|
|
puVar2 = (undefined4 *)__cxa_init_primary_exception(param_1,param_2,param_3);
|
|
*puVar2 = 1;
|
|
_Unwind_RaiseException(puVar2 + 0x18);
|
|
__cxa_begin_catch(puVar2 + 0x18);
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 00143670 __cxa_rethrow
|
|
|
|
void __cxa_rethrow(void)
|
|
|
|
{
|
|
long lVar1;
|
|
long *plVar2;
|
|
|
|
plVar2 = (long *)__cxa_get_globals();
|
|
lVar1 = *plVar2;
|
|
*(int *)(plVar2 + 1) = (int)plVar2[1] + 1;
|
|
if (lVar1 != 0) {
|
|
if (*(long *)(lVar1 + 0x50) + 0xb8b1aabcbcd4d500U < 2) {
|
|
*(int *)(lVar1 + 0x28) = -*(int *)(lVar1 + 0x28);
|
|
}
|
|
else {
|
|
*plVar2 = 0;
|
|
}
|
|
_Unwind_Resume_or_Rethrow(lVar1 + 0x50);
|
|
__cxa_begin_catch(lVar1 + 0x50);
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 00143720 __cxa_guard_acquire
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x00143768) */
|
|
/* WARNING: Removing unreachable block (ram,0x0014376d) */
|
|
/* WARNING: Removing unreachable block (ram,0x0011986a) */
|
|
/* WARNING: Removing unreachable block (ram,0x00143777) */
|
|
|
|
undefined8 __cxa_guard_acquire(uint *param_1)
|
|
|
|
{
|
|
uint uVar1;
|
|
ulong uVar2;
|
|
bool bVar3;
|
|
|
|
if ((char)*param_1 != '\0') {
|
|
return 0;
|
|
}
|
|
uVar2 = 0;
|
|
LOCK();
|
|
bVar3 = *param_1 == 0;
|
|
if (bVar3) {
|
|
*param_1 = 0x100;
|
|
}
|
|
else {
|
|
uVar2 = (ulong)*param_1;
|
|
}
|
|
UNLOCK();
|
|
do {
|
|
if (bVar3) {
|
|
return 1;
|
|
}
|
|
if ((int)uVar2 == 1) {
|
|
return 0;
|
|
}
|
|
if ((int)uVar2 == 0x100) {
|
|
uVar2 = 0x10100;
|
|
LOCK();
|
|
uVar1 = *param_1;
|
|
bVar3 = uVar1 == 0x100;
|
|
if (bVar3) {
|
|
*param_1 = 0x10100;
|
|
uVar1 = 0x100;
|
|
}
|
|
UNLOCK();
|
|
if (bVar3) goto LAB_001437b0;
|
|
if (uVar1 == 1) {
|
|
return 0;
|
|
}
|
|
if (uVar1 != 0) goto LAB_001437b0;
|
|
}
|
|
else {
|
|
LAB_001437b0:
|
|
syscall(0xca,param_1,0,uVar2,0);
|
|
}
|
|
uVar2 = 0;
|
|
LOCK();
|
|
bVar3 = *param_1 == 0;
|
|
if (bVar3) {
|
|
*param_1 = 0x100;
|
|
}
|
|
else {
|
|
uVar2 = (ulong)*param_1;
|
|
}
|
|
UNLOCK();
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001437e0 __cxa_guard_abort
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x001437ea) */
|
|
|
|
void __cxa_guard_abort(uint *param_1)
|
|
|
|
{
|
|
uint uVar1;
|
|
|
|
LOCK();
|
|
uVar1 = *param_1;
|
|
*param_1 = 0;
|
|
UNLOCK();
|
|
if ((uVar1 & 0x10000) == 0) {
|
|
return;
|
|
}
|
|
syscall(0xca,param_1,1,0x7fffffff);
|
|
return;
|
|
}
|
|
|
|
|
|
// 00143820 __cxa_guard_release
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x00143840) */
|
|
|
|
void __cxa_guard_release(uint *param_1)
|
|
|
|
{
|
|
uint uVar1;
|
|
|
|
LOCK();
|
|
uVar1 = *param_1;
|
|
*param_1 = 1;
|
|
UNLOCK();
|
|
if ((uVar1 & 0x10000) != 0) {
|
|
syscall(0xca,param_1,1,0x7fffffff);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001438d0 operator.new
|
|
|
|
/* operator new(unsigned long) */
|
|
|
|
void * operator_new(ulong param_1)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
void *pvVar2;
|
|
code *pcVar3;
|
|
size_t __size;
|
|
|
|
__size = 1;
|
|
if (param_1 != 0) {
|
|
__size = param_1;
|
|
}
|
|
while( true ) {
|
|
pvVar2 = malloc(__size);
|
|
if (pvVar2 != (void *)0x0) {
|
|
return pvVar2;
|
|
}
|
|
pcVar3 = (code *)std::get_new_handler();
|
|
if (pcVar3 == (code *)0x0) break;
|
|
(*pcVar3)();
|
|
}
|
|
puVar1 = (undefined8 *)__cxa_allocate_exception(8);
|
|
*puVar1 = &std::bad_alloc::vftable;
|
|
/* WARNING: Subroutine does not return */
|
|
__cxa_throw(puVar1,&std::bad_alloc::typeinfo,std::bad_alloc::~bad_alloc);
|
|
}
|
|
|
|
|
|
// 00143900 operator.new[]
|
|
|
|
/* operator new[](unsigned long) */
|
|
|
|
void * operator_new__(ulong param_1)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
void *pvVar2;
|
|
code *pcVar3;
|
|
size_t __size;
|
|
|
|
__size = 1;
|
|
if (param_1 != 0) {
|
|
__size = param_1;
|
|
}
|
|
while( true ) {
|
|
pvVar2 = malloc(__size);
|
|
if (pvVar2 != (void *)0x0) {
|
|
return pvVar2;
|
|
}
|
|
pcVar3 = (code *)std::get_new_handler();
|
|
if (pcVar3 == (code *)0x0) break;
|
|
(*pcVar3)();
|
|
}
|
|
puVar1 = (undefined8 *)__cxa_allocate_exception(8);
|
|
*puVar1 = &std::bad_alloc::vftable;
|
|
/* WARNING: Subroutine does not return */
|
|
__cxa_throw(puVar1,&std::bad_alloc::typeinfo,std::bad_alloc::~bad_alloc);
|
|
}
|
|
|
|
|
|
// 001439e0 __cxa_pure_virtual
|
|
|
|
void __thiscall __cxa_pure_virtual(void)
|
|
|
|
{
|
|
write(2,"pure virtual method called\n",0x1b);
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 00143a00 __cxa_deleted_virtual
|
|
|
|
void __cxa_deleted_virtual(void)
|
|
|
|
{
|
|
write(2,"deleted virtual method called\n",0x1e);
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 0019f700 d_make_comp
|
|
|
|
undefined4 * d_make_comp(long param_1,undefined4 param_2,long param_3,long param_4)
|
|
|
|
{
|
|
undefined4 *puVar1;
|
|
int iVar2;
|
|
long lVar3;
|
|
|
|
switch(param_2) {
|
|
default:
|
|
goto switchD_0019f716_caseD_0;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 0xb:
|
|
case 0x21:
|
|
case 0x2b:
|
|
case 0x2d:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3d:
|
|
case 0x3e:
|
|
case 0x40:
|
|
case 0x4c:
|
|
case 0x4e:
|
|
if (param_3 == 0) {
|
|
return (undefined4 *)0x0;
|
|
}
|
|
case 0x2a:
|
|
case 0x31:
|
|
lVar3 = param_4;
|
|
break;
|
|
case 9:
|
|
case 10:
|
|
case 0xc:
|
|
case 0xd:
|
|
case 0xe:
|
|
case 0xf:
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x28:
|
|
case 0x30:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x3c:
|
|
case 0x3f:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x49:
|
|
case 0x4a:
|
|
case 0x4b:
|
|
lVar3 = param_3;
|
|
break;
|
|
case 0x19:
|
|
case 0x1a:
|
|
case 0x1b:
|
|
case 0x1c:
|
|
case 0x1d:
|
|
case 0x1e:
|
|
case 0x1f:
|
|
case 0x20:
|
|
case 0x29:
|
|
case 0x2e:
|
|
case 0x2f:
|
|
case 0x4d:
|
|
case 0x4f:
|
|
case 0x50:
|
|
goto switchD_0019f716_caseD_19;
|
|
}
|
|
if (lVar3 != 0) {
|
|
switchD_0019f716_caseD_19:
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
puVar1 = (undefined4 *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar1[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*puVar1 = param_2;
|
|
*(long *)(puVar1 + 2) = param_3;
|
|
*(long *)(puVar1 + 4) = param_4;
|
|
return puVar1;
|
|
}
|
|
}
|
|
switchD_0019f716_caseD_0:
|
|
return (undefined4 *)0x0;
|
|
}
|
|
|
|
|
|
// 0019f770 d_ref_qualifier
|
|
|
|
undefined8 d_ref_qualifier(long param_1,undefined8 param_2)
|
|
|
|
{
|
|
char cVar1;
|
|
int iVar2;
|
|
undefined8 uVar3;
|
|
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
if ((cVar1 != 'R') && (cVar1 != 'O')) {
|
|
return param_2;
|
|
}
|
|
uVar3 = 0x20;
|
|
iVar2 = *(int *)(param_1 + 0x48) + 3;
|
|
if (cVar1 == 'R') {
|
|
iVar2 = *(int *)(param_1 + 0x48) + 2;
|
|
uVar3 = 0x1f;
|
|
}
|
|
*(int *)(param_1 + 0x48) = iVar2;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar3 = d_make_comp(param_1,uVar3,param_2,0);
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 0019f7d0 d_count_templates_scopes
|
|
|
|
void d_count_templates_scopes(long param_1,undefined4 *param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
|
|
if (param_2 == (undefined4 *)0x0) {
|
|
return;
|
|
}
|
|
do {
|
|
switch(*param_2) {
|
|
default:
|
|
goto switchD_0019f7fa_caseD_0;
|
|
case 4:
|
|
iVar1 = *(int *)(param_1 + 0x134);
|
|
*(int *)(param_1 + 0x16c) = *(int *)(param_1 + 0x16c) + 1;
|
|
joined_r0x0019f882:
|
|
if (0x800 < iVar1) {
|
|
return;
|
|
}
|
|
uVar2 = *(undefined8 *)(param_2 + 2);
|
|
*(int *)(param_1 + 0x134) = iVar1 + 1;
|
|
d_count_templates_scopes(param_1,uVar2);
|
|
d_count_templates_scopes(param_1,*(undefined8 *)(param_2 + 4));
|
|
*(int *)(param_1 + 0x134) = *(int *)(param_1 + 0x134) + -1;
|
|
return;
|
|
case 7:
|
|
case 8:
|
|
case 0x33:
|
|
param_2 = *(undefined4 **)(param_2 + 4);
|
|
break;
|
|
case 0x23:
|
|
case 0x24:
|
|
if (**(int **)(param_2 + 2) == 5) {
|
|
*(int *)(param_1 + 0x15c) = *(int *)(param_1 + 0x15c) + 1;
|
|
}
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 9:
|
|
case 10:
|
|
case 0xb:
|
|
case 0xc:
|
|
case 0xd:
|
|
case 0xe:
|
|
case 0xf:
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
case 0x19:
|
|
case 0x1a:
|
|
case 0x1b:
|
|
case 0x1c:
|
|
case 0x1d:
|
|
case 0x1e:
|
|
case 0x1f:
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2a:
|
|
case 0x2b:
|
|
case 0x2d:
|
|
case 0x2e:
|
|
case 0x2f:
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3c:
|
|
case 0x3d:
|
|
case 0x3e:
|
|
case 0x3f:
|
|
case 0x40:
|
|
case 0x43:
|
|
case 0x49:
|
|
case 0x4a:
|
|
case 0x4b:
|
|
case 0x4c:
|
|
case 0x4d:
|
|
case 0x4e:
|
|
case 0x4f:
|
|
case 0x50:
|
|
iVar1 = *(int *)(param_1 + 0x134);
|
|
goto joined_r0x0019f882;
|
|
case 0x2c:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
param_2 = *(undefined4 **)(param_2 + 2);
|
|
}
|
|
} while (param_2 != (undefined4 *)0x0);
|
|
switchD_0019f7fa_caseD_0:
|
|
return;
|
|
}
|
|
|
|
|
|
// 0019f890 d_append_buffer
|
|
|
|
void d_append_buffer(long param_1,undefined1 *param_2,long param_3)
|
|
|
|
{
|
|
undefined1 *puVar1;
|
|
undefined1 uVar2;
|
|
long lVar3;
|
|
long lVar4;
|
|
|
|
if (param_3 != 0) {
|
|
puVar1 = param_2 + param_3;
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar2 = *param_2;
|
|
if (lVar3 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar4 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar4 = lVar3 + 1;
|
|
}
|
|
param_2 = param_2 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar4;
|
|
*(undefined1 *)(param_1 + lVar3) = uVar2;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar2;
|
|
lVar3 = lVar4;
|
|
} while (param_2 != puVar1);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 0019f940 d_number.isra.0
|
|
|
|
int d_number_isra_0(long *param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
char cVar2;
|
|
char *pcVar3;
|
|
bool bVar4;
|
|
int iVar5;
|
|
char *pcVar6;
|
|
int iVar7;
|
|
|
|
pcVar3 = (char *)*param_1;
|
|
cVar2 = *pcVar3;
|
|
if (cVar2 == 'n') {
|
|
pcVar6 = pcVar3 + 1;
|
|
*param_1 = (long)pcVar6;
|
|
cVar2 = pcVar3[1];
|
|
if (9 < (byte)(cVar2 - 0x30U)) {
|
|
return 0;
|
|
}
|
|
bVar4 = true;
|
|
}
|
|
else {
|
|
if (9 < (byte)(cVar2 - 0x30U)) {
|
|
return 0;
|
|
}
|
|
bVar4 = false;
|
|
pcVar6 = pcVar3;
|
|
}
|
|
iVar5 = (int)cVar2;
|
|
iVar7 = 0;
|
|
do {
|
|
pcVar6 = pcVar6 + 1;
|
|
*param_1 = (long)pcVar6;
|
|
iVar1 = iVar5 + iVar7 * 10;
|
|
iVar5 = (int)*pcVar6;
|
|
iVar7 = iVar1 + -0x30;
|
|
if (9 < (byte)(*pcVar6 - 0x30U)) {
|
|
if (bVar4) {
|
|
iVar7 = 0x30 - iVar1;
|
|
}
|
|
return iVar7;
|
|
}
|
|
} while (iVar7 <= (int)((0x7fffffffU - (iVar5 + -0x30)) / 10));
|
|
return -1;
|
|
}
|
|
|
|
|
|
// 0019fa00 d_number_component
|
|
|
|
undefined4 * d_number_component(long param_1)
|
|
|
|
{
|
|
undefined4 *puVar1;
|
|
int iVar2;
|
|
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
puVar1 = (undefined4 *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar1[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*puVar1 = 0x42;
|
|
iVar2 = d_number_isra_0();
|
|
*(long *)(puVar1 + 2) = (long)iVar2;
|
|
return puVar1;
|
|
}
|
|
return (undefined4 *)0x0;
|
|
}
|
|
|
|
|
|
// 0019fa60 d_compact_number
|
|
|
|
int d_compact_number(long param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
char *pcVar2;
|
|
|
|
pcVar2 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar2 != '_') {
|
|
if (*pcVar2 != 'n') {
|
|
iVar1 = d_number_isra_0(param_1 + 0x18);
|
|
iVar1 = iVar1 + 1;
|
|
if ((-1 < iVar1) && (pcVar2 = *(char **)(param_1 + 0x18), *pcVar2 == '_')) goto LAB_0019fa8a;
|
|
}
|
|
return -1;
|
|
}
|
|
iVar1 = 0;
|
|
LAB_0019fa8a:
|
|
*(char **)(param_1 + 0x18) = pcVar2 + 1;
|
|
return iVar1;
|
|
}
|
|
|
|
|
|
// 0019fab0 d_template_param
|
|
|
|
undefined4 * d_template_param(long param_1)
|
|
|
|
{
|
|
undefined4 *puVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
|
|
if (**(char **)(param_1 + 0x18) != 'T') {
|
|
return (undefined4 *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
iVar3 = d_compact_number();
|
|
if ((-1 < iVar3) && (iVar2 = *(int *)(param_1 + 0x28), iVar2 < *(int *)(param_1 + 0x2c))) {
|
|
puVar1 = (undefined4 *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar1[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*(long *)(puVar1 + 2) = (long)iVar3;
|
|
*puVar1 = 5;
|
|
return puVar1;
|
|
}
|
|
return (undefined4 *)0x0;
|
|
}
|
|
|
|
|
|
// 0019fb20 d_source_name
|
|
|
|
undefined8 * d_source_name(long param_1)
|
|
|
|
{
|
|
long *plVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
int iVar4;
|
|
char *pcVar5;
|
|
undefined8 *puVar6;
|
|
|
|
iVar2 = d_number_isra_0(param_1 + 0x18);
|
|
if (iVar2 < 1) {
|
|
return (undefined8 *)0x0;
|
|
}
|
|
plVar1 = *(long **)(param_1 + 0x18);
|
|
if (*(long *)(param_1 + 8) - (long)plVar1 < (long)iVar2) goto LAB_0019fc08;
|
|
pcVar5 = (char *)((long)iVar2 + (long)plVar1);
|
|
*(char **)(param_1 + 0x18) = pcVar5;
|
|
if (((*(byte *)(param_1 + 0x10) & 4) == 0) || (*pcVar5 != '$')) {
|
|
iVar4 = *(int *)(param_1 + 0x28);
|
|
iVar3 = *(int *)(param_1 + 0x2c);
|
|
if (iVar2 < 10) goto LAB_0019fb6c;
|
|
LAB_0019fbb0:
|
|
if ((((*plVar1 == 0x5f4c41424f4c475f) && ((byte)(*(byte *)(plVar1 + 1) - 0x24) < 0x3c)) &&
|
|
((0x800000000000401U >> ((ulong)(*(byte *)(plVar1 + 1) - 0x24) & 0x3f) & 1) != 0)) &&
|
|
(*(char *)((long)plVar1 + 9) == 'N')) {
|
|
*(int *)(param_1 + 0x48) = (*(int *)(param_1 + 0x48) + 0x16) - iVar2;
|
|
if (iVar4 < iVar3) {
|
|
*(int *)(param_1 + 0x28) = iVar4 + 1;
|
|
puVar6 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar4 * 0x18);
|
|
*puVar6 = 0;
|
|
puVar6[1] = "(anonymous namespace)";
|
|
*(undefined4 *)(puVar6 + 2) = 0x15;
|
|
goto LAB_0019fba5;
|
|
}
|
|
}
|
|
else if (iVar4 < iVar3) {
|
|
puVar6 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar4 * 0x18);
|
|
*(undefined4 *)((long)puVar6 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar4 + 1;
|
|
LAB_0019fb96:
|
|
*puVar6 = 0;
|
|
puVar6[1] = plVar1;
|
|
*(int *)(puVar6 + 2) = iVar2;
|
|
goto LAB_0019fba5;
|
|
}
|
|
}
|
|
else {
|
|
iVar3 = *(int *)(param_1 + 0x2c);
|
|
*(char **)(param_1 + 0x18) = pcVar5 + 1;
|
|
iVar4 = *(int *)(param_1 + 0x28);
|
|
if (9 < iVar2) goto LAB_0019fbb0;
|
|
LAB_0019fb6c:
|
|
if (iVar4 < iVar3) {
|
|
puVar6 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar4 * 0x18);
|
|
*(undefined4 *)((long)puVar6 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar4 + 1;
|
|
if (plVar1 == (long *)0x0) goto LAB_0019fc08;
|
|
goto LAB_0019fb96;
|
|
}
|
|
}
|
|
LAB_0019fc08:
|
|
puVar6 = (undefined8 *)0x0;
|
|
LAB_0019fba5:
|
|
*(undefined8 **)(param_1 + 0x40) = puVar6;
|
|
return puVar6;
|
|
}
|
|
|
|
|
|
// 0019fc80 d_abi_tags
|
|
|
|
undefined8 d_abi_tags(long param_1,undefined8 param_2)
|
|
|
|
{
|
|
char cVar1;
|
|
char *pcVar2;
|
|
undefined8 uVar3;
|
|
undefined8 uVar4;
|
|
|
|
pcVar2 = *(char **)(param_1 + 0x18);
|
|
uVar3 = *(undefined8 *)(param_1 + 0x40);
|
|
cVar1 = *pcVar2;
|
|
while (cVar1 == 'B') {
|
|
*(char **)(param_1 + 0x18) = pcVar2 + 1;
|
|
uVar4 = d_source_name(param_1);
|
|
param_2 = d_make_comp(param_1,0x4c,param_2,uVar4);
|
|
pcVar2 = *(char **)(param_1 + 0x18);
|
|
cVar1 = *pcVar2;
|
|
}
|
|
*(undefined8 *)(param_1 + 0x40) = uVar3;
|
|
return param_2;
|
|
}
|
|
|
|
|
|
// 0019fce0 d_substitution
|
|
|
|
undefined4 * d_substitution(long param_1,uint param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined4 uVar2;
|
|
char *pcVar3;
|
|
long lVar4;
|
|
char cVar5;
|
|
long lVar6;
|
|
undefined4 *puVar7;
|
|
char cVar8;
|
|
int iVar9;
|
|
ulong uVar10;
|
|
uint uVar11;
|
|
uint uVar12;
|
|
int iVar13;
|
|
undefined1 *puVar14;
|
|
undefined8 uVar15;
|
|
bool bVar16;
|
|
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar3 != 'S') {
|
|
return (undefined4 *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar5 = '\0';
|
|
if (pcVar3[1] == '\0') {
|
|
LAB_0019fcf9:
|
|
bVar16 = (*(uint *)(param_1 + 0x10) & 8) != 0;
|
|
if (((!bVar16) && ((param_2 & 1) != 0)) && ((byte)(**(char **)(param_1 + 0x18) + 0xbdU) < 2)) {
|
|
bVar16 = true;
|
|
}
|
|
puVar14 = standard_subs;
|
|
cVar8 = 't';
|
|
while( true ) {
|
|
if (cVar5 == cVar8) {
|
|
lVar4 = *(long *)(puVar14 + 0x28);
|
|
iVar9 = *(int *)(param_1 + 0x28);
|
|
iVar1 = *(int *)(param_1 + 0x2c);
|
|
if (lVar4 != 0) {
|
|
uVar2 = *(undefined4 *)(puVar14 + 0x30);
|
|
if (iVar9 < iVar1) {
|
|
lVar6 = (long)iVar9;
|
|
iVar9 = iVar9 + 1;
|
|
puVar7 = (undefined4 *)(*(long *)(param_1 + 0x20) + lVar6 * 0x18);
|
|
puVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar9;
|
|
*puVar7 = 0x18;
|
|
*(long *)(puVar7 + 2) = lVar4;
|
|
puVar7[4] = uVar2;
|
|
}
|
|
else {
|
|
puVar7 = (undefined4 *)0x0;
|
|
}
|
|
*(undefined4 **)(param_1 + 0x40) = puVar7;
|
|
}
|
|
if (bVar16) {
|
|
uVar15 = *(undefined8 *)(puVar14 + 0x18);
|
|
iVar13 = *(int *)(puVar14 + 0x20);
|
|
}
|
|
else {
|
|
uVar15 = *(undefined8 *)(puVar14 + 8);
|
|
iVar13 = *(int *)(puVar14 + 0x10);
|
|
}
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + iVar13;
|
|
if (iVar9 < iVar1) {
|
|
puVar7 = (undefined4 *)(*(long *)(param_1 + 0x20) + (long)iVar9 * 0x18);
|
|
puVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar9 + 1;
|
|
*puVar7 = 0x18;
|
|
*(undefined8 *)(puVar7 + 2) = uVar15;
|
|
puVar7[4] = iVar13;
|
|
}
|
|
else {
|
|
puVar7 = (undefined4 *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != 'B') {
|
|
return puVar7;
|
|
}
|
|
puVar7 = (undefined4 *)d_abi_tags(param_1,puVar7);
|
|
if ((puVar7 != (undefined4 *)0x0) &&
|
|
(iVar9 = *(int *)(param_1 + 0x38), iVar9 < *(int *)(param_1 + 0x3c))) {
|
|
*(undefined4 **)(*(long *)(param_1 + 0x30) + (long)iVar9 * 8) = puVar7;
|
|
*(int *)(param_1 + 0x38) = iVar9 + 1;
|
|
return puVar7;
|
|
}
|
|
return (undefined4 *)0x0;
|
|
}
|
|
puVar14 = puVar14 + 0x38;
|
|
if (puVar14 == "") break;
|
|
cVar8 = *puVar14;
|
|
}
|
|
}
|
|
else {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
cVar5 = pcVar3[1];
|
|
iVar9 = (int)cVar5;
|
|
if ((byte)(cVar5 - 0x30U) < 10) {
|
|
if (cVar5 != '_') {
|
|
LAB_0019fd78:
|
|
uVar11 = 0;
|
|
if (9 < (byte)(cVar5 - 0x30U)) goto LAB_0019fdb7;
|
|
do {
|
|
uVar12 = uVar11;
|
|
uVar11 = iVar9 + -0x30 + uVar11 * 0x24;
|
|
while( true ) {
|
|
if (uVar11 < uVar12) {
|
|
return (undefined4 *)0x0;
|
|
}
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
cVar5 = '\0';
|
|
if (*pcVar3 != '\0') {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar5 = *pcVar3;
|
|
if (cVar5 == '_') {
|
|
uVar10 = (ulong)(uVar11 + 1);
|
|
goto LAB_0019fdda;
|
|
}
|
|
}
|
|
iVar9 = (int)cVar5;
|
|
if ((byte)(cVar5 - 0x30U) < 10) break;
|
|
LAB_0019fdb7:
|
|
if (0x19 < (byte)((char)iVar9 + 0xbfU)) {
|
|
return (undefined4 *)0x0;
|
|
}
|
|
uVar12 = uVar11;
|
|
uVar11 = iVar9 + -0x37 + uVar11 * 0x24;
|
|
}
|
|
} while( true );
|
|
}
|
|
}
|
|
else if (cVar5 != '_') {
|
|
if ((byte)(cVar5 + 0xbfU) < 0x1a) goto LAB_0019fd78;
|
|
goto LAB_0019fcf9;
|
|
}
|
|
uVar10 = 0;
|
|
LAB_0019fdda:
|
|
if ((uint)uVar10 < *(uint *)(param_1 + 0x38)) {
|
|
return *(undefined4 **)(*(long *)(param_1 + 0x30) + uVar10 * 8);
|
|
}
|
|
}
|
|
return (undefined4 *)0x0;
|
|
}
|
|
|
|
|
|
// 0019ff00 d_call_offset
|
|
|
|
undefined8 d_call_offset(long param_1,int param_2)
|
|
|
|
{
|
|
char *pcVar1;
|
|
|
|
if (param_2 == 0) {
|
|
pcVar1 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar1 == '\0') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar1 + 1;
|
|
param_2 = (int)*pcVar1;
|
|
}
|
|
if (param_2 == 0x68) {
|
|
d_number_isra_0(param_1 + 0x18);
|
|
}
|
|
else {
|
|
if (param_2 != 0x76) {
|
|
return 0;
|
|
}
|
|
d_number_isra_0(param_1 + 0x18);
|
|
if (**(char **)(param_1 + 0x18) != '_') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
d_number_isra_0();
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != '_') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 0019ff80 next_is_type_qual.isra.0
|
|
|
|
uint next_is_type_qual_isra_0(char *param_1)
|
|
|
|
{
|
|
byte bVar1;
|
|
|
|
bVar1 = *param_1 + 0xb5;
|
|
if (bVar1 < 0x28) {
|
|
return (uint)(0x8000000801 >> (bVar1 & 0x3f)) & 1;
|
|
}
|
|
if (*param_1 != 'D') {
|
|
return 0;
|
|
}
|
|
return (uint)((byte)(param_1[1] + 0x89U) < 2 || (param_1[1] & 0xdfU) == 0x4f);
|
|
}
|
|
|
|
|
|
// 0019ffd0 d_discriminator
|
|
|
|
undefined8 d_discriminator(long param_1)
|
|
|
|
{
|
|
char *pcVar1;
|
|
int iVar2;
|
|
|
|
pcVar1 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar1 != '_') {
|
|
return 1;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar1 + 1;
|
|
if (pcVar1[1] == '_') {
|
|
*(char **)(param_1 + 0x18) = pcVar1 + 2;
|
|
iVar2 = d_number_isra_0();
|
|
if (iVar2 < 0) {
|
|
return 0;
|
|
}
|
|
if (9 < iVar2) {
|
|
if (**(char **)(param_1 + 0x18) != '_') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
}
|
|
else {
|
|
iVar2 = d_number_isra_0(param_1 + 0x18);
|
|
if (iVar2 < 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 001a0050 d_index_template_argument.part.0
|
|
|
|
undefined8 d_index_template_argument_part_0(int *param_1,int param_2)
|
|
|
|
{
|
|
while( true ) {
|
|
if (param_1 == (int *)0x0) {
|
|
return 0;
|
|
}
|
|
if (*param_1 != 0x2f) break;
|
|
if (param_2 < 1) {
|
|
if (param_2 != 0) {
|
|
return 0;
|
|
}
|
|
return *(undefined8 *)(param_1 + 2);
|
|
}
|
|
param_1 = *(int **)(param_1 + 4);
|
|
param_2 = param_2 + -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001a0090 d_lookup_template_argument.isra.0
|
|
|
|
undefined8 d_lookup_template_argument_isra_0(long param_1,undefined8 *param_2)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if (*(long *)(param_1 + 0x120) == 0) {
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
uVar1 = 0;
|
|
}
|
|
else {
|
|
uVar1 = *(undefined8 *)(*(long *)(*(long *)(param_1 + 0x120) + 8) + 0x10);
|
|
if (-1 < (int)*param_2) {
|
|
uVar1 = d_index_template_argument_part_0();
|
|
return uVar1;
|
|
}
|
|
}
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 001a00c0 d_find_pack
|
|
|
|
int * d_find_pack(undefined8 param_1,undefined4 *param_2)
|
|
|
|
{
|
|
int *piVar1;
|
|
|
|
if (param_2 == (undefined4 *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
do {
|
|
switch(*param_2) {
|
|
case 0:
|
|
case 6:
|
|
case 0x18:
|
|
case 0x27:
|
|
case 0x2c:
|
|
case 0x32:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x4b:
|
|
case 0x4c:
|
|
goto LAB_001a0108;
|
|
case 5:
|
|
piVar1 = (int *)d_lookup_template_argument_isra_0(param_1,param_2 + 2);
|
|
if ((piVar1 != (int *)0x0) && (*piVar1 == 0x2f)) {
|
|
return piVar1;
|
|
}
|
|
goto LAB_001a0108;
|
|
case 7:
|
|
case 8:
|
|
case 0x33:
|
|
goto switchD_001a00e5_caseD_7;
|
|
}
|
|
piVar1 = (int *)d_find_pack(param_1,*(undefined8 *)(param_2 + 2));
|
|
if (piVar1 != (int *)0x0) {
|
|
return piVar1;
|
|
}
|
|
switchD_001a00e5_caseD_7:
|
|
param_2 = *(undefined4 **)(param_2 + 4);
|
|
} while (param_2 != (undefined4 *)0x0);
|
|
LAB_001a0108:
|
|
return (int *)0x0;
|
|
}
|
|
|
|
|
|
// 001a0140 d_growable_string_callback_adapter
|
|
|
|
void d_growable_string_callback_adapter(void *param_1,size_t param_2,long *param_3)
|
|
|
|
{
|
|
ulong uVar1;
|
|
void *pvVar2;
|
|
int iVar3;
|
|
ulong __size;
|
|
|
|
__size = param_3[2];
|
|
iVar3 = (int)param_3[3];
|
|
uVar1 = param_2 + 1 + param_3[1];
|
|
if (__size < uVar1) {
|
|
if (iVar3 != 0) {
|
|
return;
|
|
}
|
|
if ((__size != 0) || (__size = 2, 2 < uVar1)) {
|
|
do {
|
|
__size = __size * 2;
|
|
} while (__size < uVar1);
|
|
}
|
|
pvVar2 = realloc((void *)*param_3,__size);
|
|
if (pvVar2 == (void *)0x0) {
|
|
free((void *)*param_3);
|
|
*param_3 = 0;
|
|
param_3[1] = 0;
|
|
param_3[2] = 0;
|
|
*(undefined4 *)(param_3 + 3) = 1;
|
|
return;
|
|
}
|
|
*param_3 = (long)pvVar2;
|
|
iVar3 = (int)param_3[3];
|
|
param_3[2] = __size;
|
|
}
|
|
if (iVar3 == 0) {
|
|
memcpy((void *)(param_3[1] + *param_3),param_1,param_2);
|
|
*(undefined1 *)(*param_3 + param_2 + param_3[1]) = 0;
|
|
param_3[1] = param_3[1] + param_2;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001a0210 d_exprlist
|
|
|
|
long d_exprlist(long param_1,char param_2)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined4 uVar2;
|
|
int iVar3;
|
|
undefined8 *puVar4;
|
|
bool bVar5;
|
|
uint uVar6;
|
|
int iVar7;
|
|
char *pcVar8;
|
|
uint *puVar9;
|
|
undefined4 *puVar10;
|
|
long lVar11;
|
|
undefined8 uVar12;
|
|
undefined8 uVar13;
|
|
undefined8 uVar14;
|
|
long *plVar15;
|
|
long local_40 [2];
|
|
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
local_40[0] = 0;
|
|
plVar15 = local_40;
|
|
if (*pcVar8 == param_2) {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
uVar12 = d_make_comp(param_1,0x2e,0,0);
|
|
return uVar12;
|
|
}
|
|
do {
|
|
uVar2 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
cVar1 = *pcVar8;
|
|
if (cVar1 == 'L') {
|
|
puVar10 = (undefined4 *)d_expr_primary(param_1);
|
|
LAB_001a03cb:
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar2;
|
|
if (puVar10 == (undefined4 *)0x0) {
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
if (cVar1 == 'T') {
|
|
puVar10 = (undefined4 *)d_template_param(param_1);
|
|
goto LAB_001a03cb;
|
|
}
|
|
if (cVar1 == 's') {
|
|
if (pcVar8[1] == 'r') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
uVar12 = d_type(param_1);
|
|
uVar13 = d_unqualified_name(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar14 = d_template_args_1(param_1);
|
|
uVar13 = d_make_comp(param_1,4,uVar13,uVar14);
|
|
}
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,1,uVar12,uVar13);
|
|
}
|
|
else {
|
|
if (pcVar8[1] != 'p') goto LAB_001a027c;
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
uVar12 = d_expression_1(param_1);
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,0x4b,uVar12,0);
|
|
}
|
|
goto LAB_001a03cb;
|
|
}
|
|
if (cVar1 == 'f') {
|
|
if (pcVar8[1] != 'p') goto LAB_001a027c;
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
if (pcVar8[2] == 'T') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 3;
|
|
iVar7 = 0;
|
|
}
|
|
else {
|
|
uVar6 = d_compact_number(param_1);
|
|
if ((uVar6 & 0x7fffffff) == 0x7fffffff) goto LAB_001a02e8;
|
|
iVar7 = uVar6 + 1;
|
|
}
|
|
iVar3 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar3) goto LAB_001a02e8;
|
|
puVar10 = (undefined4 *)(*(long *)(param_1 + 0x20) + (long)iVar3 * 0x18);
|
|
puVar10[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar3 + 1;
|
|
*puVar10 = 6;
|
|
*(long *)(puVar10 + 2) = (long)iVar7;
|
|
}
|
|
else {
|
|
if (9 < (byte)(cVar1 - 0x30U)) {
|
|
if (cVar1 == 'o') {
|
|
if (pcVar8[1] == 'n') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
puVar10 = (undefined4 *)d_unqualified_name(param_1);
|
|
goto joined_r0x001a0415;
|
|
}
|
|
}
|
|
else if (((cVar1 == 'i') || (cVar1 == 't')) && (pcVar8[1] == 'l')) {
|
|
uVar12 = 0;
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
if (cVar1 == 't') {
|
|
uVar12 = d_type(param_1);
|
|
cVar1 = *(char *)(*(long *)(param_1 + 0x18) + 1);
|
|
}
|
|
else {
|
|
cVar1 = pcVar8[3];
|
|
}
|
|
if (cVar1 == '\0') goto LAB_001a02e8;
|
|
uVar13 = d_exprlist(param_1,0x45);
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,0x31,uVar12,uVar13);
|
|
goto LAB_001a03cb;
|
|
}
|
|
LAB_001a027c:
|
|
puVar9 = (uint *)d_operator_name(param_1);
|
|
if (puVar9 == (uint *)0x0) {
|
|
LAB_001a041b:
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar2;
|
|
return 0;
|
|
}
|
|
uVar6 = *puVar9;
|
|
if (uVar6 == 0x32) {
|
|
puVar4 = *(undefined8 **)(puVar9 + 2);
|
|
pcVar8 = (char *)*puVar4;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + *(int *)(puVar4 + 2) + -2;
|
|
if (((*pcVar8 == 's') && (pcVar8[1] == 't')) && (pcVar8[2] == '\0')) {
|
|
uVar12 = d_type(param_1);
|
|
}
|
|
else {
|
|
iVar7 = *(int *)((long)puVar4 + 0x14);
|
|
if (iVar7 != 1) {
|
|
if (iVar7 < 2) {
|
|
if (iVar7 != 0) goto LAB_001a02e8;
|
|
LAB_001a02bb:
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,0x36,puVar9,0);
|
|
goto LAB_001a03cb;
|
|
}
|
|
if (iVar7 == 2) {
|
|
if ((((char *)**(undefined8 **)(puVar9 + 2))[1] == 'c') &&
|
|
((cVar1 = *(char *)**(undefined8 **)(puVar9 + 2), (byte)(cVar1 + 0x8eU) < 2 ||
|
|
((byte)(cVar1 + 0x9dU) < 2)))) {
|
|
uVar12 = d_type(param_1);
|
|
}
|
|
else if (*pcVar8 == 'f') {
|
|
uVar12 = d_operator_name(param_1);
|
|
}
|
|
else {
|
|
uVar12 = d_expression_1(param_1);
|
|
}
|
|
cVar1 = *pcVar8;
|
|
if (cVar1 == 'c') {
|
|
if ((pcVar8[1] != 'l') || (pcVar8[2] != '\0')) goto LAB_001a095a;
|
|
uVar13 = d_exprlist(param_1,0x45);
|
|
}
|
|
else if ((((cVar1 == 'd') || (cVar1 == 'p')) && (pcVar8[1] == 't')) &&
|
|
(pcVar8[2] == '\0')) {
|
|
uVar13 = d_unqualified_name(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar14 = d_template_args_1(param_1);
|
|
uVar13 = d_make_comp(param_1,4,uVar13,uVar14);
|
|
}
|
|
}
|
|
else {
|
|
LAB_001a095a:
|
|
uVar13 = d_expression_1(param_1);
|
|
}
|
|
d_make_comp(param_1,0x39,uVar12,uVar13);
|
|
puVar10 = (undefined4 *)d_make_comp();
|
|
goto LAB_001a03cb;
|
|
}
|
|
if (iVar7 != 3) goto LAB_001a02e8;
|
|
cVar1 = *pcVar8;
|
|
if (cVar1 == 'q') {
|
|
if ((pcVar8[1] != 'u') || (pcVar8[2] != '\0')) goto LAB_001a02e8;
|
|
d_expression_1(param_1);
|
|
LAB_001a07f4:
|
|
uVar12 = d_expression_1(param_1);
|
|
lVar11 = d_expression_1(param_1);
|
|
if (lVar11 == 0) {
|
|
LAB_001a02e8:
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar2;
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
if (cVar1 == 'f') {
|
|
d_operator_name(param_1);
|
|
goto LAB_001a07f4;
|
|
}
|
|
if ((cVar1 != 'n') || ((pcVar8[1] != 'w' && (pcVar8[1] != 'a'))))
|
|
goto LAB_001a02e8;
|
|
d_exprlist(param_1,0x5f);
|
|
uVar12 = d_type(param_1);
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
cVar1 = *pcVar8;
|
|
if (cVar1 == 'E') {
|
|
lVar11 = 0;
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
}
|
|
else if (cVar1 == 'p') {
|
|
if (pcVar8[1] != 'i') goto LAB_001a02e8;
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
lVar11 = d_exprlist(param_1,0x45);
|
|
}
|
|
else {
|
|
if ((cVar1 != 'i') || (pcVar8[1] != 'l')) goto LAB_001a02e8;
|
|
lVar11 = d_expression_1(param_1);
|
|
}
|
|
}
|
|
d_make_comp(param_1,0x3c,uVar12,lVar11);
|
|
d_make_comp();
|
|
puVar10 = (undefined4 *)d_make_comp();
|
|
goto LAB_001a03cb;
|
|
}
|
|
cVar1 = *pcVar8;
|
|
if (((cVar1 == 'p') || (cVar1 == 'm')) && (cVar1 == pcVar8[1])) {
|
|
bVar5 = true;
|
|
if (**(char **)(param_1 + 0x18) == '_') {
|
|
bVar5 = false;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
}
|
|
else {
|
|
bVar5 = false;
|
|
}
|
|
if (((*pcVar8 == 's') && (pcVar8[1] == 'P')) && (pcVar8[2] == '\0')) {
|
|
uVar12 = d_template_args_1(param_1);
|
|
}
|
|
else {
|
|
uVar12 = d_expression_1(param_1);
|
|
}
|
|
if (bVar5) {
|
|
uVar12 = d_make_comp(param_1,0x39,uVar12);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (uVar6 == 0x34) {
|
|
if (**(char **)(param_1 + 0x18) == '_') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar12 = d_exprlist(param_1,0x45);
|
|
goto LAB_001a070e;
|
|
}
|
|
}
|
|
else {
|
|
if (((0x34 < uVar6) || (uVar6 != 0x33)) ||
|
|
((uVar6 = puVar9[2], uVar6 == 2 || (2 < (int)uVar6)))) goto LAB_001a02e8;
|
|
if (uVar6 == 0) goto LAB_001a02bb;
|
|
if (uVar6 != 1) goto LAB_001a02e8;
|
|
}
|
|
uVar12 = d_expression_1(param_1);
|
|
}
|
|
LAB_001a070e:
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,0x37,puVar9,uVar12);
|
|
goto LAB_001a03cb;
|
|
}
|
|
puVar10 = (undefined4 *)d_unqualified_name(param_1);
|
|
joined_r0x001a0415:
|
|
if (puVar10 == (undefined4 *)0x0) goto LAB_001a041b;
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar12 = d_template_args_1(param_1);
|
|
puVar10 = (undefined4 *)d_make_comp(param_1,4,puVar10,uVar12);
|
|
goto LAB_001a03cb;
|
|
}
|
|
}
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar2;
|
|
}
|
|
lVar11 = d_make_comp(param_1,0x2e,puVar10,0);
|
|
*plVar15 = lVar11;
|
|
if (lVar11 == 0) {
|
|
return 0;
|
|
}
|
|
plVar15 = (long *)(lVar11 + 0x10);
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar8 == param_2) {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
return local_40[0];
|
|
}
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001a0a50 d_expression_1
|
|
|
|
uint * d_expression_1(long param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
int iVar2;
|
|
undefined8 *puVar3;
|
|
bool bVar4;
|
|
uint uVar5;
|
|
int iVar6;
|
|
uint *puVar7;
|
|
long lVar8;
|
|
undefined8 uVar9;
|
|
undefined8 uVar10;
|
|
char *pcVar11;
|
|
undefined8 uVar12;
|
|
|
|
pcVar11 = *(char **)(param_1 + 0x18);
|
|
cVar1 = *pcVar11;
|
|
if (cVar1 == 'L') {
|
|
puVar7 = (uint *)d_expr_primary();
|
|
return puVar7;
|
|
}
|
|
if (cVar1 == 'T') {
|
|
puVar7 = (uint *)d_template_param();
|
|
return puVar7;
|
|
}
|
|
if (cVar1 == 's') {
|
|
if (pcVar11[1] == 'r') {
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 2;
|
|
puVar7 = (uint *)d_type();
|
|
uVar9 = d_unqualified_name(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar12 = d_template_args_1(param_1);
|
|
uVar9 = d_make_comp(param_1,4,uVar9,uVar12);
|
|
uVar12 = 1;
|
|
}
|
|
else {
|
|
uVar12 = 1;
|
|
}
|
|
goto LAB_001a0d2b;
|
|
}
|
|
if (pcVar11[1] == 'p') {
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 2;
|
|
puVar7 = (uint *)d_expression_1();
|
|
uVar9 = 0;
|
|
uVar12 = 0x4b;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
}
|
|
else if (cVar1 == 'f') {
|
|
if (pcVar11[1] == 'p') {
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 2;
|
|
if (pcVar11[2] == 'T') {
|
|
iVar6 = 0;
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 3;
|
|
}
|
|
else {
|
|
uVar5 = d_compact_number();
|
|
iVar6 = uVar5 + 1;
|
|
if ((uVar5 & 0x7fffffff) == 0x7fffffff) {
|
|
return (uint *)0x0;
|
|
}
|
|
}
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar2) {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar7 = (uint *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*puVar7 = 6;
|
|
*(long *)(puVar7 + 2) = (long)iVar6;
|
|
return puVar7;
|
|
}
|
|
}
|
|
else {
|
|
if ((byte)(cVar1 - 0x30U) < 10) {
|
|
LAB_001a0a8a:
|
|
puVar7 = (uint *)d_unqualified_name(param_1);
|
|
if (puVar7 == (uint *)0x0) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != 'I') {
|
|
return puVar7;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar9 = d_template_args_1(param_1);
|
|
uVar12 = 4;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
if (cVar1 == 'o') {
|
|
if (pcVar11[1] == 'n') {
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 2;
|
|
goto LAB_001a0a8a;
|
|
}
|
|
}
|
|
else if (((cVar1 == 'i') || (cVar1 == 't')) && (pcVar11[1] == 'l')) {
|
|
pcVar11 = pcVar11 + 2;
|
|
puVar7 = (uint *)0x0;
|
|
*(char **)(param_1 + 0x18) = pcVar11;
|
|
if (cVar1 == 't') {
|
|
puVar7 = (uint *)d_type(param_1);
|
|
pcVar11 = *(char **)(param_1 + 0x18);
|
|
}
|
|
if (pcVar11[1] == '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
uVar9 = d_exprlist(param_1,0x45);
|
|
uVar12 = 0x31;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
}
|
|
puVar7 = (uint *)d_operator_name(param_1);
|
|
if (puVar7 == (uint *)0x0) {
|
|
return (uint *)0x0;
|
|
}
|
|
uVar5 = *puVar7;
|
|
if (uVar5 == 0x32) {
|
|
puVar3 = *(undefined8 **)(puVar7 + 2);
|
|
pcVar11 = (char *)*puVar3;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + *(int *)(puVar3 + 2) + -2;
|
|
if (((*pcVar11 == 's') && (pcVar11[1] == 't')) && (pcVar11[2] == '\0')) {
|
|
uVar9 = d_type(param_1);
|
|
uVar12 = 0x37;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
iVar6 = *(int *)((long)puVar3 + 0x14);
|
|
if (iVar6 == 1) {
|
|
cVar1 = *pcVar11;
|
|
if (((cVar1 == 'p') || (cVar1 == 'm')) && (cVar1 == pcVar11[1])) {
|
|
bVar4 = true;
|
|
if (**(char **)(param_1 + 0x18) == '_') {
|
|
bVar4 = false;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
}
|
|
else {
|
|
bVar4 = false;
|
|
}
|
|
if (((*pcVar11 == 's') && (pcVar11[1] == 'P')) && (pcVar11[2] == '\0')) {
|
|
uVar9 = d_template_args_1(param_1);
|
|
}
|
|
else {
|
|
uVar9 = d_expression_1(param_1);
|
|
}
|
|
if (bVar4) {
|
|
uVar9 = d_make_comp(param_1,0x39,uVar9);
|
|
}
|
|
goto LAB_001a0e18;
|
|
}
|
|
if (iVar6 < 2) {
|
|
if (iVar6 != 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
goto LAB_001a0b1d;
|
|
}
|
|
if (iVar6 == 2) {
|
|
if ((((char *)**(undefined8 **)(puVar7 + 2))[1] == 'c') &&
|
|
((cVar1 = *(char *)**(undefined8 **)(puVar7 + 2), (byte)(cVar1 + 0x8eU) < 2 ||
|
|
((byte)(cVar1 + 0x9dU) < 2)))) {
|
|
uVar9 = d_type(param_1);
|
|
}
|
|
else if (*pcVar11 == 'f') {
|
|
uVar9 = d_operator_name(param_1);
|
|
}
|
|
else {
|
|
uVar9 = d_expression_1(param_1);
|
|
}
|
|
cVar1 = *pcVar11;
|
|
if (cVar1 == 'c') {
|
|
if ((pcVar11[1] != 'l') || (pcVar11[2] != '\0')) goto LAB_001a0f15;
|
|
uVar12 = d_exprlist(param_1,0x45);
|
|
}
|
|
else if ((((cVar1 == 'd') || (cVar1 == 'p')) && (pcVar11[1] == 't')) && (pcVar11[2] == '\0'))
|
|
{
|
|
uVar12 = d_unqualified_name(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar10 = d_template_args_1(param_1);
|
|
uVar12 = d_make_comp(param_1,4,uVar12,uVar10);
|
|
}
|
|
}
|
|
else {
|
|
LAB_001a0f15:
|
|
uVar12 = d_expression_1(param_1);
|
|
}
|
|
uVar9 = d_make_comp(param_1,0x39,uVar9,uVar12);
|
|
uVar12 = 0x38;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
if (iVar6 != 3) {
|
|
return (uint *)0x0;
|
|
}
|
|
cVar1 = *pcVar11;
|
|
if (cVar1 == 'q') {
|
|
if (pcVar11[1] != 'u') {
|
|
return (uint *)0x0;
|
|
}
|
|
if (pcVar11[2] != '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
d_expression_1(param_1);
|
|
LAB_001a0cc1:
|
|
uVar9 = d_expression_1(param_1);
|
|
lVar8 = d_expression_1(param_1);
|
|
if (lVar8 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
}
|
|
else {
|
|
if (cVar1 == 'f') {
|
|
d_operator_name(param_1);
|
|
goto LAB_001a0cc1;
|
|
}
|
|
if (cVar1 != 'n') {
|
|
return (uint *)0x0;
|
|
}
|
|
if ((pcVar11[1] != 'w') && (pcVar11[1] != 'a')) {
|
|
return (uint *)0x0;
|
|
}
|
|
d_exprlist(param_1,0x5f);
|
|
uVar9 = d_type(param_1);
|
|
pcVar11 = *(char **)(param_1 + 0x18);
|
|
cVar1 = *pcVar11;
|
|
if (cVar1 == 'E') {
|
|
lVar8 = 0;
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 1;
|
|
}
|
|
else if (cVar1 == 'p') {
|
|
if (pcVar11[1] != 'i') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar11 + 2;
|
|
lVar8 = d_exprlist(param_1,0x45);
|
|
}
|
|
else {
|
|
if (cVar1 != 'i') {
|
|
return (uint *)0x0;
|
|
}
|
|
if (pcVar11[1] != 'l') {
|
|
return (uint *)0x0;
|
|
}
|
|
lVar8 = d_expression_1(param_1);
|
|
}
|
|
}
|
|
d_make_comp(param_1,0x3c,uVar9,lVar8);
|
|
uVar9 = d_make_comp();
|
|
uVar12 = 0x3a;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
if (uVar5 == 0x34) {
|
|
if (**(char **)(param_1 + 0x18) != '_') goto LAB_001a0e09;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar9 = d_exprlist(param_1,0x45);
|
|
}
|
|
else {
|
|
if (0x34 < uVar5) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (uVar5 != 0x33) {
|
|
return (uint *)0x0;
|
|
}
|
|
uVar5 = puVar7[2];
|
|
if (uVar5 == 2) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (2 < (int)uVar5) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (uVar5 == 0) {
|
|
LAB_001a0b1d:
|
|
uVar9 = 0;
|
|
uVar12 = 0x36;
|
|
goto LAB_001a0d2b;
|
|
}
|
|
if (uVar5 != 1) {
|
|
return (uint *)0x0;
|
|
}
|
|
LAB_001a0e09:
|
|
uVar9 = d_expression_1(param_1);
|
|
}
|
|
LAB_001a0e18:
|
|
uVar12 = 0x37;
|
|
LAB_001a0d2b:
|
|
puVar7 = (uint *)d_make_comp(param_1,uVar12,puVar7,uVar9);
|
|
return puVar7;
|
|
}
|
|
|
|
|
|
// 001a10f0 d_template_arg
|
|
|
|
undefined8 d_template_arg(long param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined4 uVar2;
|
|
undefined8 uVar3;
|
|
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
if (cVar1 == 'L') {
|
|
uVar3 = d_expr_primary();
|
|
return uVar3;
|
|
}
|
|
if (cVar1 < 'M') {
|
|
if ((byte)(cVar1 + 0xb7U) < 2) {
|
|
uVar3 = d_template_args();
|
|
return uVar3;
|
|
}
|
|
}
|
|
else if (cVar1 == 'X') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar2 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
uVar3 = d_expression_1();
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar2;
|
|
if (**(char **)(param_1 + 0x18) == 'E') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
else {
|
|
uVar3 = 0;
|
|
}
|
|
return uVar3;
|
|
}
|
|
uVar3 = d_type();
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 001a1170 d_template_args_1
|
|
|
|
undefined8 d_template_args_1(long param_1)
|
|
|
|
{
|
|
long lVar1;
|
|
undefined8 uVar2;
|
|
long *plVar3;
|
|
long local_20;
|
|
|
|
uVar2 = *(undefined8 *)(param_1 + 0x40);
|
|
if (**(char **)(param_1 + 0x18) == 'E') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar2 = d_make_comp(param_1,0x2f,0,0);
|
|
return uVar2;
|
|
}
|
|
local_20 = 0;
|
|
plVar3 = &local_20;
|
|
while( true ) {
|
|
lVar1 = d_template_arg(param_1);
|
|
if (lVar1 == 0) {
|
|
return 0;
|
|
}
|
|
lVar1 = d_make_comp(param_1,0x2f,lVar1,0);
|
|
*plVar3 = lVar1;
|
|
if (lVar1 == 0) break;
|
|
plVar3 = (long *)(lVar1 + 0x10);
|
|
if (**(char **)(param_1 + 0x18) == 'E') {
|
|
*(undefined8 *)(param_1 + 0x40) = uVar2;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
return local_20;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001a1220 d_template_args
|
|
|
|
undefined8 d_template_args(long param_1)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
|
|
if ((byte)(**(char **)(param_1 + 0x18) + 0xb7U) < 2) {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar1 = d_template_args_1();
|
|
return uVar1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001a1250 d_encoding
|
|
|
|
uint * d_encoding(long param_1,int param_2)
|
|
|
|
{
|
|
char cVar1;
|
|
int iVar2;
|
|
long lVar3;
|
|
int iVar4;
|
|
uint *puVar5;
|
|
int *piVar6;
|
|
uint uVar7;
|
|
char *pcVar9;
|
|
undefined8 uVar10;
|
|
uint *puVar11;
|
|
char *pcVar12;
|
|
uint uVar13;
|
|
ulong uVar14;
|
|
bool bVar15;
|
|
long lVar8;
|
|
|
|
pcVar12 = *(char **)(param_1 + 0x18);
|
|
if ((*pcVar12 == 'G') || (*pcVar12 == 'T')) {
|
|
iVar4 = *(int *)(param_1 + 0x48);
|
|
*(int *)(param_1 + 0x48) = iVar4 + 0x14;
|
|
if (*pcVar12 != 'T') {
|
|
if (*pcVar12 != 'G') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 1;
|
|
if (pcVar12[1] == '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 2;
|
|
cVar1 = pcVar12[1];
|
|
if (cVar1 == 'T') {
|
|
if ((pcVar12[2] == '\0') || (*(char **)(param_1 + 0x18) = pcVar12 + 3, pcVar12[2] != 'n')) {
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x49;
|
|
}
|
|
else {
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x4a;
|
|
}
|
|
}
|
|
else if (cVar1 < 'U') {
|
|
if (cVar1 == 'A') {
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x17;
|
|
}
|
|
else {
|
|
if (cVar1 != 'R') {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar5 = (uint *)d_name(param_1);
|
|
piVar6 = (int *)d_number_component(param_1);
|
|
uVar10 = 0x16;
|
|
}
|
|
}
|
|
else if (cVar1 == 'V') {
|
|
puVar5 = (uint *)d_name(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x13;
|
|
}
|
|
else {
|
|
if (cVar1 != 'r') {
|
|
return (uint *)0x0;
|
|
}
|
|
iVar4 = d_number_isra_0(param_1 + 0x18);
|
|
if (iVar4 < 2) {
|
|
return (uint *)0x0;
|
|
}
|
|
pcVar12 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar12 == '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 1;
|
|
if (*pcVar12 != '_') {
|
|
return (uint *)0x0;
|
|
}
|
|
uVar14 = (ulong)(iVar4 - 1);
|
|
puVar11 = (uint *)0x0;
|
|
pcVar12 = pcVar12 + 1;
|
|
do {
|
|
if (*pcVar12 == '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
iVar4 = (int)uVar14;
|
|
if (*pcVar12 == '$') {
|
|
cVar1 = pcVar12[1];
|
|
if (cVar1 == 'S') {
|
|
uVar7 = 0x2f;
|
|
}
|
|
else if (cVar1 == '_') {
|
|
uVar7 = 0x2e;
|
|
}
|
|
else {
|
|
if (cVar1 != '$') {
|
|
return (uint *)0x0;
|
|
}
|
|
uVar7 = 0x24;
|
|
}
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
pcVar9 = (char *)(*(long *)(param_1 + 0x18) + 2);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar2) {
|
|
*(char **)(param_1 + 0x18) = pcVar9;
|
|
return (uint *)0x0;
|
|
}
|
|
uVar13 = iVar4 - 2;
|
|
puVar5 = (uint *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar5[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*puVar5 = 0x41;
|
|
puVar5[2] = uVar7;
|
|
*(char **)(param_1 + 0x18) = pcVar9;
|
|
}
|
|
else {
|
|
lVar3 = 1;
|
|
while (lVar8 = lVar3, uVar7 = (uint)lVar8, (int)uVar7 < iVar4) {
|
|
if ((pcVar12[lVar8] == '\0') || (lVar3 = lVar8 + 1, pcVar12[lVar8] == '$')) break;
|
|
}
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar2) {
|
|
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + lVar8;
|
|
return (uint *)0x0;
|
|
}
|
|
uVar13 = iVar4 - uVar7;
|
|
puVar5 = (uint *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
puVar5[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
puVar5[0] = 0;
|
|
puVar5[1] = 0;
|
|
pcVar9 = (char *)(lVar8 + *(long *)(param_1 + 0x18));
|
|
*(char **)(puVar5 + 2) = pcVar12;
|
|
puVar5[4] = uVar7;
|
|
*(char **)(param_1 + 0x18) = pcVar9;
|
|
}
|
|
uVar14 = (ulong)uVar13;
|
|
if ((puVar11 != (uint *)0x0) &&
|
|
(puVar5 = (uint *)d_make_comp(param_1,0x40,puVar11), puVar5 == (uint *)0x0)) {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar11 = puVar5;
|
|
pcVar12 = pcVar9;
|
|
} while (0 < (int)uVar14);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x3f;
|
|
}
|
|
goto LAB_001a1393;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 1;
|
|
if (pcVar12[1] == '\0') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 2;
|
|
switch(pcVar12[1]) {
|
|
case 'A':
|
|
puVar5 = (uint *)d_template_arg(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x30;
|
|
break;
|
|
default:
|
|
goto LAB_001a142b;
|
|
case 'C':
|
|
piVar6 = (int *)d_type(param_1);
|
|
iVar4 = d_number_isra_0(param_1 + 0x18);
|
|
if (iVar4 < 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != '_') {
|
|
return (uint *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
puVar5 = (uint *)d_type(param_1);
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 5;
|
|
uVar10 = 0xb;
|
|
break;
|
|
case 'F':
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0xe;
|
|
break;
|
|
case 'H':
|
|
puVar5 = (uint *)d_name(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x14;
|
|
break;
|
|
case 'I':
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0xc;
|
|
break;
|
|
case 'J':
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x12;
|
|
break;
|
|
case 'S':
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0xd;
|
|
break;
|
|
case 'T':
|
|
*(int *)(param_1 + 0x48) = iVar4 + 10;
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 10;
|
|
break;
|
|
case 'V':
|
|
*(int *)(param_1 + 0x48) = iVar4 + 0xf;
|
|
puVar5 = (uint *)d_type(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 9;
|
|
break;
|
|
case 'W':
|
|
puVar5 = (uint *)d_name(param_1);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x15;
|
|
break;
|
|
case 'c':
|
|
iVar4 = d_call_offset(param_1,0);
|
|
if (iVar4 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
iVar4 = d_call_offset(param_1,0);
|
|
if (iVar4 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x11;
|
|
break;
|
|
case 'h':
|
|
iVar4 = d_call_offset(param_1,0x68);
|
|
if (iVar4 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0xf;
|
|
break;
|
|
case 'v':
|
|
iVar4 = d_call_offset(param_1,0x76);
|
|
if (iVar4 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
puVar5 = (uint *)d_encoding(param_1,0);
|
|
piVar6 = (int *)0x0;
|
|
uVar10 = 0x10;
|
|
}
|
|
goto LAB_001a1393;
|
|
}
|
|
puVar5 = (uint *)d_name();
|
|
if (puVar5 == (uint *)0x0) {
|
|
return (uint *)0x0;
|
|
}
|
|
if ((param_2 != 0) && ((*(byte *)(param_1 + 0x10) & 1) == 0)) {
|
|
while( true ) {
|
|
uVar7 = *puVar5 - 0x1c;
|
|
if ((0x34 < uVar7) || ((1L << ((byte)uVar7 & 0x3f) & 0x1a00000000001fU) == 0)) break;
|
|
puVar5 = *(uint **)(puVar5 + 2);
|
|
}
|
|
if (*puVar5 != 2) {
|
|
return puVar5;
|
|
}
|
|
piVar6 = *(int **)(puVar5 + 4);
|
|
iVar4 = *piVar6;
|
|
while( true ) {
|
|
if (0x34 < iVar4 - 0x1cU) {
|
|
return puVar5;
|
|
}
|
|
if ((1L << ((byte)(iVar4 - 0x1cU) & 0x3f) & 0x1a00000000001fU) == 0) break;
|
|
piVar6 = *(int **)(piVar6 + 2);
|
|
iVar4 = *piVar6;
|
|
*(int **)(puVar5 + 4) = piVar6;
|
|
}
|
|
return puVar5;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) == '\0') {
|
|
return puVar5;
|
|
}
|
|
puVar11 = puVar5;
|
|
if (**(char **)(param_1 + 0x18) == 'E') {
|
|
return puVar5;
|
|
}
|
|
do {
|
|
uVar7 = *puVar11;
|
|
if (uVar7 == 4) {
|
|
puVar11 = *(uint **)(puVar11 + 2);
|
|
goto joined_r0x001a1757;
|
|
}
|
|
if (uVar7 < 5) {
|
|
if (uVar7 != 2) break;
|
|
puVar11 = *(uint **)(puVar11 + 4);
|
|
}
|
|
else {
|
|
if ((0x34 < uVar7 - 0x1c) || ((1L << ((byte)(uVar7 - 0x1c) & 0x3f) & 0x1a00000000001fU) == 0))
|
|
break;
|
|
puVar11 = *(uint **)(puVar11 + 2);
|
|
}
|
|
} while (puVar11 != (uint *)0x0);
|
|
LAB_001a13e4:
|
|
bVar15 = false;
|
|
LAB_001a13e6:
|
|
piVar6 = (int *)d_bare_function_type(param_1,bVar15);
|
|
if (piVar6 == (int *)0x0) {
|
|
LAB_001a142b:
|
|
return (uint *)0x0;
|
|
}
|
|
if (((param_2 == 0) && (*puVar5 == 2)) && (*piVar6 == 0x29)) {
|
|
piVar6[2] = 0;
|
|
piVar6[3] = 0;
|
|
}
|
|
uVar10 = 3;
|
|
LAB_001a1393:
|
|
puVar5 = (uint *)d_make_comp(param_1,uVar10,puVar5,piVar6);
|
|
return puVar5;
|
|
joined_r0x001a1757:
|
|
if (puVar11 == (uint *)0x0) goto LAB_001a1780;
|
|
uVar7 = *puVar11;
|
|
if (8 < uVar7) {
|
|
bVar15 = uVar7 != 0x35;
|
|
goto LAB_001a13e6;
|
|
}
|
|
if (6 < uVar7) goto LAB_001a13e4;
|
|
if (1 < uVar7 - 1) goto LAB_001a1780;
|
|
puVar11 = *(uint **)(puVar11 + 4);
|
|
goto joined_r0x001a1757;
|
|
LAB_001a1780:
|
|
bVar15 = true;
|
|
goto LAB_001a13e6;
|
|
}
|
|
|
|
|
|
// 001a18d0 d_name
|
|
|
|
long d_name(long param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
int iVar2;
|
|
long lVar3;
|
|
undefined8 uVar4;
|
|
int *piVar5;
|
|
int *piVar6;
|
|
long *plVar7;
|
|
char *pcVar8;
|
|
int *piVar9;
|
|
long lVar10;
|
|
byte bVar11;
|
|
uint uVar12;
|
|
undefined8 *puVar13;
|
|
char cVar14;
|
|
long lVar15;
|
|
long local_40 [2];
|
|
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
cVar14 = *pcVar8;
|
|
if (cVar14 == 'U') {
|
|
lVar3 = d_unqualified_name();
|
|
return lVar3;
|
|
}
|
|
if (cVar14 < 'V') {
|
|
if (cVar14 == 'N') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
plVar7 = (long *)d_cv_qualifiers(param_1,local_40,1);
|
|
if (plVar7 == (long *)0x0) {
|
|
return 0;
|
|
}
|
|
lVar3 = d_ref_qualifier(param_1);
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
cVar14 = *pcVar8;
|
|
if (cVar14 == '\0') {
|
|
LAB_001a1a40:
|
|
*plVar7 = 0;
|
|
return 0;
|
|
}
|
|
lVar15 = 0;
|
|
LAB_001a1b7e:
|
|
if (cVar14 == 'D') {
|
|
if ((pcVar8[1] & 0xdfU) == 0x54) {
|
|
lVar10 = d_type();
|
|
goto LAB_001a1c0a;
|
|
}
|
|
lVar10 = d_unqualified_name(param_1);
|
|
goto LAB_001a1c0a;
|
|
}
|
|
bVar11 = cVar14 - 0x30;
|
|
uVar12 = 0;
|
|
lVar10 = lVar15;
|
|
if (bVar11 < 0x26) goto LAB_001a1c6a;
|
|
do {
|
|
if (((byte)(cVar14 + 0x9fU) < 0x1a) || ((char)uVar12 != '\0')) {
|
|
lVar10 = d_unqualified_name(param_1);
|
|
if (lVar15 != 0) goto LAB_001a1c80;
|
|
LAB_001a19f7:
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
if (cVar14 == 'S') goto LAB_001a1a2d;
|
|
}
|
|
else {
|
|
if (cVar14 == 'S') {
|
|
lVar10 = d_substitution(param_1);
|
|
if (lVar15 != 0) {
|
|
LAB_001a1c80:
|
|
lVar10 = d_make_comp(param_1,1,lVar15,lVar10);
|
|
goto LAB_001a19f7;
|
|
}
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
goto LAB_001a1a2d;
|
|
}
|
|
if (cVar14 == 'I') {
|
|
if (lVar15 != 0) {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
lVar10 = d_template_args_1(param_1);
|
|
uVar4 = 4;
|
|
LAB_001a1c48:
|
|
lVar10 = d_make_comp(param_1,uVar4,lVar15,lVar10);
|
|
goto LAB_001a19f7;
|
|
}
|
|
goto LAB_001a1a40;
|
|
}
|
|
if (cVar14 != 'T') {
|
|
if (cVar14 == 'E') {
|
|
*plVar7 = lVar15;
|
|
if (lVar15 == 0) {
|
|
return 0;
|
|
}
|
|
if (lVar3 != 0) {
|
|
*(long *)(lVar3 + 8) = local_40[0];
|
|
local_40[0] = lVar3;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != 'E') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
return local_40[0];
|
|
}
|
|
if ((cVar14 != 'M') || (lVar15 == 0)) goto LAB_001a1a40;
|
|
pcVar8 = pcVar8 + 1;
|
|
*(char **)(param_1 + 0x18) = pcVar8;
|
|
lVar10 = lVar15;
|
|
goto LAB_001a1a2d;
|
|
}
|
|
lVar10 = d_template_param(param_1);
|
|
LAB_001a1c0a:
|
|
uVar4 = 1;
|
|
if (lVar15 != 0) goto LAB_001a1c48;
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
}
|
|
if (*pcVar8 != 'E') goto code_r0x001a1a0f;
|
|
bVar11 = 0x15;
|
|
cVar14 = 'E';
|
|
LAB_001a1c6a:
|
|
uVar12 = (uint)(0x20100803ff >> (bVar11 & 0x3f)) & 1;
|
|
lVar15 = lVar10;
|
|
} while( true );
|
|
}
|
|
if (cVar14 != 'S') goto LAB_001a1b00;
|
|
if (pcVar8[1] != 't') {
|
|
lVar3 = d_substitution(param_1,0);
|
|
if (**(char **)(param_1 + 0x18) != 'I') {
|
|
return lVar3;
|
|
}
|
|
goto LAB_001a1923;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
uVar4 = d_unqualified_name();
|
|
iVar1 = *(int *)(param_1 + 0x28);
|
|
if (iVar1 < *(int *)(param_1 + 0x2c)) {
|
|
*(int *)(param_1 + 0x28) = iVar1 + 1;
|
|
puVar13 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar1 * 0x18);
|
|
*puVar13 = 0;
|
|
puVar13[1] = &DAT_001b4e69;
|
|
*(undefined4 *)(puVar13 + 2) = 3;
|
|
}
|
|
else {
|
|
puVar13 = (undefined8 *)0x0;
|
|
}
|
|
lVar3 = d_make_comp(param_1,1,puVar13,uVar4);
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 3;
|
|
cVar14 = **(char **)(param_1 + 0x18);
|
|
}
|
|
else {
|
|
if (cVar14 == 'Z') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
piVar5 = (int *)d_encoding(param_1,0);
|
|
if (piVar5 == (int *)0x0) {
|
|
return 0;
|
|
}
|
|
pcVar8 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar8 != 'E') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 1;
|
|
if (pcVar8[1] == 's') {
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
iVar1 = d_discriminator(param_1);
|
|
if (iVar1 == 0) {
|
|
return 0;
|
|
}
|
|
iVar1 = *(int *)(param_1 + 0x28);
|
|
if (iVar1 < *(int *)(param_1 + 0x2c)) {
|
|
*(int *)(param_1 + 0x28) = iVar1 + 1;
|
|
piVar6 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar1 * 0x18);
|
|
piVar6[0] = 0;
|
|
piVar6[1] = 0;
|
|
*(char **)(piVar6 + 2) = "string literal";
|
|
piVar6[4] = 0xe;
|
|
goto LAB_001a19bc;
|
|
}
|
|
}
|
|
else {
|
|
if (pcVar8[1] != 'd') {
|
|
piVar6 = (int *)d_name(param_1);
|
|
if (((piVar6 != (int *)0x0) && ((*piVar6 - 0x46U & 0xfffffffd) != 0)) &&
|
|
(iVar1 = d_discriminator(param_1), iVar1 == 0)) {
|
|
return 0;
|
|
}
|
|
goto LAB_001a19bc;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar8 + 2;
|
|
iVar1 = d_compact_number(param_1);
|
|
if (iVar1 < 0) {
|
|
return 0;
|
|
}
|
|
piVar9 = (int *)d_name(param_1);
|
|
if (((piVar9 != (int *)0x0) && ((*piVar9 - 0x46U & 0xfffffffd) != 0)) &&
|
|
(iVar2 = d_discriminator(param_1), iVar2 == 0)) {
|
|
return 0;
|
|
}
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
piVar6 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
piVar6[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
*piVar6 = 0x47;
|
|
piVar6[4] = iVar1;
|
|
*(int **)(piVar6 + 2) = piVar9;
|
|
goto LAB_001a19bc;
|
|
}
|
|
}
|
|
piVar6 = (int *)0x0;
|
|
LAB_001a19bc:
|
|
if ((*piVar5 == 3) && (piVar9 = *(int **)(piVar5 + 4), *piVar9 == 0x29)) {
|
|
piVar9[2] = 0;
|
|
piVar9[3] = 0;
|
|
}
|
|
lVar3 = d_make_comp(param_1,2,piVar5,piVar6);
|
|
return lVar3;
|
|
}
|
|
LAB_001a1b00:
|
|
lVar3 = d_unqualified_name(param_1);
|
|
cVar14 = **(char **)(param_1 + 0x18);
|
|
}
|
|
if (cVar14 != 'I') {
|
|
return lVar3;
|
|
}
|
|
if ((lVar3 == 0) || (iVar1 = *(int *)(param_1 + 0x38), *(int *)(param_1 + 0x3c) <= iVar1)) {
|
|
return 0;
|
|
}
|
|
*(long *)(*(long *)(param_1 + 0x30) + (long)iVar1 * 8) = lVar3;
|
|
*(int *)(param_1 + 0x38) = iVar1 + 1;
|
|
LAB_001a1923:
|
|
uVar4 = d_template_args(param_1);
|
|
lVar3 = d_make_comp(param_1,4,lVar3,uVar4);
|
|
return lVar3;
|
|
code_r0x001a1a0f:
|
|
if ((lVar10 == 0) || (iVar1 = *(int *)(param_1 + 0x38), *(int *)(param_1 + 0x3c) <= iVar1))
|
|
goto LAB_001a1a40;
|
|
*(long *)(*(long *)(param_1 + 0x30) + (long)iVar1 * 8) = lVar10;
|
|
*(int *)(param_1 + 0x38) = iVar1 + 1;
|
|
LAB_001a1a2d:
|
|
cVar14 = *pcVar8;
|
|
lVar15 = lVar10;
|
|
if (cVar14 == '\0') goto LAB_001a1a40;
|
|
goto LAB_001a1b7e;
|
|
}
|
|
|
|
|
|
// 001a1e60 d_type
|
|
|
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
|
|
|
|
int * d_type(long param_1)
|
|
|
|
{
|
|
undefined4 uVar1;
|
|
undefined4 uVar2;
|
|
undefined4 uVar3;
|
|
code *pcVar4;
|
|
int iVar5;
|
|
long *plVar6;
|
|
int *piVar7;
|
|
undefined8 uVar8;
|
|
char *pcVar9;
|
|
long lVar10;
|
|
undefined8 *puVar11;
|
|
char *pcVar12;
|
|
char cVar13;
|
|
long lVar14;
|
|
char *pcVar15;
|
|
int iVar16;
|
|
int *local_30;
|
|
|
|
pcVar15 = *(char **)(param_1 + 0x18);
|
|
iVar5 = next_is_type_qual_isra_0(pcVar15);
|
|
if (iVar5 != 0) {
|
|
plVar6 = (long *)d_cv_qualifiers(param_1,&local_30,0);
|
|
if (plVar6 == (long *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) == 'F') {
|
|
piVar7 = (int *)d_function_type(param_1);
|
|
*plVar6 = (long)piVar7;
|
|
}
|
|
else {
|
|
piVar7 = (int *)d_type();
|
|
*plVar6 = (long)piVar7;
|
|
}
|
|
if (piVar7 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
if (*piVar7 - 0x1fU < 2) {
|
|
lVar14 = *(long *)(piVar7 + 2);
|
|
*(int **)(piVar7 + 2) = local_30;
|
|
local_30 = (int *)*plVar6;
|
|
*plVar6 = lVar14;
|
|
}
|
|
if (local_30 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
iVar5 = *(int *)(param_1 + 0x38);
|
|
if (*(int *)(param_1 + 0x3c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar5 * 8) = local_30;
|
|
*(int *)(param_1 + 0x38) = iVar5 + 1;
|
|
return local_30;
|
|
}
|
|
switch(*pcVar15) {
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case 'N':
|
|
case 'Z':
|
|
local_30 = (int *)d_name(param_1);
|
|
break;
|
|
default:
|
|
goto switchD_001a1e9e_caseD_3a;
|
|
case 'A':
|
|
pcVar12 = pcVar15 + 1;
|
|
*(char **)(param_1 + 0x18) = pcVar12;
|
|
if (pcVar15[1] == '_') {
|
|
puVar11 = (undefined8 *)0x0;
|
|
}
|
|
else {
|
|
pcVar9 = pcVar12;
|
|
if ((byte)(pcVar15[1] - 0x30U) < 10) {
|
|
do {
|
|
pcVar15 = pcVar9;
|
|
pcVar9 = pcVar15 + 1;
|
|
*(char **)(param_1 + 0x18) = pcVar9;
|
|
} while ((byte)(*pcVar9 - 0x30U) < 10);
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
iVar16 = (int)pcVar9 - (int)pcVar12;
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
puVar11 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
*(undefined4 *)((long)puVar11 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
if (iVar16 < 1) {
|
|
return (int *)0x0;
|
|
}
|
|
*puVar11 = 0;
|
|
puVar11[1] = pcVar12;
|
|
*(int *)(puVar11 + 2) = iVar16;
|
|
cVar13 = pcVar15[1];
|
|
}
|
|
else {
|
|
uVar1 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
puVar11 = (undefined8 *)d_expression_1(param_1);
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar1;
|
|
if (puVar11 == (undefined8 *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
pcVar9 = *(char **)(param_1 + 0x18);
|
|
cVar13 = *pcVar9;
|
|
}
|
|
pcVar12 = pcVar9;
|
|
if (cVar13 != '_') {
|
|
return (int *)0x0;
|
|
}
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar12 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x2a,puVar11,uVar8);
|
|
break;
|
|
case 'C':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x25,uVar8,0);
|
|
break;
|
|
case 'D':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
if (pcVar15[1] == '\0') {
|
|
return (int *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 2;
|
|
switch(pcVar15[1]) {
|
|
case 'F':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
_DAT_00000000 = 0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
local_30 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
local_30[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*local_30 = 0x2c;
|
|
cVar13 = pcVar15[2];
|
|
*(ushort *)(local_30 + 4) = (ushort)((byte)(cVar13 - 0x30U) < 10);
|
|
if ((byte)(cVar13 - 0x30U) < 10) {
|
|
d_number_isra_0(param_1 + 0x18);
|
|
}
|
|
piVar7 = local_30;
|
|
uVar8 = d_type(param_1);
|
|
*(undefined8 *)(piVar7 + 2) = uVar8;
|
|
if (*(long *)(local_30 + 2) == 0) {
|
|
return (int *)0x0;
|
|
}
|
|
d_number_isra_0(param_1 + 0x18);
|
|
pcVar15 = *(char **)(param_1 + 0x18);
|
|
cVar13 = '\0';
|
|
if (*pcVar15 != '\0') {
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
cVar13 = *pcVar15;
|
|
}
|
|
*(ushort *)((long)local_30 + 0x12) = (ushort)(cVar13 == 's');
|
|
return local_30;
|
|
default:
|
|
return (int *)0x0;
|
|
case 'T':
|
|
case 't':
|
|
uVar1 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
uVar8 = d_expression_1(param_1);
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar1;
|
|
local_30 = (int *)d_make_comp(param_1,0x43,uVar8,0);
|
|
if (local_30 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
pcVar15 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar15 == '\0') {
|
|
return (int *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
if (*pcVar15 != 'E') {
|
|
return (int *)0x0;
|
|
}
|
|
goto LAB_001a2019;
|
|
case 'a':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[0] = 0;
|
|
piVar7[1] = 0;
|
|
*(undefined **)(piVar7 + 2) = &DAT_001b4e6d;
|
|
piVar7[4] = 4;
|
|
return piVar7;
|
|
case 'c':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[0] = 0;
|
|
piVar7[1] = 0;
|
|
*(char **)(piVar7 + 2) = "decltype(auto)";
|
|
piVar7[4] = 0xe;
|
|
return piVar7;
|
|
case 'd':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef640;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 9;
|
|
return piVar7;
|
|
case 'e':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef660;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 10;
|
|
return piVar7;
|
|
case 'f':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef620;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 9;
|
|
return piVar7;
|
|
case 'h':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef680;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 4;
|
|
return piVar7;
|
|
case 'i':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef6e0;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 8;
|
|
return piVar7;
|
|
case 'n':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef700;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 0x11;
|
|
return piVar7;
|
|
case 'p':
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x4b,uVar8,0);
|
|
break;
|
|
case 's':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef6c0;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 8;
|
|
return piVar7;
|
|
case 'u':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*piVar7 = 0x27;
|
|
piVar7[2] = 0x1ef6a0;
|
|
piVar7[3] = 0;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 7;
|
|
return piVar7;
|
|
case 'v':
|
|
if (pcVar15[2] == '_') {
|
|
uVar1 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 3;
|
|
lVar14 = d_expression_1(param_1);
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar1;
|
|
}
|
|
else {
|
|
lVar14 = d_number_component(param_1);
|
|
}
|
|
if (lVar14 == 0) {
|
|
return (int *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != '_') {
|
|
return (int *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x2d,lVar14,uVar8);
|
|
}
|
|
break;
|
|
case 'F':
|
|
local_30 = (int *)d_function_type(param_1);
|
|
break;
|
|
case 'G':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x26,uVar8,0);
|
|
break;
|
|
case 'M':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
lVar14 = d_type(param_1);
|
|
if (lVar14 == 0) {
|
|
return (int *)0x0;
|
|
}
|
|
lVar10 = d_type(param_1);
|
|
if (lVar10 == 0) {
|
|
return (int *)0x0;
|
|
}
|
|
local_30 = (int *)d_make_comp(param_1,0x2b,lVar14,lVar10);
|
|
break;
|
|
case 'O':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x24,uVar8,0);
|
|
break;
|
|
case 'P':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x22,uVar8,0);
|
|
break;
|
|
case 'R':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x23,uVar8,0);
|
|
break;
|
|
case 'S':
|
|
if ((0x2f < (byte)((byte)pcVar15[1] - 0x30)) ||
|
|
((0x87fffffe03ffU >> ((ulong)((byte)pcVar15[1] - 0x30) & 0x3f) & 1) == 0)) {
|
|
local_30 = (int *)d_name(param_1);
|
|
if (local_30 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
if (*local_30 == 0x18) {
|
|
return local_30;
|
|
}
|
|
goto LAB_001a2019;
|
|
}
|
|
local_30 = (int *)d_substitution(param_1,0);
|
|
if (**(char **)(param_1 + 0x18) != 'I') {
|
|
return local_30;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
LAB_001a208f:
|
|
uVar8 = d_template_args_1(param_1);
|
|
LAB_001a209a:
|
|
local_30 = (int *)d_make_comp(param_1,4,local_30,uVar8);
|
|
break;
|
|
case 'T':
|
|
local_30 = (int *)d_template_param(param_1);
|
|
pcVar15 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar15 == 'I') {
|
|
if (*(int *)(param_1 + 0x50) == 0) {
|
|
if (local_30 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
iVar5 = *(int *)(param_1 + 0x38);
|
|
if (*(int *)(param_1 + 0x3c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar5 * 8) = local_30;
|
|
uVar8 = 0;
|
|
*(int *)(param_1 + 0x38) = iVar5 + 1;
|
|
if ((byte)(*pcVar15 + 0xb7U) < 2) {
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
goto LAB_001a208f;
|
|
}
|
|
goto LAB_001a209a;
|
|
}
|
|
uVar1 = *(undefined4 *)(param_1 + 0x28);
|
|
uVar2 = *(undefined4 *)(param_1 + 0x38);
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar3 = *(undefined4 *)(param_1 + 0x48);
|
|
uVar8 = d_template_args_1(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
if (local_30 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
iVar5 = *(int *)(param_1 + 0x38);
|
|
if (*(int *)(param_1 + 0x3c) <= iVar5) {
|
|
return (int *)0x0;
|
|
}
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar5 * 8) = local_30;
|
|
*(int *)(param_1 + 0x38) = iVar5 + 1;
|
|
local_30 = (int *)d_make_comp(param_1,4,local_30,uVar8);
|
|
}
|
|
else {
|
|
*(char **)(param_1 + 0x18) = pcVar15;
|
|
*(undefined4 *)(param_1 + 0x28) = uVar1;
|
|
*(undefined4 *)(param_1 + 0x38) = uVar2;
|
|
*(undefined4 *)(param_1 + 0x48) = uVar3;
|
|
}
|
|
}
|
|
break;
|
|
case 'U':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
piVar7 = (int *)d_source_name(param_1);
|
|
if (**(char **)(param_1 + 0x18) == 'I') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
local_30 = piVar7;
|
|
uVar8 = d_template_args_1(param_1);
|
|
piVar7 = (int *)d_make_comp(param_1,4,local_30,uVar8);
|
|
}
|
|
local_30 = piVar7;
|
|
uVar8 = d_type(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x21,uVar8,piVar7);
|
|
break;
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'e':
|
|
case 'f':
|
|
case 'g':
|
|
case 'h':
|
|
case 'i':
|
|
case 'j':
|
|
case 'l':
|
|
case 'm':
|
|
case 'n':
|
|
case 'o':
|
|
case 's':
|
|
case 't':
|
|
case 'v':
|
|
case 'w':
|
|
case 'x':
|
|
case 'y':
|
|
case 'z':
|
|
iVar5 = *(int *)(param_1 + 0x28);
|
|
lVar14 = (long)(*pcVar15 + -0x61) * 0x20;
|
|
if (*(int *)(param_1 + 0x2c) <= iVar5) {
|
|
local_30 = (int *)0x0;
|
|
/* WARNING: Does not return */
|
|
pcVar4 = (code *)invalidInstructionException();
|
|
(*pcVar4)();
|
|
}
|
|
piVar7 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar5 * 0x18);
|
|
piVar7[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar5 + 1;
|
|
*(undefined1 **)(piVar7 + 2) = cplus_demangle_builtin_types + lVar14;
|
|
iVar5 = *(int *)(cplus_demangle_builtin_types + lVar14 + 8);
|
|
*piVar7 = 0x27;
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + iVar5;
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
return piVar7;
|
|
case 'u':
|
|
*(char **)(param_1 + 0x18) = pcVar15 + 1;
|
|
uVar8 = d_source_name(param_1);
|
|
local_30 = (int *)d_make_comp(param_1,0x28,uVar8,0);
|
|
}
|
|
if (local_30 != (int *)0x0) {
|
|
LAB_001a2019:
|
|
iVar5 = *(int *)(param_1 + 0x38);
|
|
if (iVar5 < *(int *)(param_1 + 0x3c)) {
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar5 * 8) = local_30;
|
|
*(int *)(param_1 + 0x38) = iVar5 + 1;
|
|
return local_30;
|
|
}
|
|
}
|
|
switchD_001a1e9e_caseD_3a:
|
|
return (int *)0x0;
|
|
}
|
|
|
|
|
|
// 001a28d0 d_operator_name
|
|
|
|
undefined8 * d_operator_name(long param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined4 uVar2;
|
|
char *pcVar3;
|
|
char cVar4;
|
|
int iVar5;
|
|
long lVar6;
|
|
undefined8 uVar7;
|
|
undefined8 *puVar8;
|
|
int iVar9;
|
|
char cVar10;
|
|
int iVar11;
|
|
char cVar12;
|
|
bool bVar13;
|
|
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar3 == '\0') {
|
|
cVar12 = '\0';
|
|
cVar10 = '\0';
|
|
}
|
|
else {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar12 = *pcVar3;
|
|
cVar10 = '\0';
|
|
if (pcVar3[1] != '\0') {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
cVar10 = pcVar3[1];
|
|
if (cVar12 == 'v') {
|
|
if ((byte)(cVar10 - 0x30U) < 10) {
|
|
lVar6 = d_source_name(param_1);
|
|
iVar9 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar9) {
|
|
return (undefined8 *)0x0;
|
|
}
|
|
puVar8 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar9 * 0x18);
|
|
*(undefined4 *)((long)puVar8 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar9 + 1;
|
|
if (lVar6 == 0) {
|
|
return (undefined8 *)0x0;
|
|
}
|
|
*puVar8 = 0x33;
|
|
puVar8[2] = lVar6;
|
|
*(int *)(puVar8 + 1) = cVar10 + -0x30;
|
|
return puVar8;
|
|
}
|
|
}
|
|
else if ((cVar12 == 'c') && (cVar10 == 'v')) {
|
|
uVar2 = *(undefined4 *)(param_1 + 0x50);
|
|
*(uint *)(param_1 + 0x50) = (uint)(*(int *)(param_1 + 0x4c) == 0);
|
|
uVar7 = d_type(param_1);
|
|
if (*(int *)(param_1 + 0x50) == 0) {
|
|
puVar8 = (undefined8 *)d_make_comp(param_1,0x34,uVar7,0);
|
|
}
|
|
else {
|
|
puVar8 = (undefined8 *)d_make_comp(param_1,0x35,uVar7,0);
|
|
}
|
|
*(undefined4 *)(param_1 + 0x50) = uVar2;
|
|
return puVar8;
|
|
}
|
|
}
|
|
}
|
|
iVar11 = 0x43;
|
|
iVar9 = 0;
|
|
do {
|
|
iVar5 = (iVar11 - iVar9) / 2 + iVar9;
|
|
pcVar3 = *(char **)(cplus_demangle_operators + (long)iVar5 * 0x18);
|
|
cVar1 = *pcVar3;
|
|
bVar13 = SBORROW1(cVar1,cVar12);
|
|
cVar4 = cVar1 - cVar12;
|
|
if (cVar1 == cVar12) {
|
|
cVar4 = pcVar3[1];
|
|
bVar13 = SBORROW1(cVar4,cVar10);
|
|
cVar4 = cVar4 - cVar10;
|
|
if (cVar4 == '\0') {
|
|
iVar9 = *(int *)(param_1 + 0x28);
|
|
if (*(int *)(param_1 + 0x2c) <= iVar9) {
|
|
return (undefined8 *)0x0;
|
|
}
|
|
puVar8 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar9 * 0x18);
|
|
*(undefined4 *)((long)puVar8 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar9 + 1;
|
|
*(undefined4 *)puVar8 = 0x32;
|
|
puVar8[1] = cplus_demangle_operators + (long)iVar5 * 0x18;
|
|
return puVar8;
|
|
}
|
|
}
|
|
if (bVar13 != cVar4 < '\0') {
|
|
iVar9 = iVar5 + 1;
|
|
iVar5 = iVar11;
|
|
}
|
|
iVar11 = iVar5;
|
|
} while (iVar9 != iVar11);
|
|
return (undefined8 *)0x0;
|
|
}
|
|
|
|
|
|
// 001a2a80 d_parmlist
|
|
|
|
long d_parmlist(long param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
long lVar2;
|
|
char *pcVar3;
|
|
long *plVar4;
|
|
long local_20 [2];
|
|
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
local_20[0] = 0;
|
|
cVar1 = *pcVar3;
|
|
if ((cVar1 != 'E' && cVar1 != '\0') && (plVar4 = local_20, cVar1 != '.')) {
|
|
while (((cVar1 != 'R' && (cVar1 != 'O')) || (pcVar3[1] != 'E'))) {
|
|
lVar2 = d_type(param_1);
|
|
if (lVar2 == 0) {
|
|
return 0;
|
|
}
|
|
lVar2 = d_make_comp(param_1,0x2e,lVar2,0);
|
|
*plVar4 = lVar2;
|
|
if (lVar2 == 0) {
|
|
return 0;
|
|
}
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
plVar4 = (long *)(lVar2 + 0x10);
|
|
cVar1 = *pcVar3;
|
|
if ((cVar1 == '\0' || cVar1 == 'E') || (cVar1 == '.')) break;
|
|
}
|
|
if (local_20[0] != 0) {
|
|
if (*(long *)(local_20[0] + 0x10) != 0) {
|
|
return local_20[0];
|
|
}
|
|
if (**(int **)(local_20[0] + 8) == 0x27) {
|
|
lVar2 = *(long *)(*(int **)(local_20[0] + 8) + 2);
|
|
if (*(int *)(lVar2 + 0x1c) == 9) {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) - *(int *)(lVar2 + 8);
|
|
*(undefined8 *)(local_20[0] + 8) = 0;
|
|
return local_20[0];
|
|
}
|
|
return local_20[0];
|
|
}
|
|
return local_20[0];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001a2b60 d_cv_qualifiers
|
|
|
|
long * d_cv_qualifiers(long param_1,long *param_2,uint param_3)
|
|
|
|
{
|
|
long *plVar1;
|
|
byte bVar2;
|
|
undefined4 uVar3;
|
|
int *piVar4;
|
|
int iVar5;
|
|
long lVar6;
|
|
byte *pbVar7;
|
|
char cVar8;
|
|
ulong uVar9;
|
|
|
|
pbVar7 = *(byte **)(param_1 + 0x18);
|
|
uVar9 = (ulong)*pbVar7;
|
|
iVar5 = next_is_type_qual_isra_0(pbVar7);
|
|
cVar8 = (char)uVar9;
|
|
plVar1 = param_2;
|
|
do {
|
|
if (iVar5 == 0) {
|
|
if (((param_3 & 1) == 0) && (cVar8 == 'F')) {
|
|
while (plVar1 != param_2) {
|
|
piVar4 = (int *)*param_2;
|
|
iVar5 = *piVar4;
|
|
if (iVar5 == 0x1a) {
|
|
*piVar4 = 0x1d;
|
|
}
|
|
else if (iVar5 == 0x1b) {
|
|
*piVar4 = 0x1e;
|
|
}
|
|
else if (iVar5 == 0x19) {
|
|
*piVar4 = 0x1c;
|
|
}
|
|
param_2 = (long *)(piVar4 + 2);
|
|
}
|
|
}
|
|
return plVar1;
|
|
}
|
|
*(byte **)(param_1 + 0x18) = pbVar7 + 1;
|
|
cVar8 = (char)uVar9;
|
|
if (cVar8 == 'r') {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 9;
|
|
lVar6 = 0;
|
|
iVar5 = (-(uint)(param_3 == 0) & 0xfffffffd) + 0x1c;
|
|
}
|
|
else if (cVar8 == 'V') {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 9;
|
|
lVar6 = 0;
|
|
iVar5 = (-(uint)(param_3 == 0) & 0xfffffffd) + 0x1d;
|
|
}
|
|
else if (cVar8 == 'K') {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 6;
|
|
lVar6 = 0;
|
|
iVar5 = (-(uint)(param_3 == 0) & 0xfffffffd) + 0x1e;
|
|
}
|
|
else {
|
|
if (pbVar7[1] == 0) {
|
|
return (long *)0x0;
|
|
}
|
|
*(byte **)(param_1 + 0x18) = pbVar7 + 2;
|
|
bVar2 = pbVar7[1];
|
|
if (bVar2 == 0x78) {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 0x11;
|
|
lVar6 = 0;
|
|
iVar5 = 0x4d;
|
|
}
|
|
else if ((bVar2 & 0xdf) == 0x4f) {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 9;
|
|
if (bVar2 == 0x4f) {
|
|
uVar3 = *(undefined4 *)(param_1 + 0x4c);
|
|
*(undefined4 *)(param_1 + 0x4c) = 1;
|
|
lVar6 = d_expression_1(param_1);
|
|
*(undefined4 *)(param_1 + 0x4c) = uVar3;
|
|
if (lVar6 == 0) {
|
|
return (long *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != 'E') {
|
|
return (long *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
iVar5 = 0x4f;
|
|
}
|
|
else {
|
|
lVar6 = 0;
|
|
iVar5 = 0x4f;
|
|
}
|
|
}
|
|
else {
|
|
if (bVar2 != 0x77) {
|
|
return (long *)0x0;
|
|
}
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + 6;
|
|
lVar6 = d_parmlist(param_1);
|
|
if (lVar6 == 0) {
|
|
return (long *)0x0;
|
|
}
|
|
if (**(char **)(param_1 + 0x18) != 'E') {
|
|
return (long *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
iVar5 = 0x50;
|
|
}
|
|
}
|
|
lVar6 = d_make_comp(param_1,iVar5,0,lVar6);
|
|
*plVar1 = lVar6;
|
|
if (lVar6 == 0) {
|
|
return (long *)0x0;
|
|
}
|
|
pbVar7 = *(byte **)(param_1 + 0x18);
|
|
plVar1 = (long *)(lVar6 + 8);
|
|
uVar9 = (ulong)*pbVar7;
|
|
iVar5 = next_is_type_qual_isra_0(pbVar7);
|
|
cVar8 = (char)uVar9;
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001a2da0 d_bare_function_type
|
|
|
|
undefined8 d_bare_function_type(long param_1,int param_2)
|
|
|
|
{
|
|
long lVar1;
|
|
long lVar2;
|
|
undefined8 uVar3;
|
|
|
|
if (**(char **)(param_1 + 0x18) == 'J') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
else if (param_2 == 0) {
|
|
lVar1 = 0;
|
|
lVar2 = d_parmlist(param_1);
|
|
if (lVar2 == 0) {
|
|
return 0;
|
|
}
|
|
goto LAB_001a2dd7;
|
|
}
|
|
lVar1 = d_type(param_1);
|
|
if ((lVar1 == 0) || (lVar2 = d_parmlist(param_1), lVar2 == 0)) {
|
|
return 0;
|
|
}
|
|
LAB_001a2dd7:
|
|
uVar3 = d_make_comp(param_1,0x29,lVar1,lVar2);
|
|
return uVar3;
|
|
}
|
|
|
|
|
|
// 001a2e20 d_function_type
|
|
|
|
undefined8 d_function_type(long param_1)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
uint uVar2;
|
|
char *pcVar3;
|
|
|
|
if ((*(byte *)(param_1 + 0x12) & 4) == 0) {
|
|
uVar2 = *(uint *)(param_1 + 0x54);
|
|
if (0x800 < uVar2) {
|
|
return 0;
|
|
}
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
*(uint *)(param_1 + 0x54) = uVar2 + 1;
|
|
uVar1 = 0;
|
|
if (*pcVar3 != 'F') goto LAB_001a2e46;
|
|
}
|
|
else {
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar3 != 'F') {
|
|
return 0;
|
|
}
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
if (pcVar3[1] == 'Y') {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
}
|
|
uVar1 = d_bare_function_type(param_1,1);
|
|
uVar1 = d_ref_qualifier(param_1,uVar1);
|
|
if (**(char **)(param_1 + 0x18) == 'E') {
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
}
|
|
else {
|
|
uVar1 = 0;
|
|
}
|
|
if ((*(byte *)(param_1 + 0x12) & 4) != 0) {
|
|
return uVar1;
|
|
}
|
|
uVar2 = *(int *)(param_1 + 0x54) - 1;
|
|
LAB_001a2e46:
|
|
*(uint *)(param_1 + 0x54) = uVar2;
|
|
return uVar1;
|
|
}
|
|
|
|
|
|
// 001a2ec0 d_unqualified_name
|
|
|
|
int * d_unqualified_name(long param_1)
|
|
|
|
{
|
|
char cVar1;
|
|
int iVar2;
|
|
char *pcVar3;
|
|
int iVar4;
|
|
int *piVar5;
|
|
int *piVar6;
|
|
undefined8 uVar7;
|
|
long lVar8;
|
|
int *piVar9;
|
|
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
cVar1 = *pcVar3;
|
|
if ((byte)(cVar1 - 0x30U) < 10) {
|
|
piVar6 = (int *)d_source_name();
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
if ((byte)(cVar1 + 0x9fU) < 0x1a) {
|
|
if ((cVar1 == 'o') && (pcVar3[1] == 'n')) {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
}
|
|
piVar5 = (int *)d_operator_name(param_1);
|
|
if ((piVar5 != (int *)0x0) && (*piVar5 == 0x32)) {
|
|
pcVar3 = (char *)**(undefined8 **)(piVar5 + 2);
|
|
*(int *)(param_1 + 0x48) =
|
|
*(int *)(param_1 + 0x48) + 7 + *(int *)(*(undefined8 **)(piVar5 + 2) + 2);
|
|
if ((*pcVar3 == 'l') && ((pcVar3[1] == 'i' && (pcVar3[2] == '\0')))) {
|
|
uVar7 = d_source_name(param_1);
|
|
piVar5 = (int *)d_make_comp(param_1,0x37,piVar5,uVar7);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if ((byte)(cVar1 + 0xbdU) < 2) {
|
|
piVar9 = *(int **)(param_1 + 0x40);
|
|
if ((piVar9 == (int *)0x0) || ((*piVar9 != 0 && (*piVar9 != 0x18)))) {
|
|
if (cVar1 == 'C') goto LAB_001a3270;
|
|
}
|
|
else {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) + piVar9[4];
|
|
cVar1 = *pcVar3;
|
|
if (cVar1 == 'C') {
|
|
LAB_001a3270:
|
|
cVar1 = pcVar3[1];
|
|
if (cVar1 == 'I') {
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar1 = pcVar3[2];
|
|
if (4 < (byte)(cVar1 - 0x31U)) {
|
|
cVar1 = pcVar3[1];
|
|
piVar6 = (int *)0x0;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 3;
|
|
d_type(param_1);
|
|
piVar9 = *(int **)(param_1 + 0x40);
|
|
}
|
|
else {
|
|
if (4 < (byte)(cVar1 - 0x31U)) {
|
|
return (int *)0x0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
}
|
|
iVar4 = *(int *)(param_1 + 0x28);
|
|
if (iVar4 < *(int *)(param_1 + 0x2c)) {
|
|
piVar5 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar4 * 0x18);
|
|
piVar5[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar4 + 1;
|
|
if (piVar9 != (int *)0x0) {
|
|
piVar5[0] = 7;
|
|
piVar5[1] = 0;
|
|
piVar5[2] = cVar1 + -0x30;
|
|
*(int **)(piVar5 + 4) = piVar9;
|
|
goto LAB_001a2f03;
|
|
}
|
|
}
|
|
goto LAB_001a32d8;
|
|
}
|
|
if (cVar1 != 'D') {
|
|
LAB_001a3119:
|
|
piVar6 = (int *)0x0;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
}
|
|
switch(pcVar3[1]) {
|
|
case '0':
|
|
iVar4 = 1;
|
|
break;
|
|
case '1':
|
|
iVar4 = 2;
|
|
break;
|
|
case '2':
|
|
iVar4 = 3;
|
|
break;
|
|
default:
|
|
piVar6 = (int *)0x0;
|
|
goto joined_r0x001a2ff2;
|
|
case '4':
|
|
iVar4 = 4;
|
|
break;
|
|
case '5':
|
|
iVar4 = 5;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
piVar6 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
piVar6[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
if (piVar9 != (int *)0x0) {
|
|
piVar6[0] = 8;
|
|
piVar6[1] = 0;
|
|
piVar6[2] = iVar4;
|
|
*(int **)(piVar6 + 4) = piVar9;
|
|
cVar1 = pcVar3[2];
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
}
|
|
cVar1 = pcVar3[2];
|
|
piVar6 = (int *)0x0;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
if (cVar1 != 'L') {
|
|
if (cVar1 != 'U') {
|
|
return (int *)0x0;
|
|
}
|
|
if (pcVar3[1] == 'l') {
|
|
piVar6 = (int *)0x0;
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar1 = pcVar3[1];
|
|
if (cVar1 != 'l') goto joined_r0x001a2ff2;
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
lVar8 = d_parmlist();
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
if ((lVar8 == 0) || (cVar1 != 'E')) goto joined_r0x001a2ff2;
|
|
*(char **)(param_1 + 0x18) = *(char **)(param_1 + 0x18) + 1;
|
|
iVar4 = d_compact_number(param_1);
|
|
if (-1 < iVar4) {
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
piVar6 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
piVar6[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
piVar6[4] = iVar4;
|
|
iVar4 = *(int *)(param_1 + 0x38);
|
|
*piVar6 = 0x46;
|
|
*(long *)(piVar6 + 2) = lVar8;
|
|
if (iVar4 < *(int *)(param_1 + 0x3c)) {
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar4 * 8) = piVar6;
|
|
*(int *)(param_1 + 0x38) = iVar4 + 1;
|
|
cVar1 = *pcVar3;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
}
|
|
cVar1 = *pcVar3;
|
|
piVar6 = (int *)0x0;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
}
|
|
else {
|
|
if (pcVar3[1] != 't') {
|
|
return (int *)0x0;
|
|
}
|
|
piVar6 = (int *)0x0;
|
|
piVar5 = (int *)0x0;
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
cVar1 = pcVar3[1];
|
|
if (cVar1 != 't') goto joined_r0x001a2ff2;
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 2;
|
|
iVar4 = d_compact_number();
|
|
if (iVar4 < 0) goto LAB_001a2f03;
|
|
iVar2 = *(int *)(param_1 + 0x28);
|
|
if (iVar2 < *(int *)(param_1 + 0x2c)) {
|
|
piVar6 = (int *)(*(long *)(param_1 + 0x20) + (long)iVar2 * 0x18);
|
|
piVar6[1] = 0;
|
|
*(int *)(param_1 + 0x28) = iVar2 + 1;
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
*(long *)(piVar6 + 2) = (long)iVar4;
|
|
iVar4 = *(int *)(param_1 + 0x38);
|
|
*piVar6 = 0x48;
|
|
if (iVar4 < *(int *)(param_1 + 0x3c)) {
|
|
*(int **)(*(long *)(param_1 + 0x30) + (long)iVar4 * 8) = piVar6;
|
|
*(int *)(param_1 + 0x38) = iVar4 + 1;
|
|
cVar1 = *pcVar3;
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
cVar1 = *pcVar3;
|
|
goto LAB_001a3119;
|
|
}
|
|
}
|
|
LAB_001a32d8:
|
|
piVar6 = (int *)0x0;
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
goto joined_r0x001a2ff2;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar3 + 1;
|
|
piVar5 = (int *)d_source_name();
|
|
if (piVar5 == (int *)0x0) {
|
|
return (int *)0x0;
|
|
}
|
|
iVar4 = d_discriminator(param_1);
|
|
if (iVar4 == 0) {
|
|
return (int *)0x0;
|
|
}
|
|
}
|
|
LAB_001a2f03:
|
|
cVar1 = **(char **)(param_1 + 0x18);
|
|
piVar6 = piVar5;
|
|
joined_r0x001a2ff2:
|
|
if (cVar1 == 'B') {
|
|
piVar6 = (int *)d_abi_tags(param_1,piVar6);
|
|
return piVar6;
|
|
}
|
|
return piVar6;
|
|
}
|
|
|
|
|
|
// 001a3350 d_expr_primary
|
|
|
|
undefined8 d_expr_primary(long param_1)
|
|
|
|
{
|
|
int iVar1;
|
|
int *piVar2;
|
|
char *pcVar3;
|
|
char *pcVar4;
|
|
char cVar5;
|
|
int iVar6;
|
|
undefined8 *puVar7;
|
|
undefined8 uVar8;
|
|
|
|
pcVar3 = *(char **)(param_1 + 0x18);
|
|
if (*pcVar3 != 'L') {
|
|
return 0;
|
|
}
|
|
pcVar4 = pcVar3 + 1;
|
|
*(char **)(param_1 + 0x18) = pcVar4;
|
|
if (pcVar3[1] == '_') {
|
|
pcVar4 = pcVar3 + 2;
|
|
*(char **)(param_1 + 0x18) = pcVar4;
|
|
cVar5 = pcVar3[2];
|
|
if (cVar5 != 'Z') {
|
|
uVar8 = 0;
|
|
goto LAB_001a340e;
|
|
}
|
|
}
|
|
else if (pcVar3[1] != 'Z') {
|
|
piVar2 = (int *)d_type();
|
|
if (piVar2 == (int *)0x0) {
|
|
return 0;
|
|
}
|
|
if ((*piVar2 == 0x27) && (*(int *)(*(long *)(piVar2 + 2) + 0x1c) != 0)) {
|
|
*(int *)(param_1 + 0x48) = *(int *)(param_1 + 0x48) - *(int *)(*(long *)(piVar2 + 2) + 8);
|
|
}
|
|
pcVar4 = *(char **)(param_1 + 0x18);
|
|
uVar8 = 0x3d;
|
|
cVar5 = *pcVar4;
|
|
pcVar3 = pcVar4;
|
|
if (cVar5 == 'n') {
|
|
pcVar3 = pcVar4 + 1;
|
|
uVar8 = 0x3e;
|
|
*(char **)(param_1 + 0x18) = pcVar3;
|
|
cVar5 = pcVar4[1];
|
|
}
|
|
pcVar4 = pcVar3;
|
|
if (cVar5 == 'E') {
|
|
iVar6 = 0;
|
|
}
|
|
else {
|
|
do {
|
|
pcVar4 = pcVar4 + 1;
|
|
if (cVar5 == '\0') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar4;
|
|
cVar5 = *pcVar4;
|
|
} while (cVar5 != 'E');
|
|
iVar6 = (int)pcVar4 - (int)pcVar3;
|
|
}
|
|
iVar1 = *(int *)(param_1 + 0x28);
|
|
if (iVar1 < *(int *)(param_1 + 0x2c)) {
|
|
puVar7 = (undefined8 *)(*(long *)(param_1 + 0x20) + (long)iVar1 * 0x18);
|
|
*(undefined4 *)((long)puVar7 + 4) = 0;
|
|
*(int *)(param_1 + 0x28) = iVar1 + 1;
|
|
if (iVar6 < 1) goto LAB_001a34b8;
|
|
*puVar7 = 0;
|
|
puVar7[1] = pcVar3;
|
|
*(int *)(puVar7 + 2) = iVar6;
|
|
}
|
|
else {
|
|
LAB_001a34b8:
|
|
puVar7 = (undefined8 *)0x0;
|
|
}
|
|
uVar8 = d_make_comp(param_1,uVar8,piVar2,puVar7);
|
|
pcVar4 = *(char **)(param_1 + 0x18);
|
|
cVar5 = *pcVar4;
|
|
goto LAB_001a340e;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar4 + 1;
|
|
uVar8 = d_encoding(param_1,0);
|
|
pcVar4 = *(char **)(param_1 + 0x18);
|
|
cVar5 = *pcVar4;
|
|
LAB_001a340e:
|
|
if (cVar5 != 'E') {
|
|
return 0;
|
|
}
|
|
*(char **)(param_1 + 0x18) = pcVar4 + 1;
|
|
return uVar8;
|
|
}
|
|
|
|
|
|
// 001a34d0 d_print_comp_inner
|
|
|
|
void d_print_comp_inner(undefined1 *param_1,uint param_2,int *param_3)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined8 uVar2;
|
|
undefined8 uVar3;
|
|
long *plVar4;
|
|
long *plVar5;
|
|
long *plVar6;
|
|
long **pplVar7;
|
|
uint uVar8;
|
|
uint uVar9;
|
|
long lVar10;
|
|
int *piVar11;
|
|
long lVar12;
|
|
long **pplVar13;
|
|
long *plVar14;
|
|
undefined8 *puVar15;
|
|
long *plVar16;
|
|
ulong uVar17;
|
|
long lVar18;
|
|
undefined1 *puVar19;
|
|
uint *puVar20;
|
|
uint *puVar21;
|
|
int iVar22;
|
|
undefined8 unaff_RBX;
|
|
char *pcVar23;
|
|
undefined *puVar24;
|
|
uint *puVar25;
|
|
byte *pbVar26;
|
|
long **pplVar27;
|
|
byte *pbVar28;
|
|
int *piVar29;
|
|
undefined8 *puVar30;
|
|
char *pcVar31;
|
|
undefined1 *puVar32;
|
|
char cVar33;
|
|
ulong uVar34;
|
|
char *pcVar35;
|
|
undefined1 uVar36;
|
|
int iVar37;
|
|
long in_FS_OFFSET;
|
|
bool bVar38;
|
|
bool bVar39;
|
|
byte bVar40;
|
|
undefined8 local_108;
|
|
long *local_f8;
|
|
long *local_f0;
|
|
long *local_e8 [2];
|
|
long local_d8;
|
|
long *local_d0 [2];
|
|
long alStack_c0 [2];
|
|
long *aplStack_b0 [8];
|
|
undefined1 auStack_6b [43];
|
|
long local_40;
|
|
|
|
bVar40 = 0;
|
|
local_40 = *(long *)(in_FS_OFFSET + 0x28);
|
|
if (param_3 == (int *)0x0) goto LAB_001a36d0;
|
|
if (*(int *)(param_1 + 0x130) != 0) goto switchD_001a66c1_default;
|
|
iVar22 = *param_3;
|
|
iVar37 = 0;
|
|
switch(iVar22) {
|
|
case 0:
|
|
lVar18 = (long)param_3[4];
|
|
pcVar23 = *(char **)(param_3 + 2);
|
|
if ((param_2 & 4) == 0) {
|
|
if (lVar18 != 0) {
|
|
pcVar31 = pcVar23 + lVar18;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
cVar33 = *pcVar23;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
pcVar23 = pcVar23 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
lVar18 = lVar10;
|
|
} while (pcVar31 != pcVar23);
|
|
}
|
|
}
|
|
else {
|
|
pcVar31 = pcVar23 + lVar18;
|
|
while (pcVar23 < pcVar31) {
|
|
cVar33 = *pcVar23;
|
|
if ((((3 < (long)pcVar31 - (long)pcVar23) && (cVar33 == '_')) && (pcVar23[1] == '_')) &&
|
|
((pcVar23[2] == 'U' && (pcVar35 = pcVar23 + 3, pcVar35 < pcVar31)))) {
|
|
uVar17 = 0;
|
|
do {
|
|
cVar1 = *pcVar35;
|
|
iVar22 = (int)cVar1;
|
|
if ((byte)(cVar1 - 0x30U) < 10) {
|
|
iVar22 = iVar22 + -0x30;
|
|
}
|
|
else if ((byte)(cVar1 + 0xbfU) < 6) {
|
|
iVar22 = iVar22 + -0x37;
|
|
}
|
|
else {
|
|
if (5 < (byte)(cVar1 + 0x9fU)) {
|
|
if (((pcVar35 < pcVar31) && (uVar17 < 0x100)) && (cVar1 == '_')) {
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = (char)uVar17;
|
|
param_1[0x108] = (char)uVar17;
|
|
goto LAB_001a6161;
|
|
}
|
|
break;
|
|
}
|
|
iVar22 = iVar22 + -0x57;
|
|
}
|
|
pcVar35 = pcVar35 + 1;
|
|
uVar17 = uVar17 * 0x10 + (long)iVar22;
|
|
} while (pcVar31 != pcVar35);
|
|
}
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
pcVar35 = pcVar23;
|
|
LAB_001a6161:
|
|
pcVar23 = pcVar35 + 1;
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if ((param_2 & 4) == 0) {
|
|
puVar24 = &DAT_001b4e87;
|
|
uVar36 = 0x3a;
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4e89) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x2e;
|
|
param_1[0x108] = 0x2e;
|
|
}
|
|
piVar11 = *(int **)(param_3 + 4);
|
|
if (*piVar11 == 0x47) {
|
|
pcVar23 = "{default arg#";
|
|
cVar33 = '{';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,piVar11[4] + 1);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)(puVar19 + (long)puVar25);
|
|
lVar10 = lVar18;
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
else {
|
|
lVar18 = lVar10 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar10 = lVar18;
|
|
} while (puVar21 != puVar25);
|
|
}
|
|
puVar24 = &DAT_001b4e98;
|
|
uVar36 = 0x7d;
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4e9b) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
piVar11 = *(int **)(piVar11 + 2);
|
|
}
|
|
d_print_comp(param_1,param_2,piVar11);
|
|
break;
|
|
case 3:
|
|
plVar16 = *(long **)(param_3 + 2);
|
|
uVar2 = *(undefined8 *)(param_1 + 0x128);
|
|
*(undefined8 *)(param_1 + 0x128) = 0;
|
|
if (plVar16 == (long *)0x0) {
|
|
LAB_001a7114:
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
}
|
|
else {
|
|
uVar17 = 0;
|
|
plVar14 = *(long **)(param_1 + 0x120);
|
|
pplVar13 = (long **)0x0;
|
|
pplVar7 = local_e8;
|
|
do {
|
|
pplVar27 = pplVar7;
|
|
*(undefined4 *)(pplVar27 + 2) = 0;
|
|
iVar22 = (int)*plVar16;
|
|
uVar9 = (int)uVar17 + 1;
|
|
uVar17 = (ulong)uVar9;
|
|
*pplVar27 = (long *)pplVar13;
|
|
pplVar27[1] = plVar16;
|
|
pplVar27[3] = plVar14;
|
|
if ((0x34 < iVar22 - 0x1cU) ||
|
|
((1L << ((byte)(iVar22 - 0x1cU) & 0x3f) & 0x1a00000000001fU) == 0)) {
|
|
*(long ***)(param_1 + 0x128) = pplVar27;
|
|
if (iVar22 != 2) goto LAB_001a4380;
|
|
plVar16 = (long *)plVar16[2];
|
|
iVar22 = (int)*plVar16;
|
|
if (iVar22 == 0x47) {
|
|
plVar16 = (long *)plVar16[1];
|
|
if (plVar16 == (long *)0x0) goto LAB_001a7114;
|
|
iVar22 = (int)*plVar16;
|
|
}
|
|
pplVar13 = local_e8 + uVar17 * 4;
|
|
uVar34 = uVar17;
|
|
goto joined_r0x001a6ee2;
|
|
}
|
|
plVar16 = (long *)plVar16[1];
|
|
if (plVar16 == (long *)0x0) {
|
|
*(long ***)(param_1 + 0x128) = pplVar27;
|
|
goto LAB_001a7114;
|
|
}
|
|
pplVar13 = pplVar27;
|
|
pplVar7 = pplVar27 + 4;
|
|
} while (uVar9 != 4);
|
|
*(long ***)(param_1 + 0x128) = pplVar27;
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
}
|
|
break;
|
|
case 4:
|
|
uVar2 = *(undefined8 *)(param_1 + 0x170);
|
|
uVar3 = *(undefined8 *)(param_1 + 0x128);
|
|
*(int **)(param_1 + 0x170) = param_3;
|
|
*(undefined8 *)(param_1 + 0x128) = 0;
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
if ((((param_2 & 4) == 0) || (*piVar11 != 0)) || (piVar11[4] != 6)) {
|
|
LAB_001a4f8d:
|
|
d_print_comp(param_1,param_2);
|
|
if (param_1[0x108] == '<') {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
else {
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
}
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x3c;
|
|
param_1[0x108] = 0x3c;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
if (param_1[0x108] == '>') {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
else {
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
}
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x3e;
|
|
param_1[0x108] = 0x3e;
|
|
}
|
|
else {
|
|
lVar18 = 6;
|
|
bVar38 = false;
|
|
bVar39 = true;
|
|
pbVar26 = *(byte **)(piVar11 + 2);
|
|
pbVar28 = (byte *)"JArray";
|
|
do {
|
|
if (lVar18 == 0) break;
|
|
lVar18 = lVar18 + -1;
|
|
bVar38 = *pbVar26 < *pbVar28;
|
|
bVar39 = *pbVar26 == *pbVar28;
|
|
pbVar26 = pbVar26 + 1;
|
|
pbVar28 = pbVar28 + 1;
|
|
} while (bVar39);
|
|
if ((!bVar38 && !bVar39) != bVar38) goto LAB_001a4f8d;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
d_append_buffer(param_1,&DAT_001b472c,2);
|
|
}
|
|
*(undefined8 *)(param_1 + 0x128) = uVar3;
|
|
*(undefined8 *)(param_1 + 0x170) = uVar2;
|
|
break;
|
|
case 5:
|
|
if (*(int *)(param_1 + 0x138) != 0) {
|
|
puVar24 = &DAT_001b4ea3;
|
|
uVar36 = 0x61;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4ea8) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,(int)*(undefined8 *)(param_3 + 2) + 1);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)(puVar19 + (long)puVar25);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar18 = lVar10;
|
|
} while (puVar21 != puVar25);
|
|
}
|
|
break;
|
|
}
|
|
piVar11 = (int *)d_lookup_template_argument_isra_0(param_1,param_3 + 2);
|
|
if ((piVar11 != (int *)0x0) &&
|
|
(((*piVar11 != 0x2f || (*(int *)(param_1 + 0x13c) < 0)) ||
|
|
(piVar11 = (int *)d_index_template_argument_part_0
|
|
(piVar11,*(int *)(param_1 + 0x13c),piVar11),
|
|
piVar11 != (int *)0x0)))) {
|
|
puVar30 = *(undefined8 **)(param_1 + 0x120);
|
|
*(undefined8 *)(param_1 + 0x120) = *puVar30;
|
|
d_print_comp(param_1,param_2,piVar11);
|
|
*(undefined8 **)(param_1 + 0x120) = puVar30;
|
|
break;
|
|
}
|
|
goto LAB_001a36d0;
|
|
case 6:
|
|
uVar17 = *(ulong *)(param_3 + 2);
|
|
if (uVar17 == 0) {
|
|
puVar24 = &DAT_001b5064;
|
|
uVar36 = 0x74;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b5068) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
else {
|
|
puVar24 = &DAT_001b505d;
|
|
uVar36 = 0x7b;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b5063) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,uVar17 & 0xffffffff);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)((long)puVar25 + (long)puVar19);
|
|
lVar10 = lVar18;
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
else {
|
|
lVar18 = lVar10 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar10 = lVar18;
|
|
} while (puVar21 != puVar25);
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x7d;
|
|
param_1[0x108] = 0x7d;
|
|
}
|
|
break;
|
|
case 7:
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
break;
|
|
case 8:
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x7e;
|
|
param_1[0x108] = 0x7e;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
break;
|
|
case 9:
|
|
pcVar23 = "vtable for ";
|
|
cVar33 = 'v';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 10:
|
|
pcVar23 = "VTT for ";
|
|
cVar33 = 'V';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0xb:
|
|
pcVar23 = "construction vtable for ";
|
|
cVar33 = 'c';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar24 = &DAT_001b4ed7;
|
|
uVar36 = 0x2d;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4edb) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
break;
|
|
case 0xc:
|
|
pcVar23 = "typeinfo for ";
|
|
cVar33 = 't';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0xd:
|
|
pcVar23 = "typeinfo name for ";
|
|
cVar33 = 't';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0xe:
|
|
pcVar23 = "typeinfo fn for ";
|
|
cVar33 = 't';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0xf:
|
|
pcVar23 = "non-virtual thunk to ";
|
|
cVar33 = 'n';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x10:
|
|
pcVar23 = "virtual thunk to ";
|
|
cVar33 = 'v';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x11:
|
|
pcVar23 = "covariant return thunk to ";
|
|
cVar33 = 'c';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x12:
|
|
pcVar23 = "java Class for ";
|
|
cVar33 = 'j';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x13:
|
|
pcVar23 = "guard variable for ";
|
|
cVar33 = 'g';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x14:
|
|
pcVar23 = "TLS init function for ";
|
|
cVar33 = 'T';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x15:
|
|
pcVar23 = "TLS wrapper function for ";
|
|
cVar33 = 'T';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x16:
|
|
pcVar23 = "reference temporary #";
|
|
cVar33 = 'r';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar24 = &DAT_001b4fbc;
|
|
uVar36 = 0x20;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4fc1) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x17:
|
|
pcVar23 = "hidden alias for ";
|
|
cVar33 = 'h';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x18:
|
|
puVar19 = *(undefined1 **)(param_3 + 2);
|
|
if ((long)param_3[4] != 0) {
|
|
puVar32 = puVar19 + param_3[4];
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar36 = *puVar19;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar19 = puVar19 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
lVar18 = lVar10;
|
|
} while (puVar19 != puVar32);
|
|
}
|
|
break;
|
|
case 0x19:
|
|
case 0x1a:
|
|
case 0x1b:
|
|
plVar16 = *(long **)(param_1 + 0x128);
|
|
for (plVar14 = plVar16; plVar14 != (long *)0x0; plVar14 = (long *)*plVar14) {
|
|
if ((int)plVar14[2] == 0) {
|
|
if (2 < *(int *)plVar14[1] - 0x19U) {
|
|
iVar37 = 0;
|
|
break;
|
|
}
|
|
if (iVar22 == *(int *)plVar14[1]) {
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
goto switchD_001a66c1_default;
|
|
}
|
|
}
|
|
}
|
|
goto LAB_001a36ec;
|
|
case 0x1c:
|
|
case 0x1d:
|
|
case 0x1e:
|
|
case 0x1f:
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x4d:
|
|
case 0x4f:
|
|
case 0x50:
|
|
plVar16 = *(long **)(param_1 + 0x128);
|
|
LAB_001a36ec:
|
|
local_e8[0] = plVar16;
|
|
*(long ***)(param_1 + 0x128) = local_e8;
|
|
local_d0[0] = *(long **)(param_1 + 0x120);
|
|
LAB_001a3711:
|
|
lVar18 = *(long *)(param_3 + 2);
|
|
local_e8[1] = (long *)param_3;
|
|
LAB_001a3716:
|
|
plVar16 = local_e8[1];
|
|
local_d8._0_4_ = 0;
|
|
d_print_comp(param_1,param_2,lVar18);
|
|
if ((int)local_d8 == 0) {
|
|
d_print_mod(param_1,param_2,plVar16);
|
|
}
|
|
*(long **)(param_1 + 0x128) = local_e8[0];
|
|
if (iVar37 != 0) {
|
|
*(undefined8 *)(param_1 + 0x120) = unaff_RBX;
|
|
}
|
|
break;
|
|
case 0x23:
|
|
case 0x24:
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
iVar22 = *piVar11;
|
|
if ((*(int *)(param_1 + 0x138) != 0) || (iVar37 = 0, iVar22 != 5)) goto LAB_001a3a6d;
|
|
iVar22 = *(int *)(param_1 + 0x158);
|
|
puVar30 = *(undefined8 **)(param_1 + 0x150);
|
|
if (0 < iVar22) {
|
|
puVar15 = puVar30;
|
|
do {
|
|
if (piVar11 == (int *)*puVar15) {
|
|
puVar30 = *(undefined8 **)(param_1 + 0x148);
|
|
goto joined_r0x001a71af;
|
|
}
|
|
puVar15 = puVar15 + 2;
|
|
} while (puVar15 != puVar30 + (ulong)(iVar22 - 1) * 2 + 2);
|
|
}
|
|
if (*(int *)(param_1 + 0x15c) <= iVar22) {
|
|
LAB_001a77b3:
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
break;
|
|
}
|
|
*(int *)(param_1 + 0x158) = iVar22 + 1;
|
|
plVar16 = *(long **)(param_1 + 0x120);
|
|
puVar30[(long)iVar22 * 2] = piVar11;
|
|
puVar30 = puVar30 + (long)iVar22 * 2 + 1;
|
|
if (plVar16 != (long *)0x0) {
|
|
uVar17 = (ulong)*(int *)(param_1 + 0x168);
|
|
iVar22 = *(int *)(param_1 + 0x16c);
|
|
lVar18 = uVar17 << 4;
|
|
puVar15 = puVar30;
|
|
do {
|
|
if (iVar22 <= (int)uVar17) goto LAB_001a77b3;
|
|
lVar10 = plVar16[1];
|
|
uVar9 = (int)uVar17 + 1;
|
|
uVar17 = (ulong)uVar9;
|
|
*(uint *)(param_1 + 0x168) = uVar9;
|
|
puVar30 = (undefined8 *)(*(long *)(param_1 + 0x160) + lVar18);
|
|
lVar18 = lVar18 + 0x10;
|
|
puVar30[1] = lVar10;
|
|
*puVar15 = puVar30;
|
|
plVar16 = (long *)*plVar16;
|
|
puVar15 = puVar30;
|
|
} while (plVar16 != (long *)0x0);
|
|
}
|
|
*puVar30 = 0;
|
|
LAB_001a71df:
|
|
iVar37 = 0;
|
|
piVar11 = (int *)d_lookup_template_argument_isra_0(param_1,piVar11 + 2);
|
|
if (piVar11 != (int *)0x0) goto LAB_001a71fa;
|
|
goto LAB_001a36d0;
|
|
case 0x27:
|
|
puVar30 = *(undefined8 **)(param_3 + 2);
|
|
if ((param_2 & 4) == 0) {
|
|
puVar19 = (undefined1 *)*puVar30;
|
|
if ((long)*(int *)(puVar30 + 1) != 0) {
|
|
puVar32 = puVar19 + *(int *)(puVar30 + 1);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar36 = *puVar19;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar19 = puVar19 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
lVar18 = lVar10;
|
|
} while (puVar32 != puVar19);
|
|
}
|
|
}
|
|
else {
|
|
puVar19 = (undefined1 *)puVar30[2];
|
|
if ((long)*(int *)(puVar30 + 3) != 0) {
|
|
puVar32 = puVar19 + *(int *)(puVar30 + 3);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar36 = *puVar19;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar19 = puVar19 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
lVar18 = lVar10;
|
|
} while (puVar19 != puVar32);
|
|
}
|
|
}
|
|
break;
|
|
case 0x28:
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x29:
|
|
plVar16 = *(long **)(param_1 + 0x128);
|
|
uVar9 = param_2 & 0xffffff9f;
|
|
if ((param_2 & 0x20) == 0) {
|
|
if ((*(long *)(param_3 + 2) != 0) && ((param_2 & 0x40) == 0)) {
|
|
*(long ***)(param_1 + 0x128) = local_e8;
|
|
local_d0[0] = *(long **)(param_1 + 0x120);
|
|
local_d8._0_4_ = 0;
|
|
local_e8[0] = plVar16;
|
|
local_e8[1] = (long *)param_3;
|
|
d_print_comp(param_1,uVar9);
|
|
*(long **)(param_1 + 0x128) = local_e8[0];
|
|
if ((int)local_d8 != 0) break;
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x20;
|
|
plVar16 = *(long **)(param_1 + 0x128);
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
d_print_function_type_isra_0(param_1,uVar9,param_3 + 4,plVar16);
|
|
}
|
|
else {
|
|
d_print_function_type_isra_0(param_1,uVar9,param_3 + 4);
|
|
if (*(long *)(param_3 + 2) != 0) {
|
|
d_print_comp(param_1,uVar9);
|
|
}
|
|
}
|
|
break;
|
|
case 0x2a:
|
|
plVar16 = *(long **)(param_1 + 0x128);
|
|
uVar9 = 1;
|
|
local_d0[0] = *(long **)(param_1 + 0x120);
|
|
*(long ***)(param_1 + 0x128) = local_e8;
|
|
local_d8._0_4_ = 0;
|
|
plVar14 = plVar16;
|
|
pplVar13 = local_e8;
|
|
local_e8[0] = plVar16;
|
|
if (plVar16 == (long *)0x0) {
|
|
local_e8[1] = (long *)param_3;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
*(undefined8 *)(param_1 + 0x128) = 0;
|
|
if ((int)local_d8 != 0) break;
|
|
}
|
|
else {
|
|
do {
|
|
if (2 < *(int *)plVar14[1] - 0x19U) break;
|
|
if ((int)plVar14[2] == 0) {
|
|
if (3 < uVar9) {
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
local_e8[1] = (long *)param_3;
|
|
goto switchD_001a66c1_default;
|
|
}
|
|
lVar18 = plVar14[1];
|
|
uVar17 = (ulong)uVar9;
|
|
uVar9 = uVar9 + 1;
|
|
local_e8[uVar17 * 4] = (long *)*plVar14;
|
|
(&local_d8)[uVar17 * 4 + -1] = lVar18;
|
|
lVar18 = plVar14[2];
|
|
plVar4 = (long *)plVar14[3];
|
|
local_e8[uVar17 * 4] = (long *)pplVar13;
|
|
pplVar13 = local_e8 + uVar17 * 4;
|
|
*(long ***)(param_1 + 0x128) = pplVar13;
|
|
(&local_d8)[uVar17 * 4] = lVar18;
|
|
local_d0[uVar17 * 4] = plVar4;
|
|
*(undefined4 *)(plVar14 + 2) = 1;
|
|
}
|
|
plVar14 = (long *)*plVar14;
|
|
} while (plVar14 != (long *)0x0);
|
|
local_e8[1] = (long *)param_3;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
*(long **)(param_1 + 0x128) = plVar16;
|
|
if ((int)local_d8 != 0) break;
|
|
pplVar13 = local_e8 + (ulong)uVar9 * 4;
|
|
for (; uVar9 != 1; uVar9 = uVar9 - 1) {
|
|
pplVar7 = pplVar13 + -3;
|
|
pplVar13 = pplVar13 + -4;
|
|
d_print_mod(param_1,param_2,*pplVar7);
|
|
}
|
|
}
|
|
d_print_array_type_isra_0(param_1,param_2,param_3 + 2,*(undefined8 *)(param_1 + 0x128));
|
|
break;
|
|
case 0x2b:
|
|
case 0x2d:
|
|
local_e8[0] = *(long **)(param_1 + 0x128);
|
|
uVar2 = *(undefined8 *)(param_3 + 4);
|
|
local_d8._0_4_ = 0;
|
|
*(long ***)(param_1 + 0x128) = local_e8;
|
|
local_d0[0] = *(long **)(param_1 + 0x120);
|
|
local_e8[1] = (long *)param_3;
|
|
d_print_comp(param_1,param_2,uVar2);
|
|
if ((int)local_d8 == 0) {
|
|
d_print_mod(param_1,param_2,param_3);
|
|
}
|
|
*(long **)(param_1 + 0x128) = local_e8[0];
|
|
break;
|
|
case 0x2c:
|
|
if (*(short *)((long)param_3 + 0x12) != 0) {
|
|
puVar24 = &DAT_001b5006;
|
|
uVar36 = 0x5f;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b500b) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
if (*(long *)(*(long *)(param_3 + 2) + 8) == 0x1ef3e0) {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
}
|
|
else {
|
|
d_print_comp(param_1,param_2);
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
if ((short)param_3[4] == 0) {
|
|
pcVar23 = "_Fract";
|
|
cVar33 = '_';
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
pcVar23 = pcVar23 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
else {
|
|
pcVar23 = "_Accum";
|
|
cVar33 = '_';
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
pcVar23 = pcVar23 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
break;
|
|
case 0x2e:
|
|
case 0x2f:
|
|
if (*(long *)(param_3 + 2) != 0) {
|
|
d_print_comp(param_1,param_2);
|
|
}
|
|
if (*(long *)(param_3 + 4) != 0) {
|
|
uVar17 = *(ulong *)(param_1 + 0x100);
|
|
if (0xfd < uVar17) {
|
|
param_1[uVar17] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,uVar17,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
uVar17 = 0;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
puVar24 = &DAT_001b4738;
|
|
uVar36 = 0x2c;
|
|
while( true ) {
|
|
if (uVar17 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
uVar34 = 1;
|
|
uVar17 = 0;
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
}
|
|
else {
|
|
uVar34 = uVar17 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(ulong *)(param_1 + 0x100) = uVar34;
|
|
param_1[uVar17] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b473a) break;
|
|
uVar36 = *puVar24;
|
|
uVar17 = uVar34;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x140);
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
if ((*(long *)(param_1 + 0x140) == lVar18) && (*(ulong *)(param_1 + 0x100) == uVar34)) {
|
|
*(ulong *)(param_1 + 0x100) = uVar34 - 2;
|
|
}
|
|
}
|
|
break;
|
|
case 0x30:
|
|
pcVar23 = "template parameter object for ";
|
|
cVar33 = 't';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x31:
|
|
uVar2 = *(undefined8 *)(param_3 + 4);
|
|
if (*(long *)(param_3 + 2) != 0) {
|
|
d_print_comp(param_1,param_2);
|
|
}
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x7b;
|
|
param_1[0x108] = 0x7b;
|
|
d_print_comp(param_1,param_2,uVar2);
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x7d;
|
|
param_1[0x108] = 0x7d;
|
|
break;
|
|
case 0x32:
|
|
lVar18 = *(long *)(param_3 + 2);
|
|
pcVar23 = "operator";
|
|
cVar33 = 'o';
|
|
iVar22 = *(int *)(lVar18 + 0x10);
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar12 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
else {
|
|
lVar12 = lVar10 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar12;
|
|
param_1[lVar10] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar10 = lVar12;
|
|
}
|
|
pcVar23 = *(char **)(lVar18 + 8);
|
|
if ((byte)(*pcVar23 + 0x9fU) < 0x1a) {
|
|
lVar10 = lVar12 + 1;
|
|
if (lVar12 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
pcVar23 = *(char **)(lVar18 + 8);
|
|
lVar12 = 0;
|
|
lVar10 = 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar12] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
lVar18 = (long)iVar22;
|
|
if (pcVar23[lVar18 + -1] == ' ') {
|
|
lVar18 = (long)(iVar22 + -1);
|
|
}
|
|
if (lVar18 != 0) {
|
|
pcVar31 = pcVar23 + lVar18;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
cVar33 = *pcVar23;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
pcVar23 = pcVar23 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
lVar18 = lVar10;
|
|
} while (pcVar23 != pcVar31);
|
|
}
|
|
break;
|
|
case 0x33:
|
|
pcVar23 = "operator ";
|
|
cVar33 = 'o';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
break;
|
|
default:
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
break;
|
|
case 0x35:
|
|
pcVar23 = "operator ";
|
|
cVar33 = 'o';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
if (*(int **)(param_1 + 0x170) != (int *)0x0) {
|
|
local_e8[0] = *(long **)(param_1 + 0x120);
|
|
*(long ***)(param_1 + 0x120) = local_e8;
|
|
local_e8[1] = (long *)*(int **)(param_1 + 0x170);
|
|
}
|
|
if (**(int **)(param_3 + 2) == 4) {
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(*(int **)(param_3 + 2) + 2));
|
|
if (*(long *)(param_1 + 0x170) != 0) {
|
|
*(long **)(param_1 + 0x120) = local_e8[0];
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (param_1[0x108] == '<') {
|
|
lVar10 = lVar18;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 0;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = lVar10 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x3c;
|
|
param_1[0x108] = 0x3c;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(*(long *)(param_3 + 2) + 0x10));
|
|
if (param_1[0x108] == '>') {
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
else {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x3e;
|
|
param_1[0x108] = 0x3e;
|
|
}
|
|
else {
|
|
d_print_comp(param_1,param_2);
|
|
if (*(long *)(param_1 + 0x170) != 0) {
|
|
*(long **)(param_1 + 0x120) = local_e8[0];
|
|
}
|
|
}
|
|
break;
|
|
case 0x36:
|
|
d_print_expr_op(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x37:
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
piVar29 = *(int **)(param_3 + 4);
|
|
if (*piVar11 == 0x32) {
|
|
iVar22 = *piVar29;
|
|
pcVar23 = (char *)**(undefined8 **)(piVar11 + 2);
|
|
if (*pcVar23 == 'a') {
|
|
if (((pcVar23[1] == 'd') && (pcVar23[2] == '\0')) && (iVar22 == 3)) {
|
|
if ((**(int **)(piVar29 + 2) == 1) && (**(int **)(piVar29 + 4) == 0x29)) {
|
|
piVar29 = *(int **)(piVar29 + 2);
|
|
}
|
|
}
|
|
else if (iVar22 == 0x39) goto LAB_001a7141;
|
|
}
|
|
else {
|
|
if (iVar22 == 0x39) {
|
|
LAB_001a7141:
|
|
d_print_subexpr(param_1,param_2,*(undefined8 *)(piVar29 + 2));
|
|
d_print_expr_op(param_1,param_2,piVar11);
|
|
break;
|
|
}
|
|
if (*pcVar23 == 's') {
|
|
if (pcVar23[1] == 'Z') {
|
|
if (pcVar23[2] == '\0') {
|
|
for (piVar11 = (int *)d_find_pack(param_1,piVar29);
|
|
((piVar11 != (int *)0x0 && (*piVar11 == 0x2f)) && (*(long *)(piVar11 + 2) != 0));
|
|
piVar11 = *(int **)(piVar11 + 4)) {
|
|
iVar37 = iVar37 + 1;
|
|
}
|
|
pcVar23 = auStack_6b + 3;
|
|
__sprintf_chk(pcVar23,1,0x19,&DAT_001b458a,iVar37);
|
|
uVar17 = 0xffffffffffffffff;
|
|
pcVar31 = pcVar23;
|
|
do {
|
|
if (uVar17 == 0) break;
|
|
uVar17 = uVar17 - 1;
|
|
cVar33 = *pcVar31;
|
|
pcVar31 = pcVar31 + (ulong)bVar40 * -2 + 1;
|
|
} while (cVar33 != '\0');
|
|
if (~uVar17 - 1 != 0) {
|
|
pcVar31 = pcVar23 + (~uVar17 - 1);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
cVar33 = *pcVar23;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
pcVar23 = pcVar23 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
lVar18 = lVar10;
|
|
} while (pcVar23 != pcVar31);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if ((pcVar23[1] == 'P') && (pcVar23[2] == '\0')) {
|
|
do {
|
|
if ((*piVar29 != 0x2f) || (piVar11 = *(int **)(piVar29 + 2), piVar11 == (int *)0x0))
|
|
break;
|
|
if ((*piVar11 == 0x4b) &&
|
|
(piVar11 = (int *)d_find_pack(param_1,*(undefined8 *)(piVar11 + 2)),
|
|
piVar11 != (int *)0x0)) {
|
|
while (*piVar11 == 0x2f) {
|
|
if ((*(long *)(piVar11 + 2) == 0) ||
|
|
(piVar11 = *(int **)(piVar11 + 4), piVar11 == (int *)0x0)) break;
|
|
}
|
|
}
|
|
piVar29 = *(int **)(piVar29 + 4);
|
|
} while (piVar29 != (int *)0x0);
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 +
|
|
((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)((long)puVar25 + (long)puVar19);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar18 = lVar10;
|
|
} while (puVar25 != puVar21);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
d_print_expr_op(param_1,param_2,piVar11);
|
|
if (*pcVar23 == 'g') {
|
|
if ((pcVar23[1] == 's') && (pcVar23[2] == '\0')) {
|
|
d_print_comp(param_1,param_2,piVar29);
|
|
break;
|
|
}
|
|
}
|
|
else if (((*pcVar23 == 's') && (pcVar23[1] == 't')) && (pcVar23[2] == '\0')) {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x28;
|
|
param_1[0x108] = 0x28;
|
|
d_print_comp(param_1,param_2,piVar29);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
break;
|
|
}
|
|
}
|
|
else if (*piVar11 == 0x34) {
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x28;
|
|
param_1[0x108] = 0x28;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(piVar11 + 2));
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
}
|
|
else {
|
|
d_print_expr_op(param_1,param_2,piVar11);
|
|
}
|
|
d_print_subexpr(param_1,param_2,piVar29);
|
|
break;
|
|
case 0x38:
|
|
if (**(int **)(param_3 + 4) == 0x39) {
|
|
pcVar23 = (char *)**(undefined8 **)(*(long *)(param_3 + 2) + 8);
|
|
if ((pcVar23[1] == 'c') &&
|
|
((cVar33 = *pcVar23, (byte)(cVar33 + 0x8eU) < 2 || ((byte)(cVar33 + 0x9dU) < 2)))) {
|
|
d_print_expr_op(param_1,param_2);
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
puVar24 = &DAT_001b502d;
|
|
uVar36 = 0x3e;
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x3c;
|
|
param_1[0x108] = 0x3c;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(*(long *)(param_3 + 4) + 8));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b502f) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(*(long *)(param_3 + 4) + 0x10));
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
break;
|
|
}
|
|
iVar22 = d_maybe_print_fold_expression_isra_0
|
|
(param_1,param_2,*(long *)(param_3 + 2),param_3 + 4);
|
|
if (iVar22 != 0) break;
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
if (((*piVar11 == 0x32) && (*(int *)(*(long *)(piVar11 + 2) + 0x10) == 1)) &&
|
|
(**(char **)(*(long *)(piVar11 + 2) + 8) == '>')) {
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x28;
|
|
param_1[0x108] = 0x28;
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
}
|
|
pcVar23 = (char *)**(undefined8 **)(piVar11 + 2);
|
|
piVar11 = *(int **)(*(long *)(param_3 + 4) + 8);
|
|
if ((((*pcVar23 == 'c') && (pcVar23[1] == 'l')) && (pcVar23[2] == '\0')) && (*piVar11 == 3)) {
|
|
if (**(int **)(piVar11 + 4) != 0x29) {
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
}
|
|
d_print_subexpr(param_1,param_2,*(undefined8 *)(piVar11 + 2));
|
|
}
|
|
else {
|
|
d_print_subexpr(param_1,param_2);
|
|
}
|
|
pcVar23 = (char *)**(undefined8 **)(*(long *)(param_3 + 2) + 8);
|
|
if (*pcVar23 == 'i') {
|
|
if ((pcVar23[1] != 'x') || (pcVar23[2] != '\0')) goto LAB_001a35d9;
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x5b;
|
|
param_1[0x108] = 0x5b;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(*(long *)(param_3 + 4) + 0x10));
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x5d;
|
|
param_1[0x108] = 0x5d;
|
|
}
|
|
else {
|
|
if (((*pcVar23 != 'c') || (pcVar23[1] != 'l')) || (pcVar23[2] != '\0')) {
|
|
LAB_001a35d9:
|
|
d_print_expr_op(param_1,param_2);
|
|
}
|
|
d_print_subexpr(param_1,param_2,*(undefined8 *)(*(long *)(param_3 + 4) + 0x10));
|
|
}
|
|
if (((**(int **)(param_3 + 2) == 0x32) &&
|
|
(lVar18 = *(long *)(*(int **)(param_3 + 2) + 2), *(int *)(lVar18 + 0x10) == 1)) &&
|
|
(**(char **)(lVar18 + 8) == '>')) {
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
}
|
|
break;
|
|
}
|
|
goto LAB_001a36d0;
|
|
case 0x3a:
|
|
if ((**(int **)(param_3 + 4) == 0x3b) && (**(int **)(*(int **)(param_3 + 4) + 4) == 0x3c)) {
|
|
iVar22 = d_maybe_print_fold_expression_isra_0
|
|
(param_1,param_2,*(undefined8 *)(param_3 + 2),param_3 + 4);
|
|
if (iVar22 == 0) {
|
|
lVar18 = *(long *)(param_3 + 2);
|
|
lVar10 = *(long *)(*(long *)(param_3 + 4) + 8);
|
|
lVar12 = *(long *)(*(long *)(param_3 + 4) + 0x10);
|
|
uVar2 = *(undefined8 *)(lVar12 + 8);
|
|
lVar12 = *(long *)(lVar12 + 0x10);
|
|
pcVar23 = (char *)**(undefined8 **)(lVar18 + 8);
|
|
if (((*pcVar23 == 'q') && (pcVar23[1] == 'u')) && (pcVar23[2] == '\0')) {
|
|
d_print_subexpr(param_1,param_2,lVar10);
|
|
d_print_expr_op(param_1,param_2,lVar18);
|
|
d_print_subexpr(param_1,param_2,uVar2);
|
|
d_append_buffer(param_1,&DAT_001b4704,3);
|
|
d_print_subexpr(param_1,param_2,lVar12);
|
|
}
|
|
else {
|
|
d_append_buffer(param_1,&DAT_001b5030,4);
|
|
if (*(long *)(lVar10 + 8) != 0) {
|
|
d_print_subexpr(param_1,param_2,lVar10);
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
d_print_comp(param_1,param_2,uVar2);
|
|
if (lVar12 != 0) {
|
|
d_print_subexpr(param_1,param_2,lVar12);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
LAB_001a36d0:
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
break;
|
|
case 0x3d:
|
|
case 0x3e:
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
uVar9 = 0;
|
|
if (*piVar11 == 0x27) {
|
|
uVar9 = *(uint *)(*(long *)(piVar11 + 2) + 0x1c);
|
|
if (uVar9 < 7) {
|
|
if ((uVar9 != 0) && (piVar29 = *(int **)(param_3 + 4), *piVar29 == 0)) {
|
|
if (iVar22 == 0x3e) {
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x2d;
|
|
param_1[0x108] = 0x2d;
|
|
piVar29 = *(int **)(param_3 + 4);
|
|
}
|
|
d_print_comp(param_1,param_2,piVar29);
|
|
switch(uVar9) {
|
|
case 2:
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x75;
|
|
param_1[0x108] = 0x75;
|
|
break;
|
|
case 3:
|
|
if (*(long *)(param_1 + 0x100) == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x6c;
|
|
param_1[0x108] = 0x6c;
|
|
break;
|
|
case 4:
|
|
d_append_buffer(param_1,&DAT_001b5035,2);
|
|
break;
|
|
case 5:
|
|
d_append_buffer(param_1,&DAT_001b5038,2);
|
|
break;
|
|
case 6:
|
|
d_append_buffer(param_1,&DAT_001b503b,3);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if ((((uVar9 == 7) && (piVar29 = *(int **)(param_3 + 4), *piVar29 == 0)) &&
|
|
(piVar29[4] == 1)) && (iVar22 == 0x3d)) {
|
|
if (**(char **)(piVar29 + 2) == '0') {
|
|
d_append_buffer(param_1,"false",5);
|
|
break;
|
|
}
|
|
if (**(char **)(piVar29 + 2) == '1') {
|
|
d_append_buffer(param_1,&DAT_001b4631,4);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
piVar11 = *(int **)(param_3 + 2);
|
|
lVar10 = 0;
|
|
lVar18 = 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x28;
|
|
param_1[0x108] = 0x28;
|
|
d_print_comp(param_1,param_2,piVar11);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*param_1 = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
iVar22 = *param_3;
|
|
*(undefined8 *)(param_1 + 0x100) = 1;
|
|
if (iVar22 == 0x3e) goto LAB_001a68f5;
|
|
}
|
|
else {
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
if (*param_3 == 0x3e) {
|
|
if (lVar18 + 1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
*(undefined8 *)(param_1 + 0x100) = 0;
|
|
}
|
|
LAB_001a68f5:
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x2d;
|
|
param_1[0x108] = 0x2d;
|
|
}
|
|
}
|
|
if (uVar9 == 8) {
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x5b;
|
|
param_1[0x108] = 0x5b;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18 + 1;
|
|
param_1[lVar18] = 0x5d;
|
|
param_1[0x108] = 0x5d;
|
|
}
|
|
else {
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
}
|
|
break;
|
|
case 0x3f:
|
|
pcVar23 = "java resource ";
|
|
cVar33 = 'j';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x40:
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
break;
|
|
case 0x41:
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
iVar22 = param_3[2];
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = (char)iVar22;
|
|
param_1[0x108] = (char)iVar22;
|
|
break;
|
|
case 0x42:
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,param_3[2]);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)((long)puVar25 + (long)puVar19);
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar18 = lVar10;
|
|
} while (puVar25 != puVar21);
|
|
}
|
|
break;
|
|
case 0x43:
|
|
pcVar23 = "decltype (";
|
|
cVar33 = 'd';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
break;
|
|
case 0x44:
|
|
pcVar23 = "global constructors keyed to ";
|
|
cVar33 = 'g';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x45:
|
|
pcVar23 = "global destructors keyed to ";
|
|
cVar33 = 'g';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x46:
|
|
puVar19 = &DAT_001b50a5;
|
|
uVar36 = 0x7b;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar19 == &DAT_001b50ac) break;
|
|
uVar36 = *puVar19;
|
|
puVar19 = puVar19 + 1;
|
|
lVar18 = lVar10;
|
|
}
|
|
*(int *)(param_1 + 0x138) = *(int *)(param_1 + 0x138) + 1;
|
|
puVar24 = &DAT_001b50ad;
|
|
uVar36 = 0x29;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
*(int *)(param_1 + 0x138) = *(int *)(param_1 + 0x138) + -1;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b50af) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,param_3[4] + 1);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)((long)puVar25 + (long)puVar19);
|
|
lVar10 = lVar18;
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
else {
|
|
lVar18 = lVar10 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar10 = lVar18;
|
|
} while (puVar21 != puVar25);
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x7d;
|
|
param_1[0x108] = 0x7d;
|
|
break;
|
|
case 0x48:
|
|
pcVar23 = "{unnamed type#";
|
|
cVar33 = '{';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
puVar25 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar25,1,0x19,&DAT_001b458a,(int)*(undefined8 *)(param_3 + 2) + 1);
|
|
puVar21 = puVar25;
|
|
do {
|
|
puVar20 = puVar21;
|
|
uVar8 = *puVar20 + 0xfefefeff & ~*puVar20;
|
|
uVar9 = uVar8 & 0x80808080;
|
|
puVar21 = puVar20 + 1;
|
|
} while (uVar9 == 0);
|
|
if ((uVar8 & 0x8080) == 0) {
|
|
puVar21 = (uint *)((long)puVar20 + 6);
|
|
uVar9 = uVar9 >> 0x10;
|
|
}
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
puVar19 = (undefined1 *)
|
|
((long)puVar21 + ((-3 - (ulong)CARRY1((byte)uVar9,(byte)uVar9)) - (long)puVar25));
|
|
if (puVar19 != (undefined1 *)0x0) {
|
|
puVar21 = (uint *)(puVar19 + (long)puVar25);
|
|
lVar10 = lVar18;
|
|
do {
|
|
uVar9 = *puVar25;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
else {
|
|
lVar18 = lVar10 + 1;
|
|
}
|
|
puVar25 = (uint *)((long)puVar25 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = (char)uVar9;
|
|
param_1[0x108] = (char)uVar9;
|
|
lVar10 = lVar18;
|
|
} while (puVar25 != puVar21);
|
|
}
|
|
lVar10 = lVar18 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = 0x7d;
|
|
param_1[0x108] = 0x7d;
|
|
break;
|
|
case 0x49:
|
|
pcVar23 = "transaction clone for ";
|
|
cVar33 = 't';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x4a:
|
|
pcVar23 = "non-transaction clone for ";
|
|
cVar33 = 'n';
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
break;
|
|
case 0x4b:
|
|
iVar22 = 0;
|
|
piVar11 = (int *)d_find_pack(param_1,*(undefined8 *)(param_3 + 2));
|
|
if (piVar11 == (int *)0x0) {
|
|
d_print_subexpr(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
d_append_buffer(param_1,&DAT_001b5059,3);
|
|
}
|
|
else {
|
|
do {
|
|
if ((*piVar11 != 0x2f) || (*(long *)(piVar11 + 2) == 0)) {
|
|
local_108 = *(undefined8 *)(param_3 + 2);
|
|
if (iVar22 != 0) goto LAB_001a3bf2;
|
|
goto switchD_001a66c1_default;
|
|
}
|
|
piVar11 = *(int **)(piVar11 + 4);
|
|
iVar22 = iVar22 + 1;
|
|
} while (piVar11 != (int *)0x0);
|
|
local_108 = *(undefined8 *)(param_3 + 2);
|
|
LAB_001a3bf2:
|
|
iVar37 = 0;
|
|
do {
|
|
*(int *)(param_1 + 0x13c) = iVar37;
|
|
d_print_comp(param_1,param_2,local_108);
|
|
if (iVar37 < iVar22 + -1) {
|
|
puVar24 = &DAT_001b4738;
|
|
uVar36 = 0x2c;
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 0;
|
|
lVar10 = 1;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b473a) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
}
|
|
iVar37 = iVar37 + 1;
|
|
} while (iVar37 < iVar22);
|
|
}
|
|
break;
|
|
case 0x4c:
|
|
puVar24 = &DAT_001b4e81;
|
|
uVar36 = 0x5b;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
puVar24 = puVar24 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = uVar36;
|
|
param_1[0x108] = uVar36;
|
|
if (puVar24 == &DAT_001b4e86) break;
|
|
uVar36 = *puVar24;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 0;
|
|
lVar18 = 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x5d;
|
|
param_1[0x108] = 0x5d;
|
|
break;
|
|
case 0x4e:
|
|
pcVar23 = " [clone ";
|
|
cVar33 = ' ';
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar18 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar23 = pcVar23 + 1;
|
|
if (lVar18 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar10 = 1;
|
|
lVar18 = 0;
|
|
}
|
|
else {
|
|
lVar10 = lVar18 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar10;
|
|
param_1[lVar18] = cVar33;
|
|
param_1[0x108] = cVar33;
|
|
if (pcVar23 == "") break;
|
|
cVar33 = *pcVar23;
|
|
lVar18 = lVar10;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
param_1[lVar10] = 0x5d;
|
|
param_1[0x108] = 0x5d;
|
|
}
|
|
switchD_001a66c1_default:
|
|
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
|
|
return;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
joined_r0x001a71af:
|
|
if (puVar30 == (undefined8 *)0x0) goto LAB_001a3699;
|
|
if (((int *)*puVar30 == piVar11) ||
|
|
(((int *)*puVar30 == param_3 && (*(undefined8 **)(param_1 + 0x148) != puVar30))))
|
|
goto LAB_001a71df;
|
|
puVar30 = (undefined8 *)puVar30[1];
|
|
goto joined_r0x001a71af;
|
|
LAB_001a3699:
|
|
unaff_RBX = *(undefined8 *)(param_1 + 0x120);
|
|
iVar37 = 1;
|
|
*(undefined8 *)(param_1 + 0x120) = puVar15[1];
|
|
piVar11 = (int *)d_lookup_template_argument_isra_0(param_1,piVar11 + 2);
|
|
if (piVar11 == (int *)0x0) {
|
|
LAB_001a36c9:
|
|
*(undefined8 *)(param_1 + 0x120) = unaff_RBX;
|
|
goto LAB_001a36d0;
|
|
}
|
|
LAB_001a71fa:
|
|
iVar22 = *piVar11;
|
|
if (iVar22 == 0x2f) {
|
|
if (-1 < *(int *)(param_1 + 0x13c)) {
|
|
piVar11 = (int *)d_index_template_argument_part_0();
|
|
if (piVar11 == (int *)0x0) {
|
|
if (iVar37 == 0) goto LAB_001a36d0;
|
|
goto LAB_001a36c9;
|
|
}
|
|
iVar22 = *piVar11;
|
|
goto LAB_001a3a6d;
|
|
}
|
|
local_e8[0] = *(long **)(param_1 + 0x128);
|
|
plVar16 = local_e8[0];
|
|
if (*param_3 != 0x2f) goto LAB_001a36ec;
|
|
LAB_001a5f51:
|
|
param_3 = piVar11;
|
|
plVar16 = local_e8[0];
|
|
goto LAB_001a36ec;
|
|
}
|
|
LAB_001a3a6d:
|
|
local_e8[0] = *(long **)(param_1 + 0x128);
|
|
if ((iVar22 == 0x23) || (*param_3 == iVar22)) goto LAB_001a5f51;
|
|
plVar16 = local_e8[0];
|
|
if (iVar22 != 0x24) goto LAB_001a36ec;
|
|
lVar18 = *(long *)(piVar11 + 2);
|
|
*(long ***)(param_1 + 0x128) = local_e8;
|
|
local_d0[0] = *(long **)(param_1 + 0x120);
|
|
local_e8[1] = (long *)param_3;
|
|
if (lVar18 == 0) goto LAB_001a3711;
|
|
goto LAB_001a3716;
|
|
joined_r0x001a6ee2:
|
|
if ((0x34 < iVar22 - 0x1cU) ||
|
|
(uVar9 = (uint)uVar34, (1L << ((byte)(iVar22 - 0x1cU) & 0x3f) & 0x1a00000000001fU) == 0))
|
|
goto LAB_001a4380;
|
|
if (3 < (uint)uVar17) goto LAB_001a7114;
|
|
plVar4 = pplVar13[-2];
|
|
plVar5 = pplVar13[-1];
|
|
uVar17 = uVar17 + 1;
|
|
pplVar13[-1] = plVar14;
|
|
*(undefined4 *)(pplVar13 + -2) = 0;
|
|
plVar6 = pplVar13[-3];
|
|
uVar34 = uVar17 & 0xffffffff;
|
|
uVar9 = (uint)uVar17;
|
|
pplVar13[-3] = plVar16;
|
|
plVar16 = (long *)plVar16[1];
|
|
*pplVar13 = pplVar13[-4];
|
|
pplVar13[1] = plVar6;
|
|
iVar22 = (int)*plVar16;
|
|
*pplVar13 = (long *)(pplVar13 + -4);
|
|
*(long ***)(param_1 + 0x128) = pplVar13;
|
|
pplVar13[2] = plVar4;
|
|
pplVar13[3] = plVar5;
|
|
pplVar13 = pplVar13 + 4;
|
|
goto joined_r0x001a6ee2;
|
|
LAB_001a4380:
|
|
if (iVar22 == 4) {
|
|
*(long ***)(param_1 + 0x120) = &local_f8;
|
|
local_f8 = plVar14;
|
|
local_f0 = plVar16;
|
|
}
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 4));
|
|
if ((int)*plVar16 == 4) {
|
|
*(long **)(param_1 + 0x120) = local_f8;
|
|
}
|
|
if (uVar9 != 0) {
|
|
pplVar13 = local_e8 + (ulong)(uVar9 - 1) * 4;
|
|
do {
|
|
if (*(int *)(pplVar13 + 2) == 0) {
|
|
lVar10 = *(long *)(param_1 + 0x100);
|
|
lVar18 = lVar10 + 1;
|
|
if (lVar10 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar18 = 1;
|
|
lVar10 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar18;
|
|
plVar16 = pplVar13[1];
|
|
param_1[lVar10] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
d_print_mod(param_1,param_2,plVar16);
|
|
}
|
|
bVar38 = local_e8 != pplVar13;
|
|
pplVar13 = pplVar13 + -4;
|
|
} while (bVar38);
|
|
}
|
|
*(undefined8 *)(param_1 + 0x128) = uVar2;
|
|
goto switchD_001a66c1_default;
|
|
}
|
|
|
|
|
|
// 001a7910 d_print_comp
|
|
|
|
void d_print_comp(long param_1,undefined8 param_2,long param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
long local_28;
|
|
undefined8 local_20;
|
|
|
|
if (((param_3 != 0) && (*(int *)(param_3 + 4) < 2)) &&
|
|
(iVar1 = *(int *)(param_1 + 0x134), iVar1 < 0x401)) {
|
|
*(int *)(param_3 + 4) = *(int *)(param_3 + 4) + 1;
|
|
local_20 = *(undefined8 *)(param_1 + 0x148);
|
|
*(int *)(param_1 + 0x134) = iVar1 + 1;
|
|
*(long **)(param_1 + 0x148) = &local_28;
|
|
local_28 = param_3;
|
|
d_print_comp_inner(param_1,param_2,param_3);
|
|
*(undefined8 *)(param_1 + 0x148) = local_20;
|
|
*(int *)(param_3 + 4) = *(int *)(param_3 + 4) + -1;
|
|
*(int *)(param_1 + 0x134) = *(int *)(param_1 + 0x134) + -1;
|
|
return;
|
|
}
|
|
*(undefined4 *)(param_1 + 0x130) = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
// 001a79b0 d_print_mod
|
|
|
|
void d_print_mod(undefined1 *param_1,uint param_2,undefined4 *param_3)
|
|
|
|
{
|
|
long lVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
undefined1 uVar4;
|
|
undefined *puVar5;
|
|
char *pcVar6;
|
|
char cVar7;
|
|
|
|
switch(*param_3) {
|
|
case 3:
|
|
param_3 = *(undefined4 **)(param_3 + 2);
|
|
goto LAB_001a79eb;
|
|
default:
|
|
goto LAB_001a79eb;
|
|
case 0x19:
|
|
case 0x1c:
|
|
pcVar6 = " restrict";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x1a:
|
|
case 0x1d:
|
|
pcVar6 = " volatile";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x1b:
|
|
case 0x1e:
|
|
pcVar6 = " const";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
pcVar6 = pcVar6 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x1f:
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
if (lVar1 != 0xff) {
|
|
lVar3 = lVar1 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
goto LAB_001a7e07;
|
|
}
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*param_1 = 0x20;
|
|
lVar3 = 1;
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
goto LAB_001a7e13;
|
|
case 0x20:
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar3 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
goto LAB_001a7bfb;
|
|
case 0x21:
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar3 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
param_3 = *(undefined4 **)(param_3 + 4);
|
|
LAB_001a79eb:
|
|
d_print_comp(param_1,param_2,param_3);
|
|
return;
|
|
case 0x22:
|
|
if ((param_2 & 4) == 0) {
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar3 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x2a;
|
|
param_1[0x108] = 0x2a;
|
|
}
|
|
break;
|
|
case 0x23:
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
LAB_001a7e07:
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
goto LAB_001a7e17;
|
|
}
|
|
LAB_001a7e13:
|
|
lVar1 = lVar3 + 1;
|
|
LAB_001a7e17:
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = 0x26;
|
|
param_1[0x108] = 0x26;
|
|
return;
|
|
case 0x24:
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
LAB_001a7bfb:
|
|
puVar5 = &DAT_001b5106;
|
|
uVar4 = 0x26;
|
|
while( true ) {
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
puVar5 = puVar5 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = uVar4;
|
|
param_1[0x108] = uVar4;
|
|
if (puVar5 == &DAT_001b5108) break;
|
|
uVar4 = *puVar5;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x25:
|
|
pcVar6 = "complex ";
|
|
cVar7 = 'c';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x26:
|
|
pcVar6 = "imaginary ";
|
|
cVar7 = 'i';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x2b:
|
|
if (param_1[0x108] != '(') {
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar3 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x20;
|
|
param_1[0x108] = 0x20;
|
|
}
|
|
puVar5 = &DAT_001b511d;
|
|
uVar4 = 0x3a;
|
|
d_print_comp(param_1,param_2,*(undefined8 *)(param_3 + 2));
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
puVar5 = puVar5 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = uVar4;
|
|
param_1[0x108] = uVar4;
|
|
if (puVar5 == &DAT_001b5120) break;
|
|
uVar4 = *puVar5;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x2d:
|
|
pcVar6 = " __vector(";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
lVar3 = *(long *)(param_3 + 2);
|
|
goto LAB_001a81ad;
|
|
case 0x4d:
|
|
pcVar6 = " transaction_safe";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
break;
|
|
case 0x4f:
|
|
pcVar6 = " noexcept";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar6 = pcVar6 + 1;
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
goto LAB_001a8150;
|
|
case 0x50:
|
|
pcVar6 = " throw";
|
|
cVar7 = ' ';
|
|
lVar3 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar3 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar1 = 1;
|
|
lVar3 = 0;
|
|
}
|
|
else {
|
|
lVar1 = lVar3 + 1;
|
|
}
|
|
pcVar6 = pcVar6 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar1;
|
|
param_1[lVar3] = cVar7;
|
|
param_1[0x108] = cVar7;
|
|
if (pcVar6 == "") break;
|
|
cVar7 = *pcVar6;
|
|
lVar3 = lVar1;
|
|
}
|
|
LAB_001a8150:
|
|
lVar3 = *(long *)(param_3 + 4);
|
|
if (lVar3 != 0) {
|
|
lVar2 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = *(long *)(param_3 + 4);
|
|
lVar1 = 0;
|
|
lVar2 = 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar2;
|
|
param_1[lVar1] = 0x28;
|
|
param_1[0x108] = 0x28;
|
|
LAB_001a81ad:
|
|
d_print_comp(param_1,param_2,lVar3);
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar3 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
param_1[0xff] = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar3 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar3;
|
|
param_1[lVar1] = 0x29;
|
|
param_1[0x108] = 0x29;
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001a82f0 d_print_function_type.isra.0
|
|
|
|
void d_print_function_type_isra_0
|
|
(undefined2 *param_1,undefined4 param_2,long *param_3,undefined8 *param_4)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
long lVar2;
|
|
byte bVar3;
|
|
long lVar4;
|
|
undefined8 uVar5;
|
|
|
|
puVar1 = param_4;
|
|
joined_r0x001a8307:
|
|
if ((puVar1 != (undefined8 *)0x0) && (*(int *)(puVar1 + 2) == 0)) {
|
|
switch(*(undefined4 *)puVar1[1]) {
|
|
case 0x19:
|
|
case 0x1a:
|
|
case 0x1b:
|
|
case 0x21:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x2b:
|
|
bVar3 = *(byte *)(param_1 + 0x84);
|
|
lVar4 = *(long *)(param_1 + 0x80);
|
|
LAB_001a834e:
|
|
lVar2 = lVar4;
|
|
if (bVar3 == 0x20) {
|
|
LAB_001a8378:
|
|
if (lVar2 == 0xff) goto LAB_001a8538;
|
|
}
|
|
else {
|
|
if (lVar4 != 0xff) {
|
|
lVar2 = lVar4 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar2;
|
|
*(undefined1 *)((long)param_1 + lVar4) = 0x20;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x20;
|
|
goto LAB_001a8378;
|
|
}
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)param_1 = 0x20;
|
|
lVar2 = 1;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
}
|
|
LAB_001a8384:
|
|
lVar4 = lVar2 + 1;
|
|
break;
|
|
default:
|
|
goto switchD_001a833b_caseD_1c;
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
bVar3 = *(byte *)(param_1 + 0x84);
|
|
lVar2 = *(long *)(param_1 + 0x80);
|
|
lVar4 = lVar2;
|
|
if ((bVar3 & 0xfd) != 0x28) goto LAB_001a834e;
|
|
if (lVar2 != 0xff) goto LAB_001a8384;
|
|
LAB_001a8538:
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
lVar4 = 1;
|
|
lVar2 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x80) = lVar4;
|
|
*(undefined1 *)((long)param_1 + lVar2) = 0x28;
|
|
uVar5 = *(undefined8 *)(param_1 + 0x94);
|
|
*(undefined1 *)(param_1 + 0x84) = 0x28;
|
|
*(undefined8 *)(param_1 + 0x94) = 0;
|
|
d_print_mod_list(param_1,param_2,param_4,0);
|
|
lVar2 = *(long *)(param_1 + 0x80);
|
|
if (lVar2 != 0xff) {
|
|
lVar4 = lVar2 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar4;
|
|
*(undefined1 *)((long)param_1 + lVar2) = 0x29;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x29;
|
|
goto joined_r0x001a84b0;
|
|
}
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)(param_1 + 0x84) = 0x28;
|
|
*param_1 = 0x2829;
|
|
lVar4 = *param_3;
|
|
lVar2 = 2;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
*(undefined8 *)(param_1 + 0x80) = 2;
|
|
if (lVar4 != 0) goto LAB_001a8411;
|
|
goto LAB_001a842f;
|
|
}
|
|
uVar5 = *(undefined8 *)(param_1 + 0x94);
|
|
*(undefined8 *)(param_1 + 0x94) = 0;
|
|
d_print_mod_list(param_1,param_2,param_4,0);
|
|
lVar4 = *(long *)(param_1 + 0x80);
|
|
joined_r0x001a84b0:
|
|
if (lVar4 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)param_1 = 0x28;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x28;
|
|
lVar2 = *param_3;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
*(undefined8 *)(param_1 + 0x80) = 1;
|
|
if (lVar2 != 0) {
|
|
LAB_001a8411:
|
|
d_print_comp(param_1,param_2);
|
|
lVar2 = *(long *)(param_1 + 0x80);
|
|
goto LAB_001a8423;
|
|
}
|
|
lVar2 = 1;
|
|
}
|
|
else {
|
|
lVar2 = lVar4 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar2;
|
|
*(undefined1 *)((long)param_1 + lVar4) = 0x28;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x28;
|
|
if (*param_3 != 0) goto LAB_001a8411;
|
|
LAB_001a8423:
|
|
if (lVar2 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
lVar4 = 1;
|
|
lVar2 = 0;
|
|
goto LAB_001a8433;
|
|
}
|
|
}
|
|
LAB_001a842f:
|
|
lVar4 = lVar2 + 1;
|
|
LAB_001a8433:
|
|
*(long *)(param_1 + 0x80) = lVar4;
|
|
*(undefined1 *)((long)param_1 + lVar2) = 0x29;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x29;
|
|
d_print_mod_list(param_1,param_2,param_4,1);
|
|
*(undefined8 *)(param_1 + 0x94) = uVar5;
|
|
return;
|
|
switchD_001a833b_caseD_1c:
|
|
puVar1 = (undefined8 *)*puVar1;
|
|
goto joined_r0x001a8307;
|
|
}
|
|
|
|
|
|
// 001a8630 d_print_mod_list
|
|
|
|
void d_print_mod_list(long param_1,uint param_2,undefined8 *param_3,int param_4)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
undefined8 uVar2;
|
|
undefined8 uVar3;
|
|
uint uVar4;
|
|
uint uVar5;
|
|
long lVar6;
|
|
int iVar7;
|
|
long lVar8;
|
|
uint *puVar9;
|
|
uint *puVar10;
|
|
undefined1 *puVar11;
|
|
char *pcVar12;
|
|
uint *puVar13;
|
|
undefined *puVar14;
|
|
int *piVar15;
|
|
undefined1 uVar16;
|
|
char cVar17;
|
|
long in_FS_OFFSET;
|
|
undefined1 auStack_6b [43];
|
|
long local_40;
|
|
|
|
local_40 = *(long *)(in_FS_OFFSET + 0x28);
|
|
do {
|
|
if ((param_3 == (undefined8 *)0x0) || (*(int *)(param_1 + 0x130) != 0)) goto LAB_001a87c0;
|
|
if (*(int *)(param_3 + 2) == 0) {
|
|
piVar15 = (int *)param_3[1];
|
|
iVar7 = *piVar15;
|
|
if (((param_4 != 0) || (0x34 < iVar7 - 0x1cU)) ||
|
|
((0x1a00000000001fU >> ((ulong)(iVar7 - 0x1cU) & 0x3f) & 1) == 0)) {
|
|
*(undefined4 *)(param_3 + 2) = 1;
|
|
uVar1 = *(undefined8 *)(param_1 + 0x120);
|
|
*(undefined8 *)(param_1 + 0x120) = param_3[3];
|
|
if (iVar7 == 0x29) {
|
|
d_print_function_type_isra_0(param_1,param_2,piVar15 + 4,*param_3);
|
|
*(undefined8 *)(param_1 + 0x120) = uVar1;
|
|
goto LAB_001a87c0;
|
|
}
|
|
if (iVar7 == 0x2a) {
|
|
d_print_array_type_isra_0(param_1,param_2,piVar15 + 2,*param_3);
|
|
*(undefined8 *)(param_1 + 0x120) = uVar1;
|
|
goto LAB_001a87c0;
|
|
}
|
|
if (iVar7 == 2) {
|
|
uVar2 = *(undefined8 *)(param_1 + 0x128);
|
|
uVar3 = *(undefined8 *)(piVar15 + 2);
|
|
*(undefined8 *)(param_1 + 0x128) = 0;
|
|
d_print_comp(param_1,param_2,uVar3);
|
|
*(undefined8 *)(param_1 + 0x128) = uVar2;
|
|
lVar6 = *(long *)(param_1 + 0x100);
|
|
if ((param_2 & 4) == 0) {
|
|
puVar14 = &DAT_001b4e87;
|
|
uVar16 = 0x3a;
|
|
while( true ) {
|
|
if (lVar6 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar6 = 0;
|
|
lVar8 = 1;
|
|
}
|
|
else {
|
|
lVar8 = lVar6 + 1;
|
|
}
|
|
puVar14 = puVar14 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar8;
|
|
*(undefined1 *)(param_1 + lVar6) = uVar16;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar16;
|
|
if (puVar14 == &DAT_001b4e89) break;
|
|
uVar16 = *puVar14;
|
|
lVar6 = lVar8;
|
|
}
|
|
}
|
|
else {
|
|
lVar8 = lVar6 + 1;
|
|
if (lVar6 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar8 = 1;
|
|
lVar6 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar8;
|
|
*(undefined1 *)(param_1 + lVar6) = 0x2e;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x2e;
|
|
}
|
|
piVar15 = *(int **)(param_3[1] + 0x10);
|
|
iVar7 = *piVar15;
|
|
if (iVar7 == 0x47) {
|
|
pcVar12 = "{default arg#";
|
|
cVar17 = '{';
|
|
lVar6 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
pcVar12 = pcVar12 + 1;
|
|
if (lVar6 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar6 = 0;
|
|
lVar8 = 1;
|
|
}
|
|
else {
|
|
lVar8 = lVar6 + 1;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar8;
|
|
*(char *)(param_1 + lVar6) = cVar17;
|
|
*(char *)(param_1 + 0x108) = cVar17;
|
|
if (pcVar12 == "") break;
|
|
cVar17 = *pcVar12;
|
|
lVar6 = lVar8;
|
|
}
|
|
puVar13 = (uint *)(auStack_6b + 3);
|
|
__sprintf_chk(puVar13,1,0x19,&DAT_001b458a,piVar15[4] + 1);
|
|
puVar10 = puVar13;
|
|
do {
|
|
puVar9 = puVar10;
|
|
uVar4 = *puVar9 + 0xfefefeff & ~*puVar9;
|
|
uVar5 = uVar4 & 0x80808080;
|
|
puVar10 = puVar9 + 1;
|
|
} while (uVar5 == 0);
|
|
if ((uVar4 & 0x8080) == 0) {
|
|
puVar10 = (uint *)((long)puVar9 + 6);
|
|
uVar5 = uVar5 >> 0x10;
|
|
}
|
|
lVar6 = *(long *)(param_1 + 0x100);
|
|
puVar11 = (undefined1 *)
|
|
((long)puVar10 +
|
|
((-3 - (ulong)CARRY1((byte)uVar5,(byte)uVar5)) - (long)puVar13));
|
|
if (puVar11 != (undefined1 *)0x0) {
|
|
puVar10 = (uint *)((long)puVar13 + (long)puVar11);
|
|
lVar8 = lVar6;
|
|
do {
|
|
uVar16 = (undefined1)*puVar13;
|
|
if (lVar8 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
auStack_6b[2] = uVar16;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar8 = 0;
|
|
lVar6 = 1;
|
|
uVar16 = auStack_6b[2];
|
|
}
|
|
else {
|
|
lVar6 = lVar8 + 1;
|
|
}
|
|
puVar13 = (uint *)((long)puVar13 + 1);
|
|
*(long *)(param_1 + 0x100) = lVar6;
|
|
*(undefined1 *)(param_1 + lVar8) = uVar16;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar16;
|
|
lVar8 = lVar6;
|
|
} while (puVar10 != puVar13);
|
|
}
|
|
puVar14 = &DAT_001b4e98;
|
|
uVar16 = 0x7d;
|
|
while( true ) {
|
|
if (lVar6 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar6 = 0;
|
|
lVar8 = 1;
|
|
}
|
|
else {
|
|
lVar8 = lVar6 + 1;
|
|
}
|
|
puVar14 = puVar14 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar8;
|
|
*(undefined1 *)(param_1 + lVar6) = uVar16;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar16;
|
|
if (puVar14 == &DAT_001b4e9b) break;
|
|
uVar16 = *puVar14;
|
|
lVar6 = lVar8;
|
|
}
|
|
piVar15 = *(int **)(piVar15 + 2);
|
|
iVar7 = *piVar15;
|
|
}
|
|
while ((iVar7 - 0x1cU < 0x35 &&
|
|
((1L << ((byte)(iVar7 - 0x1cU) & 0x3f) & 0x1a00000000001fU) != 0))) {
|
|
piVar15 = *(int **)(piVar15 + 2);
|
|
iVar7 = *piVar15;
|
|
}
|
|
d_print_comp(param_1,param_2,piVar15);
|
|
*(undefined8 *)(param_1 + 0x120) = uVar1;
|
|
LAB_001a87c0:
|
|
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
|
|
/* WARNING: Subroutine does not return */
|
|
__stack_chk_fail();
|
|
}
|
|
return;
|
|
}
|
|
d_print_mod(param_1,param_2,piVar15);
|
|
*(undefined8 *)(param_1 + 0x120) = uVar1;
|
|
}
|
|
}
|
|
param_3 = (undefined8 *)*param_3;
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001a8a90 d_print_array_type.isra.0
|
|
|
|
void d_print_array_type_isra_0(undefined2 *param_1,undefined4 param_2,long *param_3,long *param_4)
|
|
|
|
{
|
|
long *plVar1;
|
|
long lVar2;
|
|
long lVar3;
|
|
undefined *puVar4;
|
|
undefined1 uVar5;
|
|
|
|
plVar1 = param_4;
|
|
if (param_4 != (long *)0x0) {
|
|
LAB_001a8ab8:
|
|
if ((int)plVar1[2] != 0) goto code_r0x001a8ac3;
|
|
if (*(int *)plVar1[1] != 0x2a) {
|
|
puVar4 = &DAT_001b512c;
|
|
uVar5 = 0x20;
|
|
lVar3 = *(long *)(param_1 + 0x80);
|
|
while( true ) {
|
|
if (lVar3 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
lVar3 = 0;
|
|
lVar2 = 1;
|
|
}
|
|
else {
|
|
lVar2 = lVar3 + 1;
|
|
}
|
|
puVar4 = puVar4 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar2;
|
|
*(undefined1 *)((long)param_1 + lVar3) = uVar5;
|
|
*(undefined1 *)(param_1 + 0x84) = uVar5;
|
|
if (puVar4 == &DAT_001b512e) break;
|
|
uVar5 = *puVar4;
|
|
lVar3 = lVar2;
|
|
}
|
|
d_print_mod_list(param_1,param_2,param_4,0);
|
|
lVar3 = *(long *)(param_1 + 0x80);
|
|
if (lVar3 != 0xff) {
|
|
lVar2 = lVar3 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar2;
|
|
*(undefined1 *)((long)param_1 + lVar3) = 0x29;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x29;
|
|
goto LAB_001a8ae1;
|
|
}
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)param_1 = 0x29;
|
|
lVar2 = 1;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
goto LAB_001a8aed;
|
|
}
|
|
d_print_mod_list(param_1,param_2,param_4,0);
|
|
lVar3 = *(long *)(param_1 + 0x80);
|
|
goto LAB_001a8b03;
|
|
}
|
|
LAB_001a8ada:
|
|
lVar2 = *(long *)(param_1 + 0x80);
|
|
LAB_001a8ae1:
|
|
if (lVar2 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)(param_1 + 0x84) = 0x5b;
|
|
*param_1 = 0x5b20;
|
|
lVar3 = *param_3;
|
|
lVar2 = 2;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
*(undefined8 *)(param_1 + 0x80) = 2;
|
|
if (lVar3 != 0) goto LAB_001a8b2b;
|
|
}
|
|
else {
|
|
LAB_001a8aed:
|
|
lVar3 = lVar2 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar3;
|
|
*(undefined1 *)((long)param_1 + lVar2) = 0x20;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x20;
|
|
LAB_001a8b03:
|
|
if (lVar3 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(undefined1 *)param_1 = 0x5b;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x5b;
|
|
lVar3 = *param_3;
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
*(undefined8 *)(param_1 + 0x80) = 1;
|
|
if (lVar3 == 0) {
|
|
lVar2 = 1;
|
|
goto LAB_001a8b44;
|
|
}
|
|
LAB_001a8b2b:
|
|
d_print_comp(param_1,param_2);
|
|
lVar2 = *(long *)(param_1 + 0x80);
|
|
}
|
|
else {
|
|
lVar2 = lVar3 + 1;
|
|
*(long *)(param_1 + 0x80) = lVar2;
|
|
*(undefined1 *)((long)param_1 + lVar3) = 0x5b;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x5b;
|
|
if (*param_3 != 0) goto LAB_001a8b2b;
|
|
}
|
|
if (lVar2 == 0xff) {
|
|
*(undefined1 *)((long)param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x88))(param_1,0xff,*(undefined8 *)(param_1 + 0x8c));
|
|
*(long *)(param_1 + 0xa0) = *(long *)(param_1 + 0xa0) + 1;
|
|
lVar3 = 1;
|
|
lVar2 = 0;
|
|
goto LAB_001a8b48;
|
|
}
|
|
}
|
|
LAB_001a8b44:
|
|
lVar3 = lVar2 + 1;
|
|
LAB_001a8b48:
|
|
*(long *)(param_1 + 0x80) = lVar3;
|
|
*(undefined1 *)((long)param_1 + lVar2) = 0x5d;
|
|
*(undefined1 *)(param_1 + 0x84) = 0x5d;
|
|
return;
|
|
code_r0x001a8ac3:
|
|
plVar1 = (long *)*plVar1;
|
|
if (plVar1 == (long *)0x0) goto code_r0x001a8acb;
|
|
goto LAB_001a8ab8;
|
|
code_r0x001a8acb:
|
|
d_print_mod_list(param_1,param_2,param_4,0);
|
|
goto LAB_001a8ada;
|
|
}
|
|
|
|
|
|
// 001a8d70 d_print_expr_op
|
|
|
|
void d_print_expr_op(long param_1,undefined8 param_2,int *param_3)
|
|
|
|
{
|
|
undefined1 uVar1;
|
|
long lVar2;
|
|
undefined1 *puVar3;
|
|
long lVar4;
|
|
undefined1 *puVar5;
|
|
|
|
if (*param_3 != 0x32) {
|
|
d_print_comp();
|
|
return;
|
|
}
|
|
lVar4 = (long)*(int *)(*(long *)(param_3 + 2) + 0x10);
|
|
puVar3 = *(undefined1 **)(*(long *)(param_3 + 2) + 8);
|
|
if (lVar4 != 0) {
|
|
puVar5 = puVar3 + lVar4;
|
|
lVar4 = *(long *)(param_1 + 0x100);
|
|
do {
|
|
uVar1 = *puVar3;
|
|
if (lVar4 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar2 = 1;
|
|
lVar4 = 0;
|
|
}
|
|
else {
|
|
lVar2 = lVar4 + 1;
|
|
}
|
|
puVar3 = puVar3 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar2;
|
|
*(undefined1 *)(param_1 + lVar4) = uVar1;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar1;
|
|
lVar4 = lVar2;
|
|
} while (puVar3 != puVar5);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001a8e30 d_print_subexpr
|
|
|
|
void d_print_subexpr(long param_1,ulong param_2,uint *param_3)
|
|
|
|
{
|
|
long lVar1;
|
|
long lVar2;
|
|
|
|
if ((*param_3 < 0x32) && ((0x2000000000043U >> ((ulong)*param_3 & 0x3f) & 1) != 0)) {
|
|
d_print_comp(param_1,param_2,param_3);
|
|
return;
|
|
}
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar2 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar2 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar2;
|
|
*(undefined1 *)(param_1 + lVar1) = 0x28;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x28;
|
|
d_print_comp(param_1,param_2 & 0xffffffff,param_3);
|
|
lVar1 = *(long *)(param_1 + 0x100);
|
|
lVar2 = lVar1 + 1;
|
|
if (lVar1 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar2 = 1;
|
|
lVar1 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar2;
|
|
*(undefined1 *)(param_1 + lVar1) = 0x29;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x29;
|
|
return;
|
|
}
|
|
|
|
|
|
// 001a8f30 d_maybe_print_fold_expression.isra.0
|
|
|
|
undefined8
|
|
d_maybe_print_fold_expression_isra_0(long param_1,undefined4 param_2,long param_3,long *param_4)
|
|
|
|
{
|
|
char cVar1;
|
|
undefined4 uVar2;
|
|
char *pcVar3;
|
|
undefined8 uVar4;
|
|
long lVar5;
|
|
int *piVar6;
|
|
long lVar7;
|
|
undefined1 uVar8;
|
|
int *piVar9;
|
|
undefined *puVar10;
|
|
|
|
pcVar3 = (char *)**(undefined8 **)(param_3 + 8);
|
|
if (*pcVar3 != 'f') {
|
|
return 0;
|
|
}
|
|
piVar9 = (int *)0x0;
|
|
piVar6 = *(int **)(*param_4 + 0x10);
|
|
uVar4 = *(undefined8 *)(*param_4 + 8);
|
|
if (*piVar6 == 0x3c) {
|
|
piVar9 = *(int **)(piVar6 + 4);
|
|
piVar6 = *(int **)(piVar6 + 2);
|
|
}
|
|
uVar2 = *(undefined4 *)(param_1 + 0x13c);
|
|
*(undefined4 *)(param_1 + 0x13c) = 0xffffffff;
|
|
cVar1 = pcVar3[1];
|
|
if (cVar1 == 'l') {
|
|
puVar10 = &DAT_001b512f;
|
|
uVar8 = 0x28;
|
|
lVar7 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar7 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar7 = 0;
|
|
lVar5 = 1;
|
|
}
|
|
else {
|
|
lVar5 = lVar7 + 1;
|
|
}
|
|
puVar10 = puVar10 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar5;
|
|
*(undefined1 *)(param_1 + lVar7) = uVar8;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar8;
|
|
if (puVar10 == &DAT_001b5133) break;
|
|
uVar8 = *puVar10;
|
|
lVar7 = lVar5;
|
|
}
|
|
d_print_expr_op(param_1,param_2,uVar4);
|
|
}
|
|
else {
|
|
if ('l' < cVar1) {
|
|
if (cVar1 == 'r') {
|
|
lVar5 = *(long *)(param_1 + 0x100);
|
|
lVar7 = lVar5 + 1;
|
|
if (lVar5 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar7 = 1;
|
|
lVar5 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar7;
|
|
*(undefined1 *)(param_1 + lVar5) = 0x28;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x28;
|
|
d_print_subexpr(param_1,param_2,piVar6);
|
|
puVar10 = &DAT_001b5134;
|
|
uVar8 = 0x2e;
|
|
d_print_expr_op(param_1,param_2,uVar4);
|
|
lVar7 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar7 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar5 = 1;
|
|
lVar7 = 0;
|
|
}
|
|
else {
|
|
lVar5 = lVar7 + 1;
|
|
}
|
|
puVar10 = puVar10 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar5;
|
|
*(undefined1 *)(param_1 + lVar7) = uVar8;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar8;
|
|
if (puVar10 == &DAT_001b5138) break;
|
|
uVar8 = *puVar10;
|
|
lVar7 = lVar5;
|
|
}
|
|
}
|
|
goto LAB_001a90e2;
|
|
}
|
|
if ((cVar1 != 'L') && (cVar1 != 'R')) goto LAB_001a90e2;
|
|
lVar5 = *(long *)(param_1 + 0x100);
|
|
lVar7 = lVar5 + 1;
|
|
if (lVar5 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar7 = 1;
|
|
lVar5 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar7;
|
|
*(undefined1 *)(param_1 + lVar5) = 0x28;
|
|
puVar10 = &DAT_001b5059;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x28;
|
|
d_print_subexpr(param_1,param_2,piVar6);
|
|
d_print_expr_op(param_1,param_2,uVar4);
|
|
uVar8 = 0x2e;
|
|
lVar7 = *(long *)(param_1 + 0x100);
|
|
while( true ) {
|
|
if (lVar7 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar7 = 0;
|
|
lVar5 = 1;
|
|
}
|
|
else {
|
|
lVar5 = lVar7 + 1;
|
|
}
|
|
puVar10 = puVar10 + 1;
|
|
*(long *)(param_1 + 0x100) = lVar5;
|
|
*(undefined1 *)(param_1 + lVar7) = uVar8;
|
|
*(undefined1 *)(param_1 + 0x108) = uVar8;
|
|
if (puVar10 == &DAT_001b505c) break;
|
|
uVar8 = *puVar10;
|
|
lVar7 = lVar5;
|
|
}
|
|
d_print_expr_op(param_1,param_2,uVar4);
|
|
piVar6 = piVar9;
|
|
}
|
|
d_print_subexpr(param_1,param_2,piVar6);
|
|
lVar5 = *(long *)(param_1 + 0x100);
|
|
lVar7 = lVar5 + 1;
|
|
if (lVar5 == 0xff) {
|
|
*(undefined1 *)(param_1 + 0xff) = 0;
|
|
(**(code **)(param_1 + 0x110))(param_1,0xff,*(undefined8 *)(param_1 + 0x118));
|
|
*(long *)(param_1 + 0x140) = *(long *)(param_1 + 0x140) + 1;
|
|
lVar7 = 1;
|
|
lVar5 = 0;
|
|
}
|
|
*(long *)(param_1 + 0x100) = lVar7;
|
|
*(undefined1 *)(param_1 + lVar5) = 0x29;
|
|
*(undefined1 *)(param_1 + 0x108) = 0x29;
|
|
LAB_001a90e2:
|
|
*(undefined4 *)(param_1 + 0x13c) = uVar2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 001a92e0 d_demangle_callback.constprop.0
|
|
|
|
bool d_demangle_callback_constprop_0(byte *param_1,code *param_2,undefined8 param_3)
|
|
|
|
{
|
|
byte bVar1;
|
|
long lVar2;
|
|
code *pcVar3;
|
|
undefined8 uVar4;
|
|
undefined1 *puVar5;
|
|
byte bVar6;
|
|
int iVar7;
|
|
size_t sVar8;
|
|
long lVar9;
|
|
ulong uVar10;
|
|
long lVar11;
|
|
long lVar12;
|
|
byte *pbVar13;
|
|
byte *pbVar14;
|
|
undefined8 *puVar15;
|
|
long in_FS_OFFSET;
|
|
bool bVar16;
|
|
bool bVar17;
|
|
undefined *puStack_240;
|
|
undefined8 local_238;
|
|
ulong local_230;
|
|
byte *local_228;
|
|
code *local_220;
|
|
byte *local_218;
|
|
byte *local_210;
|
|
uint local_208;
|
|
byte *local_200;
|
|
ulong local_1f8;
|
|
int local_1f0;
|
|
uint local_1ec;
|
|
undefined1 *local_1e8;
|
|
undefined4 local_1e0;
|
|
int local_1dc;
|
|
undefined8 local_1d8;
|
|
undefined8 local_1d0;
|
|
undefined8 local_1c8;
|
|
undefined1 local_1b8 [256];
|
|
long local_b8;
|
|
undefined1 local_b0;
|
|
code *local_a8;
|
|
undefined8 local_a0;
|
|
undefined8 local_98;
|
|
undefined8 local_90;
|
|
undefined8 local_88;
|
|
undefined8 local_80;
|
|
undefined8 local_78;
|
|
undefined8 local_70;
|
|
undefined1 *local_68;
|
|
undefined8 local_60;
|
|
undefined1 *local_58;
|
|
undefined8 local_50;
|
|
undefined8 local_48;
|
|
long local_40;
|
|
|
|
bVar6 = *param_1;
|
|
local_40 = *(long *)(in_FS_OFFSET + 0x28);
|
|
bVar16 = bVar6 < 0x5f;
|
|
bVar17 = false;
|
|
if (bVar6 == 0x5f) {
|
|
bVar16 = param_1[1] < 0x5a;
|
|
bVar17 = param_1[1] == 0x5a;
|
|
iVar7 = 1;
|
|
if (!bVar17) goto LAB_001a931c;
|
|
}
|
|
else {
|
|
LAB_001a931c:
|
|
lVar11 = 8;
|
|
pbVar13 = param_1;
|
|
pbVar14 = (byte *)"_GLOBAL_";
|
|
do {
|
|
if (lVar11 == 0) break;
|
|
lVar11 = lVar11 + -1;
|
|
bVar16 = *pbVar13 < *pbVar14;
|
|
bVar17 = *pbVar13 == *pbVar14;
|
|
pbVar13 = pbVar13 + 1;
|
|
pbVar14 = pbVar14 + 1;
|
|
} while (bVar17);
|
|
iVar7 = 0;
|
|
if ((((((!bVar16 && !bVar17) == bVar16) && (iVar7 = 0, (byte)(param_1[8] - 0x24) < 0x3c)) &&
|
|
(iVar7 = 0, (0x800000000000401U >> ((ulong)(param_1[8] - 0x24) & 0x3f) & 1) != 0)) &&
|
|
((bVar1 = param_1[9], bVar1 == 0x44 || (bVar1 == 0x49)))) &&
|
|
(iVar7 = 0, param_1[10] == 0x5f)) {
|
|
iVar7 = (bVar1 != 0x49) + 2;
|
|
}
|
|
}
|
|
puStack_240 = (undefined *)0x1a9378;
|
|
local_220 = param_2;
|
|
sVar8 = strlen((char *)param_1);
|
|
bVar17 = false;
|
|
local_210 = param_1 + sVar8;
|
|
local_1dc = (int)sVar8;
|
|
local_1ec = local_1dc * 2;
|
|
local_208 = 0x11;
|
|
local_1f0 = 0;
|
|
local_1e0 = 0;
|
|
local_1d8 = 0;
|
|
local_1d0 = 0;
|
|
local_1c8 = 0;
|
|
local_218 = param_1;
|
|
local_200 = param_1;
|
|
if (0x800 < local_1ec) goto LAB_001a963e;
|
|
lVar11 = (long)(int)local_1ec * -0x18;
|
|
uVar10 = (long)&local_238 + lVar11 + 7;
|
|
lVar2 = -((long)local_1dc * 8 + 0xfU & 0xfffffffffffffff0);
|
|
local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
local_1f8 = uVar10 & 0xfffffffffffffff8;
|
|
if (iVar7 == 1) {
|
|
local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
if ((bVar6 == 0x5f) &&
|
|
(local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11), param_1[1] == 0x5a)) {
|
|
local_200 = param_1 + 2;
|
|
local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a9747;
|
|
lVar9 = d_encoding(&local_218,1);
|
|
if ((local_208 & 1) == 0) {
|
|
bVar6 = *local_200;
|
|
}
|
|
else {
|
|
while (bVar6 = *local_200, bVar6 == 0x2e) {
|
|
bVar1 = local_200[1];
|
|
if (((byte)(bVar1 + 0x9f) < 0x1a) || (bVar1 == 0x5f)) {
|
|
bVar6 = local_200[2];
|
|
pbVar13 = local_200 + 2;
|
|
if (0x19 < (byte)(bVar6 + 0x9f)) goto LAB_001a9899;
|
|
do {
|
|
do {
|
|
bVar6 = pbVar13[1];
|
|
pbVar13 = pbVar13 + 1;
|
|
} while ((byte)(bVar6 + 0x9f) < 0x1a);
|
|
LAB_001a9899:
|
|
} while (bVar6 == 0x5f);
|
|
}
|
|
else {
|
|
bVar6 = *local_200;
|
|
pbVar13 = local_200;
|
|
if (9 < (byte)(bVar1 - 0x30)) break;
|
|
}
|
|
while ((bVar6 == 0x2e && ((byte)(pbVar13[1] - 0x30) < 10))) {
|
|
bVar6 = pbVar13[2];
|
|
pbVar13 = pbVar13 + 2;
|
|
while ((byte)(bVar6 - 0x30) < 10) {
|
|
pbVar14 = pbVar13 + 1;
|
|
pbVar13 = pbVar13 + 1;
|
|
bVar6 = *pbVar14;
|
|
}
|
|
}
|
|
iVar7 = (int)pbVar13 - (int)local_200;
|
|
if (local_1f0 < (int)local_1ec) {
|
|
lVar12 = (long)local_1f0;
|
|
local_1f0 = local_1f0 + 1;
|
|
puVar15 = (undefined8 *)(local_1f8 + lVar12 * 0x18);
|
|
*(undefined4 *)((long)puVar15 + 4) = 0;
|
|
if (iVar7 < 1) goto LAB_001a9868;
|
|
*puVar15 = 0;
|
|
puVar15[1] = local_200;
|
|
*(int *)(puVar15 + 2) = iVar7;
|
|
}
|
|
else {
|
|
LAB_001a9868:
|
|
puVar15 = (undefined8 *)0x0;
|
|
}
|
|
local_200 = pbVar13;
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a97e5;
|
|
lVar9 = d_make_comp(&local_218,0x4e,lVar9,puVar15);
|
|
}
|
|
}
|
|
goto LAB_001a950a;
|
|
}
|
|
}
|
|
else {
|
|
if (iVar7 - 2U < 2) {
|
|
pbVar13 = param_1 + 0xb;
|
|
if ((param_1[0xb] == 0x5f) && (param_1[0xc] == 0x5a)) {
|
|
local_200 = param_1 + 0xd;
|
|
local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a96a8;
|
|
uVar10 = d_encoding(&local_218,0);
|
|
}
|
|
else {
|
|
local_200 = pbVar13;
|
|
puVar5 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
if (0 < (int)local_1ec) {
|
|
local_238 = uVar10 >> 3;
|
|
local_230 = local_1f8;
|
|
local_228 = pbVar13;
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a947f;
|
|
sVar8 = strlen((char *)pbVar13);
|
|
local_1f0 = 1;
|
|
*(undefined4 *)(local_238 * 8 + 4) = 0;
|
|
puVar5 = local_1e8;
|
|
if (0 < (int)sVar8) {
|
|
*(byte **)(local_238 * 8 + 8) = local_228;
|
|
*(undefined4 *)(local_238 * 8) = 0;
|
|
*(int *)(local_238 * 8 + 0x10) = (int)sVar8;
|
|
uVar10 = local_230;
|
|
goto LAB_001a94d2;
|
|
}
|
|
}
|
|
local_1e8 = puVar5;
|
|
uVar10 = 0;
|
|
}
|
|
LAB_001a94d2:
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a94e9;
|
|
lVar9 = d_make_comp(&local_218,(iVar7 != 2) + 'D',uVar10,0);
|
|
pbVar13 = local_200;
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a94fb;
|
|
sVar8 = strlen((char *)pbVar13);
|
|
local_200 = pbVar13 + sVar8;
|
|
bVar6 = *local_200;
|
|
}
|
|
else {
|
|
local_1e8 = (undefined1 *)((long)&local_238 + lVar2 + lVar11);
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a96cc;
|
|
lVar9 = d_type(&local_218);
|
|
bVar6 = *local_200;
|
|
}
|
|
LAB_001a950a:
|
|
if ((bVar6 == 0) && (lVar9 != 0)) {
|
|
local_b8 = 0;
|
|
local_b0 = 0;
|
|
local_a8 = local_220;
|
|
local_98 = 0;
|
|
local_90 = 0;
|
|
local_88 = 0;
|
|
local_80 = 0;
|
|
local_78 = 0;
|
|
local_70 = 0;
|
|
local_68 = (undefined1 *)0x0;
|
|
local_60 = 0;
|
|
local_58 = (undefined1 *)0x0;
|
|
local_50 = 0;
|
|
local_a0 = param_3;
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a95aa;
|
|
d_count_templates_scopes(local_1b8,lVar9);
|
|
if (local_88._4_4_ < 0x800) {
|
|
local_88 = local_88 & 0xffffffff;
|
|
}
|
|
lVar12 = (long)local_60._4_4_;
|
|
local_48 = 0;
|
|
iVar7 = local_50._4_4_ * local_60._4_4_;
|
|
if (local_60._4_4_ < 1) {
|
|
lVar12 = 1;
|
|
}
|
|
local_50 = CONCAT44(iVar7,(undefined4)local_50);
|
|
lVar12 = lVar12 * -0x10;
|
|
local_68 = (undefined1 *)((long)&local_238 + lVar12 + lVar2 + lVar11);
|
|
if (iVar7 < 1) {
|
|
iVar7 = 1;
|
|
}
|
|
local_58 = (undefined1 *)((long)&local_238 + (long)iVar7 * -0x10 + lVar12 + lVar2 + lVar11);
|
|
*(undefined8 *)((long)&puStack_240 + (long)iVar7 * -0x10 + lVar12 + lVar2 + lVar11) = 0x1a960d
|
|
;
|
|
d_print_comp(local_1b8,0x11,lVar9);
|
|
uVar4 = local_a0;
|
|
lVar9 = local_b8;
|
|
local_1b8[local_b8] = 0;
|
|
pcVar3 = local_a8;
|
|
*(undefined8 *)((long)&puStack_240 + lVar2 + lVar11) = 0x1a962f;
|
|
(*pcVar3)(local_1b8,lVar9,uVar4);
|
|
bVar17 = (int)local_88 == 0;
|
|
goto LAB_001a963e;
|
|
}
|
|
}
|
|
bVar17 = false;
|
|
LAB_001a963e:
|
|
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
|
|
/* WARNING: Subroutine does not return */
|
|
puStack_240 = &UNK_001a98a7;
|
|
__stack_chk_fail();
|
|
}
|
|
return bVar17;
|
|
}
|
|
|
|
|
|
// 001a98b0 __cxa_demangle
|
|
|
|
char * __cxa_demangle(long param_1,char *param_2,ulong *param_3,undefined4 *param_4)
|
|
|
|
{
|
|
int iVar1;
|
|
size_t sVar2;
|
|
char *__src;
|
|
ulong uVar3;
|
|
char *local_48;
|
|
undefined8 local_40;
|
|
ulong local_38;
|
|
int local_30;
|
|
|
|
if ((param_1 == 0) || ((param_2 != (char *)0x0 && (param_3 == (ulong *)0x0)))) {
|
|
if (param_4 != (undefined4 *)0x0) {
|
|
*param_4 = 0xfffffffd;
|
|
}
|
|
return (char *)0x0;
|
|
}
|
|
local_48 = (char *)0x0;
|
|
local_40 = 0;
|
|
local_38 = 0;
|
|
local_30 = 0;
|
|
iVar1 = d_demangle_callback_constprop_0(param_1,d_growable_string_callback_adapter,&local_48);
|
|
__src = local_48;
|
|
if (iVar1 == 0) {
|
|
free(local_48);
|
|
if (param_4 == (undefined4 *)0x0) {
|
|
return (char *)0x0;
|
|
}
|
|
LAB_001a99ee:
|
|
*param_4 = 0xfffffffe;
|
|
return (char *)0x0;
|
|
}
|
|
if (local_30 == 0) {
|
|
uVar3 = local_38;
|
|
if (local_48 == (char *)0x0) {
|
|
if (param_4 == (undefined4 *)0x0) {
|
|
return (char *)0x0;
|
|
}
|
|
if (local_38 != 1) goto LAB_001a99ee;
|
|
goto LAB_001a9995;
|
|
}
|
|
}
|
|
else {
|
|
uVar3 = 1;
|
|
if (local_48 == (char *)0x0) {
|
|
if (param_4 == (undefined4 *)0x0) {
|
|
return (char *)0x0;
|
|
}
|
|
LAB_001a9995:
|
|
*param_4 = 0xffffffff;
|
|
return (char *)0x0;
|
|
}
|
|
}
|
|
if (param_2 == (char *)0x0) {
|
|
if (param_3 == (ulong *)0x0) goto LAB_001a9961;
|
|
}
|
|
else {
|
|
sVar2 = strlen(local_48);
|
|
if (sVar2 < *param_3) {
|
|
memcpy(param_2,__src,sVar2 + 1);
|
|
free(__src);
|
|
__src = param_2;
|
|
goto LAB_001a9961;
|
|
}
|
|
free(param_2);
|
|
}
|
|
*param_3 = uVar3;
|
|
LAB_001a9961:
|
|
if (param_4 != (undefined4 *)0x0) {
|
|
*param_4 = 0;
|
|
}
|
|
return __src;
|
|
}
|
|
|
|
|
|
// 001a9a10 __gcclibcxx_demangle_callback
|
|
|
|
uint __gcclibcxx_demangle_callback(long param_1,long param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
if ((param_1 != 0) && (param_2 != 0)) {
|
|
iVar1 = d_demangle_callback_constprop_0();
|
|
return -(uint)(iVar1 == 0) & 0xfffffffe;
|
|
}
|
|
return 0xfffffffd;
|
|
}
|
|
|
|
|
|
// 001a9a40 __dynamic_cast
|
|
|
|
long __dynamic_cast(long *param_1,undefined8 param_2,long *param_3,long param_4)
|
|
|
|
{
|
|
long *plVar1;
|
|
uint uVar2;
|
|
long *plVar3;
|
|
long local_48;
|
|
undefined8 local_40;
|
|
undefined8 local_38;
|
|
|
|
plVar3 = (long *)(*(long *)(*param_1 + -0x10) + (long)param_1);
|
|
plVar1 = *(long **)(*param_1 + -8);
|
|
local_48 = 0;
|
|
local_38 = 0x1000000000;
|
|
local_40 = 0;
|
|
if ((*(long **)(*plVar3 + -8) == plVar1) &&
|
|
((**(code **)(*plVar1 + 0x38))(plVar1,param_4,6,param_3,plVar3,param_2,param_1,&local_48),
|
|
local_48 != 0)) {
|
|
if (((uint)local_38 & 6) == 6) {
|
|
return local_48;
|
|
}
|
|
if (((uint)local_40 & local_40._4_4_ & 6) == 6) {
|
|
return local_48;
|
|
}
|
|
if (((local_40._4_4_ & 5) != 4) && ((uint)local_38 == 0)) {
|
|
if (param_4 < 0) {
|
|
if ((param_4 != -2) &&
|
|
(uVar2 = (**(code **)(*param_3 + 0x40))(param_3,param_4,local_48,param_2,param_1),
|
|
(uVar2 & 6) == 6)) {
|
|
return local_48;
|
|
}
|
|
}
|
|
else if (param_1 == (long *)(param_4 + local_48)) {
|
|
return local_48;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001a9b40 __cxa_call_terminate
|
|
|
|
void __cxa_call_terminate(long *param_1)
|
|
|
|
{
|
|
if (param_1 != (long *)0x0) {
|
|
__cxa_begin_catch();
|
|
if (*param_1 + 0xb8b1aabcbcd4d500U < 2) {
|
|
/* WARNING: Subroutine does not return */
|
|
__cxxabiv1::__terminate((_func_void *)param_1[-7]);
|
|
}
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
std::terminate();
|
|
}
|
|
|
|
|
|
// 001a9b80 __cxa_current_exception_type
|
|
|
|
long __cxa_current_exception_type(void)
|
|
|
|
{
|
|
long *plVar1;
|
|
long lVar2;
|
|
|
|
plVar1 = (long *)__cxa_get_globals();
|
|
plVar1 = (long *)*plVar1;
|
|
lVar2 = 0;
|
|
if ((plVar1 != (long *)0x0) && (lVar2 = *plVar1, (plVar1[10] & 1U) != 0)) {
|
|
lVar2 = *(long *)(lVar2 + -0x70);
|
|
}
|
|
return lVar2;
|
|
}
|
|
|
|
|
|
// 001a9c10 operator.new[]
|
|
|
|
/* operator new[](unsigned long, std::nothrow_t const&) */
|
|
|
|
void * operator_new__(ulong param_1,nothrow_t *param_2)
|
|
|
|
{
|
|
void *pvVar1;
|
|
|
|
pvVar1 = operator_new__(param_1);
|
|
return pvVar1;
|
|
}
|
|
|
|
|
|
// 001ac518 FUN_001ac518
|
|
|
|
void FUN_001ac518(void)
|
|
|
|
{
|
|
long in_RCX;
|
|
wios *pwVar1;
|
|
long *unaff_R12;
|
|
|
|
if (in_RCX == 0) {
|
|
pwVar1 = (wios *)(*(long *)(*unaff_R12 + -0x18) + (long)unaff_R12);
|
|
std::wios::clear(pwVar1,(pwVar1->data).offset_0x18 | 4);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001aea30 _txnal_cow_string_D1_commit
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x001aea70) */
|
|
/* _txnal_cow_string_D1_commit(void*) */
|
|
|
|
void _txnal_cow_string_D1_commit(void *param_1)
|
|
|
|
{
|
|
int *piVar1;
|
|
int iVar2;
|
|
|
|
if (param_1 != &std::string::_Rep::_S_empty_rep_storage) {
|
|
LOCK();
|
|
piVar1 = (int *)((long)param_1 + 0x10);
|
|
iVar2 = *piVar1;
|
|
*piVar1 = *piVar1 + -1;
|
|
UNLOCK();
|
|
if (iVar2 < 1) {
|
|
std::string::_Rep::_M_destroy(param_1);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001aedc0 _txnal_cow_string_C1_for_exceptions
|
|
|
|
/* _txnal_cow_string_C1_for_exceptions(void*, char const*, void*) */
|
|
|
|
void _txnal_cow_string_C1_for_exceptions(void *param_1,char *param_2,void *param_3)
|
|
|
|
{
|
|
char cVar1;
|
|
long *plVar2;
|
|
long lVar3;
|
|
|
|
lVar3 = 1;
|
|
while( true ) {
|
|
cVar1 = _ITM_RU1(param_2 + lVar3 + -1);
|
|
if (cVar1 == '\0') break;
|
|
lVar3 = lVar3 + 1;
|
|
}
|
|
plVar2 = (long *)new__(lVar3 + 0x18);
|
|
*(undefined4 *)(plVar2 + 2) = 0;
|
|
plVar2[1] = lVar3 + -1;
|
|
*plVar2 = lVar3 + -1;
|
|
_ITM_memcpyRtWn(plVar2 + 3,param_2,lVar3);
|
|
*(long **)param_1 = plVar2 + 3;
|
|
return;
|
|
}
|
|
|
|
|
|
// 001aee40 _txnal_cow_string_c_str
|
|
|
|
/* _txnal_cow_string_c_str(void const*) */
|
|
|
|
void _txnal_cow_string_c_str(void *param_1)
|
|
|
|
{
|
|
_ITM_RU8();
|
|
return;
|
|
}
|
|
|
|
|
|
// 001aee50 _txnal_cow_string_D1
|
|
|
|
/* _txnal_cow_string_D1(void*) */
|
|
|
|
void _txnal_cow_string_D1(void *param_1)
|
|
|
|
{
|
|
long lVar1;
|
|
|
|
lVar1 = _txnal_cow_string_c_str(param_1);
|
|
_ITM_addUserCommitAction(_txnal_cow_string_D1_commit,1,lVar1 + -0x18);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001aee80 _txnal_logic_error_get_msg
|
|
|
|
/* _txnal_logic_error_get_msg(void*) */
|
|
|
|
long _txnal_logic_error_get_msg(void *param_1)
|
|
|
|
{
|
|
return (long)param_1 + 8;
|
|
}
|
|
|
|
|
|
// 001aee90 _txnal_runtime_error_get_msg
|
|
|
|
/* _txnal_runtime_error_get_msg(void*) */
|
|
|
|
long _txnal_runtime_error_get_msg(void *param_1)
|
|
|
|
{
|
|
return (long)param_1 + 8;
|
|
}
|
|
|
|
|
|
// 001af9c0 read_encoded_value_with_base
|
|
|
|
ulong * read_encoded_value_with_base(byte param_1,ulong *param_2,ulong *param_3,undefined8 *param_4)
|
|
|
|
{
|
|
ulong uVar1;
|
|
undefined8 *puVar2;
|
|
ulong *puVar3;
|
|
byte bVar4;
|
|
byte bVar5;
|
|
uint uVar6;
|
|
byte *pbVar7;
|
|
ulong uVar8;
|
|
|
|
if (param_1 == 0x50) {
|
|
puVar2 = (undefined8 *)((ulong)((long)param_3 + 7U) & 0xfffffffffffffff8);
|
|
*param_4 = *puVar2;
|
|
return puVar2 + 1;
|
|
}
|
|
puVar3 = param_3;
|
|
switch(param_1 & 0xf) {
|
|
case 0:
|
|
case 4:
|
|
case 0xc:
|
|
uVar8 = *param_3;
|
|
puVar3 = param_3 + 1;
|
|
break;
|
|
case 1:
|
|
uVar8 = 0;
|
|
bVar4 = 0;
|
|
do {
|
|
uVar1 = *puVar3;
|
|
puVar3 = (ulong *)((long)puVar3 + 1);
|
|
bVar5 = bVar4 & 0x3f;
|
|
bVar4 = bVar4 + 7;
|
|
uVar8 = uVar8 | (ulong)((byte)uVar1 & 0x7f) << bVar5;
|
|
} while ((char)(byte)uVar1 < '\0');
|
|
break;
|
|
case 2:
|
|
uVar8 = (ulong)(ushort)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 2);
|
|
break;
|
|
case 3:
|
|
uVar8 = (ulong)(uint)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 4);
|
|
break;
|
|
default:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
case 9:
|
|
uVar8 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar4 = (byte)*puVar3;
|
|
puVar3 = (ulong *)((long)puVar3 + 1);
|
|
bVar5 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar8 = uVar8 | (ulong)(bVar4 & 0x7f) << (bVar5 & 0x3f);
|
|
} while ((char)bVar4 < '\0');
|
|
if ((0x3f < uVar6) || ((bVar4 & 0x40) == 0)) break;
|
|
uVar8 = uVar8 | -1L << ((byte)uVar6 & 0x3f);
|
|
goto LAB_001af9fc;
|
|
case 10:
|
|
uVar8 = (ulong)(short)(ushort)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 2);
|
|
break;
|
|
case 0xb:
|
|
uVar8 = (ulong)(int)(uint)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 4);
|
|
}
|
|
pbVar7 = (byte *)0x0;
|
|
if (uVar8 != 0) {
|
|
LAB_001af9fc:
|
|
if ((param_1 & 0x70) == 0x10) {
|
|
param_2 = param_3;
|
|
}
|
|
pbVar7 = (byte *)(uVar8 + (long)param_2);
|
|
if ((char)param_1 < '\0') {
|
|
*param_4 = *(undefined8 *)pbVar7;
|
|
return puVar3;
|
|
}
|
|
}
|
|
*param_4 = pbVar7;
|
|
return puVar3;
|
|
}
|
|
|
|
|
|
// 001afb10 base_of_encoded_value
|
|
|
|
undefined8 base_of_encoded_value(byte param_1,long param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
|
|
if (param_1 == 0xff) {
|
|
return 0;
|
|
}
|
|
bVar1 = param_1 & 0x70;
|
|
if (bVar1 == 0x30) {
|
|
return *(undefined8 *)(param_2 + 0xb0);
|
|
}
|
|
if (bVar1 < 0x31) {
|
|
if (bVar1 == 0x20) {
|
|
return *(undefined8 *)(param_2 + 0xa8);
|
|
}
|
|
if ((0x20 < bVar1) || ((param_1 & 0x60) != 0)) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
}
|
|
else {
|
|
if (bVar1 == 0x40) {
|
|
return *(undefined8 *)(param_2 + 0xb8);
|
|
}
|
|
if (bVar1 != 0x50) {
|
|
/* WARNING: Subroutine does not return */
|
|
base_of_encoded_value_cold();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001afba0 execute_cfa_program
|
|
|
|
void execute_cfa_program(byte *param_1,byte *param_2,long param_3,undefined8 *param_4)
|
|
|
|
{
|
|
byte bVar1;
|
|
byte bVar2;
|
|
undefined8 uVar3;
|
|
undefined8 *puVar4;
|
|
byte bVar5;
|
|
uint uVar6;
|
|
long lVar7;
|
|
byte bVar8;
|
|
undefined8 **ppuVar9;
|
|
undefined1 *puVar10;
|
|
undefined8 *puVar11;
|
|
ulong uVar12;
|
|
undefined8 *puVar13;
|
|
undefined8 *puVar14;
|
|
ulong uVar15;
|
|
byte *pbVar16;
|
|
byte bVar17;
|
|
undefined8 *local_58;
|
|
uint local_4c;
|
|
undefined8 local_40 [2];
|
|
|
|
bVar17 = 0;
|
|
param_4[0x24] = 0;
|
|
if (param_2 <= param_1) {
|
|
return;
|
|
}
|
|
puVar14 = (undefined8 *)0x0;
|
|
ppuVar9 = &local_58;
|
|
LAB_001afbe0:
|
|
do {
|
|
uVar15 = param_4[0x29];
|
|
if ((ulong)(*(long *)(param_3 + 0x98) - (*(long *)(param_3 + 0xc0) >> 0x3f)) <= uVar15) {
|
|
return;
|
|
}
|
|
bVar5 = *param_1;
|
|
pbVar16 = param_1 + 1;
|
|
bVar8 = bVar5 & 0xc0;
|
|
if (bVar8 == 0x40) {
|
|
param_4[0x29] = (ulong)(bVar5 & 0x3f) * param_4[0x2c] + uVar15;
|
|
goto switchD_001afc38_caseD_0;
|
|
}
|
|
if (bVar8 == 0x80) {
|
|
uVar15 = 0;
|
|
bVar8 = 0;
|
|
do {
|
|
bVar1 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar2 = bVar8 & 0x3f;
|
|
bVar8 = bVar8 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar1 & 0x7f) << bVar2;
|
|
} while ((char)bVar1 < '\0');
|
|
lVar7 = param_4[0x2b];
|
|
if ((bVar5 & 0x3f) < 0x12) {
|
|
*(undefined4 *)(param_4 + (ulong)(bVar5 & 0x3f) * 2 + 1) = 1;
|
|
param_4[(ulong)(bVar5 & 0x3f) * 2] = uVar15 * lVar7;
|
|
}
|
|
goto switchD_001afc38_caseD_0;
|
|
}
|
|
if (bVar8 == 0xc0) {
|
|
uVar15 = (ulong)(bVar5 & 0x3f);
|
|
if (0x11 < (bVar5 & 0x3f)) goto switchD_001afc38_caseD_0;
|
|
goto LAB_001b0219;
|
|
}
|
|
switch(bVar5) {
|
|
case 0:
|
|
case 0x2d:
|
|
break;
|
|
case 1:
|
|
bVar5 = *(byte *)(param_4 + 0x2e);
|
|
local_4c = (uint)bVar5;
|
|
*(undefined8 *)((long)ppuVar9 + -8) = 0x1b02da;
|
|
local_58 = puVar14;
|
|
uVar3 = base_of_encoded_value(bVar5,param_3);
|
|
*(undefined8 *)((long)ppuVar9 + -8) = 0x1b02ec;
|
|
pbVar16 = (byte *)read_encoded_value_with_base(local_4c,uVar3,pbVar16,local_40);
|
|
param_4[0x29] = local_40[0];
|
|
puVar14 = local_58;
|
|
break;
|
|
case 2:
|
|
param_4[0x29] = (ulong)param_1[1] * param_4[0x2c] + uVar15;
|
|
pbVar16 = param_1 + 2;
|
|
break;
|
|
case 3:
|
|
param_4[0x29] = (ulong)*(ushort *)(param_1 + 1) * param_4[0x2c] + uVar15;
|
|
pbVar16 = param_1 + 3;
|
|
break;
|
|
case 4:
|
|
param_4[0x29] = (ulong)*(uint *)(param_1 + 1) * param_4[0x2c] + uVar15;
|
|
pbVar16 = param_1 + 5;
|
|
break;
|
|
case 5:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
goto LAB_001aff40;
|
|
case 6:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
goto joined_r0x001b0122;
|
|
case 7:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 6;
|
|
}
|
|
break;
|
|
case 8:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
joined_r0x001b0122:
|
|
if (uVar15 < 0x12) {
|
|
LAB_001b0219:
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 0;
|
|
}
|
|
break;
|
|
case 9:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 2;
|
|
param_4[uVar15 * 2] = uVar12;
|
|
}
|
|
break;
|
|
case 10:
|
|
if (puVar14 == (undefined8 *)0x0) {
|
|
puVar10 = (undefined1 *)((long)ppuVar9 + -0x150);
|
|
puVar4 = (undefined8 *)((ulong)((long)ppuVar9 + -0x141) & 0xfffffffffffffff0);
|
|
}
|
|
else {
|
|
puVar4 = puVar14;
|
|
puVar10 = (undefined1 *)ppuVar9;
|
|
puVar14 = (undefined8 *)puVar14[0x24];
|
|
}
|
|
puVar11 = param_4;
|
|
puVar13 = puVar4;
|
|
for (lVar7 = 0x29; lVar7 != 0; lVar7 = lVar7 + -1) {
|
|
*puVar13 = *puVar11;
|
|
puVar11 = puVar11 + (ulong)bVar17 * -2 + 1;
|
|
puVar13 = puVar13 + (ulong)bVar17 * -2 + 1;
|
|
}
|
|
param_4[0x24] = puVar4;
|
|
ppuVar9 = (undefined8 **)puVar10;
|
|
break;
|
|
case 0xb:
|
|
puVar4 = (undefined8 *)param_4[0x24];
|
|
puVar11 = puVar4;
|
|
puVar13 = param_4;
|
|
for (lVar7 = 0x29; lVar7 != 0; lVar7 = lVar7 + -1) {
|
|
*puVar13 = *puVar11;
|
|
puVar11 = puVar11 + (ulong)bVar17 * -2 + 1;
|
|
puVar13 = puVar13 + (ulong)bVar17 * -2 + 1;
|
|
}
|
|
puVar4[0x24] = puVar14;
|
|
puVar14 = puVar4;
|
|
break;
|
|
case 0xc:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
param_4[0x26] = uVar15;
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
param_4[0x25] = uVar15;
|
|
*(undefined4 *)(param_4 + 0x28) = 1;
|
|
break;
|
|
case 0xd:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
param_4[0x26] = uVar15;
|
|
*(undefined4 *)(param_4 + 0x28) = 1;
|
|
break;
|
|
case 0xe:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
param_4[0x25] = uVar15;
|
|
break;
|
|
case 0xf:
|
|
param_4[0x27] = pbVar16;
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
*(undefined4 *)(param_4 + 0x28) = 2;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
pbVar16 = pbVar16 + uVar15;
|
|
break;
|
|
case 0x10:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 3;
|
|
param_4[uVar15 * 2] = pbVar16;
|
|
}
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
pbVar16 = pbVar16 + uVar15;
|
|
break;
|
|
case 0x11:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar5 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar8 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar5 & 0x7f) << (bVar8 & 0x3f);
|
|
} while ((char)bVar5 < '\0');
|
|
if ((uVar6 < 0x40) && ((bVar5 & 0x40) != 0)) {
|
|
uVar12 = uVar12 | -1L << ((byte)uVar6 & 0x3f);
|
|
}
|
|
LAB_001aff40:
|
|
lVar7 = param_4[0x2b];
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 1;
|
|
param_4[uVar15 * 2] = uVar12 * lVar7;
|
|
}
|
|
break;
|
|
case 0x12:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
param_4[0x26] = uVar15;
|
|
uVar15 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar5 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar8 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar5 & 0x7f) << (bVar8 & 0x3f);
|
|
} while ((char)bVar5 < '\0');
|
|
if ((uVar6 < 0x40) && ((bVar5 & 0x40) != 0)) {
|
|
uVar15 = uVar15 | -1L << ((byte)uVar6 & 0x3f);
|
|
}
|
|
*(undefined4 *)(param_4 + 0x28) = 1;
|
|
param_4[0x25] = uVar15 * param_4[0x2b];
|
|
break;
|
|
case 0x13:
|
|
uVar15 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar5 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar8 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar5 & 0x7f) << (bVar8 & 0x3f);
|
|
} while ((char)bVar5 < '\0');
|
|
if ((uVar6 < 0x40) && ((bVar5 & 0x40) != 0)) {
|
|
uVar15 = uVar15 | -1L << ((byte)uVar6 & 0x3f);
|
|
}
|
|
param_4[0x25] = uVar15 * param_4[0x2b];
|
|
break;
|
|
case 0x14:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
goto LAB_001afda8;
|
|
case 0x15:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar5 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar8 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar5 & 0x7f) << (bVar8 & 0x3f);
|
|
} while ((char)bVar5 < '\0');
|
|
if ((uVar6 < 0x40) && ((bVar5 & 0x40) != 0)) {
|
|
uVar12 = uVar12 | -1L << ((byte)uVar6 & 0x3f);
|
|
}
|
|
LAB_001afda8:
|
|
lVar7 = param_4[0x2b];
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 4;
|
|
param_4[uVar15 * 2] = uVar12 * lVar7;
|
|
}
|
|
break;
|
|
case 0x16:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 5;
|
|
param_4[uVar15 * 2] = pbVar16;
|
|
}
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
pbVar16 = pbVar16 + uVar15;
|
|
break;
|
|
default:
|
|
/* WARNING: Subroutine does not return */
|
|
*(code **)((long)ppuVar9 + -8) = uw_frame_state_for_cold;
|
|
abort();
|
|
case 0x2e:
|
|
goto switchD_001afc38_caseD_2e;
|
|
case 0x2f:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
uVar12 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar8 = *pbVar16;
|
|
pbVar16 = pbVar16 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar12 = uVar12 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
lVar7 = param_4[0x2b];
|
|
if (uVar15 < 0x12) {
|
|
*(undefined4 *)(param_4 + uVar15 * 2 + 1) = 1;
|
|
param_4[uVar15 * 2] = -(uVar12 * lVar7);
|
|
}
|
|
}
|
|
switchD_001afc38_caseD_0:
|
|
param_1 = pbVar16;
|
|
if (param_2 <= param_1) {
|
|
return;
|
|
}
|
|
} while( true );
|
|
switchD_001afc38_caseD_2e:
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
param_1 = pbVar16;
|
|
do {
|
|
bVar8 = *param_1;
|
|
param_1 = param_1 + 1;
|
|
bVar1 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar8 & 0x7f) << bVar1;
|
|
} while ((char)bVar8 < '\0');
|
|
*(ulong *)(param_3 + 0xd0) = uVar15;
|
|
if (param_2 <= param_1) {
|
|
return;
|
|
}
|
|
goto LAB_001afbe0;
|
|
}
|
|
|
|
|
|
// 001b03f0 init_dwarf_reg_size_table
|
|
|
|
void init_dwarf_reg_size_table(void)
|
|
|
|
{
|
|
dwarf_reg_size_table = 8;
|
|
DAT_001f9751 = 8;
|
|
DAT_001f9752 = 8;
|
|
DAT_001f9753 = 8;
|
|
DAT_001f9754 = 8;
|
|
DAT_001f9755 = 8;
|
|
DAT_001f9756 = 8;
|
|
DAT_001f9757 = 8;
|
|
DAT_001f9758 = 8;
|
|
DAT_001f9759 = 8;
|
|
DAT_001f975a = 8;
|
|
DAT_001f975b = 8;
|
|
DAT_001f975c = 8;
|
|
DAT_001f975d = 8;
|
|
DAT_001f975e = 8;
|
|
DAT_001f975f = 8;
|
|
DAT_001f9760 = 8;
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b0470 uw_frame_state_for
|
|
|
|
undefined8 uw_frame_state_for(long param_1,long *param_2)
|
|
|
|
{
|
|
long lVar1;
|
|
byte bVar2;
|
|
uint uVar3;
|
|
char cVar4;
|
|
byte bVar5;
|
|
uint *puVar6;
|
|
size_t sVar7;
|
|
byte *pbVar8;
|
|
undefined8 uVar9;
|
|
byte bVar10;
|
|
uint uVar11;
|
|
long lVar12;
|
|
byte *pbVar13;
|
|
long *plVar14;
|
|
ulong uVar15;
|
|
uint *puVar16;
|
|
byte *pbVar17;
|
|
byte *pbVar18;
|
|
char *pcVar19;
|
|
long local_40 [2];
|
|
|
|
plVar14 = param_2;
|
|
for (lVar12 = 0x30; lVar12 != 0; lVar12 = lVar12 + -1) {
|
|
*plVar14 = 0;
|
|
plVar14 = plVar14 + 1;
|
|
}
|
|
*(undefined8 *)(param_1 + 0xd0) = 0;
|
|
*(undefined8 *)(param_1 + 0xa0) = 0;
|
|
if (*(long *)(param_1 + 0x98) == 0) {
|
|
return 5;
|
|
}
|
|
puVar6 = (uint *)_Unwind_Find_FDE((*(long *)(param_1 + 0x98) + -1) -
|
|
(*(long *)(param_1 + 0xc0) >> 0x3f),param_1 + 0xa8);
|
|
if (puVar6 == (uint *)0x0) {
|
|
if (**(char **)(param_1 + 0x98) != 'H') {
|
|
return 5;
|
|
}
|
|
if (*(long *)(*(char **)(param_1 + 0x98) + 1) == 0x50f0000000fc0c7) {
|
|
lVar12 = *(long *)(param_1 + 0x90);
|
|
lVar1 = *(long *)(lVar12 + 0xa0);
|
|
*(undefined4 *)(param_2 + 0x28) = 1;
|
|
param_2[0x26] = 7;
|
|
*(undefined4 *)(param_2 + 1) = 1;
|
|
*param_2 = (lVar12 + 0x90) - lVar1;
|
|
param_2[0x25] = lVar1 - lVar12;
|
|
param_2[2] = (lVar12 + 0x88) - lVar1;
|
|
param_2[0x10] = (lVar12 + 0x28) - lVar1;
|
|
param_2[4] = (lVar12 + 0x98) - lVar1;
|
|
param_2[0x12] = (lVar12 + 0x30) - lVar1;
|
|
param_2[6] = (lVar12 + 0x80) - lVar1;
|
|
param_2[0x14] = (lVar12 + 0x38) - lVar1;
|
|
param_2[8] = (lVar12 + 0x70) - lVar1;
|
|
param_2[0x16] = (lVar12 + 0x40) - lVar1;
|
|
param_2[10] = (lVar12 + 0x68) - lVar1;
|
|
param_2[0x18] = (lVar12 + 0x48) - lVar1;
|
|
*(undefined4 *)(param_2 + 3) = 1;
|
|
param_2[0x1a] = (lVar12 + 0x50) - lVar1;
|
|
*(undefined4 *)(param_2 + 5) = 1;
|
|
*(undefined4 *)(param_2 + 7) = 1;
|
|
*(undefined4 *)(param_2 + 9) = 1;
|
|
*(undefined4 *)(param_2 + 0xb) = 1;
|
|
*(undefined4 *)(param_2 + 0xd) = 1;
|
|
param_2[0xc] = (lVar12 + 0x78) - lVar1;
|
|
*(undefined4 *)(param_2 + 0x11) = 1;
|
|
*(undefined4 *)(param_2 + 0x13) = 1;
|
|
*(undefined4 *)(param_2 + 0x15) = 1;
|
|
*(undefined4 *)(param_2 + 0x17) = 1;
|
|
*(undefined4 *)(param_2 + 0x19) = 1;
|
|
*(undefined4 *)(param_2 + 0x1b) = 1;
|
|
*(undefined4 *)(param_2 + 0x1d) = 1;
|
|
param_2[0x1c] = (lVar12 + 0x58) - lVar1;
|
|
*(undefined4 *)(param_2 + 0x1f) = 1;
|
|
param_2[0x20] = (lVar12 + 0xa8) - lVar1;
|
|
param_2[0x1e] = (lVar12 + 0x60) - lVar1;
|
|
*(undefined4 *)(param_2 + 0x21) = 1;
|
|
param_2[0x2d] = 0x10;
|
|
*(undefined1 *)((long)param_2 + 0x173) = 1;
|
|
return 0;
|
|
}
|
|
return 5;
|
|
}
|
|
param_2[0x29] = *(long *)(param_1 + 0xb8);
|
|
puVar16 = (uint *)((long)puVar6 + (4 - (long)(int)puVar6[1]));
|
|
pcVar19 = (char *)((long)puVar16 + 9);
|
|
sVar7 = strlen(pcVar19);
|
|
pbVar13 = (byte *)((long)puVar16 + sVar7 + 10);
|
|
if ((*(char *)((long)puVar16 + 9) == 'e') && (*(char *)((long)puVar16 + 10) == 'h')) {
|
|
lVar12 = *(long *)pbVar13;
|
|
pcVar19 = (char *)((long)puVar16 + 0xb);
|
|
pbVar13 = pbVar13 + 8;
|
|
param_2[0x2f] = lVar12;
|
|
}
|
|
uVar3 = puVar16[2];
|
|
bVar5 = *pbVar13;
|
|
if (3 < (byte)uVar3) {
|
|
if (bVar5 != 8) {
|
|
return 3;
|
|
}
|
|
if (pbVar13[1] != 0) {
|
|
return 3;
|
|
}
|
|
bVar5 = pbVar13[2];
|
|
pbVar13 = pbVar13 + 2;
|
|
}
|
|
uVar15 = 0;
|
|
bVar10 = 0;
|
|
while( true ) {
|
|
pbVar13 = pbVar13 + 1;
|
|
bVar2 = bVar10 & 0x3f;
|
|
bVar10 = bVar10 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar5 & 0x7f) << bVar2;
|
|
if (-1 < (char)bVar5) break;
|
|
bVar5 = *pbVar13;
|
|
}
|
|
param_2[0x2c] = uVar15;
|
|
uVar11 = 0;
|
|
uVar15 = 0;
|
|
do {
|
|
pbVar8 = pbVar13;
|
|
bVar5 = *pbVar8;
|
|
pbVar13 = pbVar8 + 1;
|
|
bVar10 = (byte)uVar11;
|
|
uVar11 = uVar11 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar5 & 0x7f) << (bVar10 & 0x3f);
|
|
} while ((char)bVar5 < '\0');
|
|
if ((uVar11 < 0x40) && ((bVar5 & 0x40) != 0)) {
|
|
uVar15 = uVar15 | -1L << ((byte)uVar11 & 0x3f);
|
|
}
|
|
param_2[0x2b] = uVar15;
|
|
bVar5 = 0;
|
|
uVar15 = 0;
|
|
if ((byte)uVar3 == 1) {
|
|
bVar5 = *pbVar13;
|
|
pbVar13 = pbVar8 + 2;
|
|
param_2[0x2d] = (ulong)bVar5;
|
|
}
|
|
else {
|
|
do {
|
|
bVar10 = *pbVar13;
|
|
pbVar13 = pbVar13 + 1;
|
|
bVar2 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar10 & 0x7f) << bVar2;
|
|
} while ((char)bVar10 < '\0');
|
|
param_2[0x2d] = uVar15;
|
|
}
|
|
*(undefined1 *)((long)param_2 + 0x171) = 0xff;
|
|
cVar4 = *pcVar19;
|
|
pbVar18 = (byte *)0x0;
|
|
pbVar8 = pbVar13;
|
|
if (cVar4 == 'z') {
|
|
bVar5 = 0;
|
|
do {
|
|
bVar10 = *pbVar13;
|
|
pbVar13 = pbVar13 + 1;
|
|
bVar2 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
pbVar18 = (byte *)((ulong)pbVar18 | (ulong)(bVar10 & 0x7f) << bVar2);
|
|
} while ((char)bVar10 < '\0');
|
|
*(undefined1 *)((long)param_2 + 0x172) = 1;
|
|
cVar4 = pcVar19[1];
|
|
pbVar18 = pbVar18 + (long)pbVar13;
|
|
pcVar19 = pcVar19 + 1;
|
|
pbVar8 = pbVar18;
|
|
}
|
|
if (cVar4 != '\0') {
|
|
pcVar19 = pcVar19 + 1;
|
|
do {
|
|
while (cVar4 == 'L') {
|
|
bVar5 = *pbVar13;
|
|
pbVar13 = pbVar13 + 1;
|
|
*(byte *)((long)param_2 + 0x171) = bVar5;
|
|
cVar4 = *pcVar19;
|
|
pcVar19 = pcVar19 + 1;
|
|
if (cVar4 == '\0') goto LAB_001b064b;
|
|
}
|
|
if (cVar4 == 'R') {
|
|
bVar5 = *pbVar13;
|
|
pbVar13 = pbVar13 + 1;
|
|
*(byte *)(param_2 + 0x2e) = bVar5;
|
|
}
|
|
else if (cVar4 == 'P') {
|
|
bVar5 = *pbVar13;
|
|
uVar9 = base_of_encoded_value(bVar5,param_1);
|
|
pbVar13 = (byte *)read_encoded_value_with_base(bVar5,uVar9,pbVar13 + 1,local_40);
|
|
param_2[0x2a] = local_40[0];
|
|
}
|
|
else {
|
|
pbVar17 = pbVar18;
|
|
if (cVar4 != 'S') goto LAB_001b07f3;
|
|
*(undefined1 *)((long)param_2 + 0x173) = 1;
|
|
}
|
|
cVar4 = *pcVar19;
|
|
pcVar19 = pcVar19 + 1;
|
|
} while (cVar4 != '\0');
|
|
LAB_001b064b:
|
|
pbVar17 = pbVar13;
|
|
pbVar8 = pbVar18;
|
|
if (pbVar18 == (byte *)0x0) {
|
|
LAB_001b07f3:
|
|
pbVar8 = pbVar17;
|
|
if (pbVar17 == (byte *)0x0) {
|
|
return 3;
|
|
}
|
|
}
|
|
}
|
|
execute_cfa_program(pbVar8,(long)puVar16 + (ulong)*puVar16 + 4,param_1,param_2);
|
|
if (*(byte *)(param_2 + 0x2e) == 0xff) {
|
|
lVar12 = 8;
|
|
}
|
|
else {
|
|
bVar5 = *(byte *)(param_2 + 0x2e) & 7;
|
|
if (bVar5 == 2) {
|
|
lVar12 = 0xc;
|
|
}
|
|
else {
|
|
if (bVar5 < 3) {
|
|
if (bVar5 != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
uw_frame_state_for_cold();
|
|
}
|
|
}
|
|
else {
|
|
lVar12 = 0x10;
|
|
if (bVar5 == 3) goto LAB_001b0698;
|
|
if (bVar5 != 4) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
}
|
|
lVar12 = 0x18;
|
|
}
|
|
}
|
|
LAB_001b0698:
|
|
pbVar13 = (byte *)(lVar12 + (long)puVar6);
|
|
cVar4 = *(char *)((long)param_2 + 0x171);
|
|
if (*(char *)((long)param_2 + 0x172) == '\0') {
|
|
pbVar8 = pbVar13;
|
|
if (cVar4 != -1) {
|
|
uVar9 = base_of_encoded_value(cVar4,param_1);
|
|
pbVar8 = (byte *)read_encoded_value_with_base(cVar4,uVar9,pbVar13,local_40);
|
|
*(long *)(param_1 + 0xa0) = local_40[0];
|
|
}
|
|
}
|
|
else {
|
|
uVar15 = 0;
|
|
bVar5 = 0;
|
|
do {
|
|
bVar10 = *pbVar13;
|
|
pbVar13 = pbVar13 + 1;
|
|
bVar2 = bVar5 & 0x3f;
|
|
bVar5 = bVar5 + 7;
|
|
uVar15 = uVar15 | (ulong)(bVar10 & 0x7f) << bVar2;
|
|
} while ((char)bVar10 < '\0');
|
|
pbVar8 = pbVar13 + uVar15;
|
|
if (cVar4 != -1) {
|
|
uVar9 = base_of_encoded_value(cVar4,param_1);
|
|
read_encoded_value_with_base(cVar4,uVar9,pbVar13,local_40);
|
|
*(long *)(param_1 + 0xa0) = local_40[0];
|
|
}
|
|
}
|
|
execute_cfa_program(pbVar8,(long)puVar6 + (ulong)*puVar6 + 4,param_1,param_2);
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001b0b00 uw_install_context_1
|
|
|
|
long uw_install_context_1(long param_1,long param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
long lVar2;
|
|
undefined8 *puVar3;
|
|
ulong uVar4;
|
|
long lVar5;
|
|
undefined8 *puVar6;
|
|
undefined8 local_10 [2];
|
|
|
|
if ((((*(byte *)(param_2 + 199) & 0x40) == 0) || (*(char *)(param_2 + 0xdf) == '\0')) &&
|
|
(*(long *)(param_2 + 0x38) == 0)) {
|
|
if (DAT_001f9757 != '\b') goto uw_install_context_1_cold;
|
|
if ((*(byte *)(param_2 + 199) & 0x40) != 0) {
|
|
*(undefined1 *)(param_2 + 0xdf) = 0;
|
|
}
|
|
*(undefined8 **)(param_2 + 0x38) = local_10;
|
|
local_10[0] = *(undefined8 *)(param_2 + 0x90);
|
|
}
|
|
lVar2 = 0;
|
|
do {
|
|
while( true ) {
|
|
puVar3 = *(undefined8 **)(param_1 + lVar2 * 8);
|
|
puVar6 = *(undefined8 **)(param_2 + lVar2 * 8);
|
|
if (*(char *)(param_1 + 0xd8 + lVar2) != '\0') goto uw_install_context_1_cold;
|
|
if (*(char *)(param_2 + 0xd8 + lVar2) == '\0') break;
|
|
if (puVar3 != (undefined8 *)0x0) {
|
|
if ((&dwarf_reg_size_table)[lVar2] != '\b') goto uw_install_context_1_cold;
|
|
*puVar3 = puVar6;
|
|
}
|
|
LAB_001b0b4b:
|
|
lVar2 = lVar2 + 1;
|
|
if (lVar2 == 0x11) goto LAB_001b0bf8;
|
|
}
|
|
if ((puVar6 == (undefined8 *)0x0 || puVar3 == (undefined8 *)0x0) || (puVar3 == puVar6))
|
|
goto LAB_001b0b4b;
|
|
bVar1 = (&dwarf_reg_size_table)[lVar2];
|
|
uVar4 = (ulong)bVar1;
|
|
if (bVar1 < 8) {
|
|
if ((bVar1 & 4) == 0) {
|
|
if ((bVar1 != 0) && (*(undefined1 *)puVar3 = *(undefined1 *)puVar6, (bVar1 & 2) != 0)) {
|
|
*(undefined2 *)((long)puVar3 + (uVar4 - 2)) = *(undefined2 *)((long)puVar6 + (uVar4 - 2));
|
|
}
|
|
}
|
|
else {
|
|
*(undefined4 *)puVar3 = *(undefined4 *)puVar6;
|
|
*(undefined4 *)((long)puVar3 + (uVar4 - 4)) = *(undefined4 *)((long)puVar6 + (uVar4 - 4));
|
|
}
|
|
goto LAB_001b0b4b;
|
|
}
|
|
lVar2 = lVar2 + 1;
|
|
*puVar3 = *puVar6;
|
|
*(undefined8 *)((long)puVar3 + (uVar4 - 8)) = *(undefined8 *)((long)puVar6 + (uVar4 - 8));
|
|
lVar5 = (long)puVar3 - (long)((ulong)(puVar3 + 1) & 0xfffffffffffffff8);
|
|
puVar6 = (undefined8 *)((long)puVar6 - lVar5);
|
|
puVar3 = (undefined8 *)((ulong)(puVar3 + 1) & 0xfffffffffffffff8);
|
|
for (uVar4 = (ulong)((uint)bVar1 + (int)lVar5 >> 3); uVar4 != 0; uVar4 = uVar4 - 1) {
|
|
*puVar3 = *puVar6;
|
|
puVar6 = puVar6 + 1;
|
|
puVar3 = puVar3 + 1;
|
|
}
|
|
} while (lVar2 != 0x11);
|
|
LAB_001b0bf8:
|
|
lVar2 = 0;
|
|
if ((((*(byte *)(param_1 + 199) & 0x40) == 0) || (*(char *)(param_1 + 0xdf) == '\0')) &&
|
|
(*(long *)(param_1 + 0x38) == 0)) {
|
|
puVar3 = *(undefined8 **)(param_2 + 0x38);
|
|
if (((*(byte *)(param_2 + 199) & 0x40) == 0) || (*(char *)(param_2 + 0xdf) == '\0')) {
|
|
if (DAT_001f9757 != '\b') {
|
|
uw_install_context_1_cold:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
puVar3 = (undefined8 *)*puVar3;
|
|
}
|
|
lVar2 = (long)puVar3 + (*(long *)(param_2 + 0xd0) - *(long *)(param_1 + 0x90));
|
|
}
|
|
return lVar2;
|
|
}
|
|
|
|
|
|
// 001b0ca0 execute_stack_op
|
|
|
|
ulong execute_stack_op(byte *param_1,byte *param_2,long param_3,ulong param_4)
|
|
|
|
{
|
|
uint *puVar1;
|
|
byte bVar2;
|
|
undefined8 uVar3;
|
|
byte *pbVar4;
|
|
ulong uVar5;
|
|
byte bVar6;
|
|
byte bVar7;
|
|
uint uVar8;
|
|
uint uVar9;
|
|
long lVar10;
|
|
int iVar11;
|
|
int iVar12;
|
|
ulong uVar13;
|
|
byte *pbVar14;
|
|
byte *local_240;
|
|
ulong local_238 [65];
|
|
undefined8 *puVar15;
|
|
|
|
local_238[0] = param_4;
|
|
if (param_1 < param_2) {
|
|
iVar11 = 1;
|
|
do {
|
|
bVar6 = *param_1;
|
|
pbVar4 = param_1 + 1;
|
|
uVar9 = (uint)bVar6;
|
|
if (0xee < (byte)(bVar6 - 3)) {
|
|
code_r0x0011b181:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
switch(bVar6) {
|
|
case 3:
|
|
case 0xe:
|
|
case 0xf:
|
|
pbVar14 = *(byte **)(param_1 + 1);
|
|
pbVar4 = param_1 + 9;
|
|
break;
|
|
default:
|
|
goto code_r0x0011b181;
|
|
case 6:
|
|
case 0x19:
|
|
case 0x1f:
|
|
case 0x20:
|
|
case 0x23:
|
|
case 0x94:
|
|
if (iVar11 == 0) goto execute_stack_op_cold;
|
|
iVar11 = iVar11 + -1;
|
|
puVar1 = (uint *)local_238[iVar11];
|
|
if (bVar6 < 0x24) {
|
|
switch(uVar9 - 6 & 0xff) {
|
|
case 0:
|
|
pbVar14 = *(byte **)puVar1;
|
|
break;
|
|
default:
|
|
goto code_r0x0011b181;
|
|
case 0x13:
|
|
pbVar14 = (byte *)(((ulong)puVar1 ^ (long)puVar1 >> 0x3f) - ((long)puVar1 >> 0x3f));
|
|
break;
|
|
case 0x19:
|
|
pbVar14 = (byte *)-(long)puVar1;
|
|
break;
|
|
case 0x1a:
|
|
pbVar14 = (byte *)~(ulong)puVar1;
|
|
break;
|
|
case 0x1d:
|
|
uVar13 = 0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar7 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar13 = uVar13 | (ulong)(bVar7 & 0x7f) << bVar2;
|
|
} while ((char)bVar7 < '\0');
|
|
pbVar14 = (byte *)((long)puVar1 + uVar13);
|
|
}
|
|
}
|
|
else {
|
|
if (bVar6 != 0x94) {
|
|
/* WARNING: Subroutine does not return */
|
|
switchD_001b0d0f::caseD_4();
|
|
}
|
|
bVar6 = param_1[1];
|
|
pbVar4 = param_1 + 2;
|
|
if (bVar6 == 4) {
|
|
pbVar14 = (byte *)(ulong)*puVar1;
|
|
}
|
|
else if (bVar6 < 5) {
|
|
if (bVar6 == 1) {
|
|
pbVar14 = (byte *)(ulong)(byte)*puVar1;
|
|
}
|
|
else {
|
|
if (bVar6 != 2) {
|
|
/* WARNING: Subroutine does not return */
|
|
switchD_001b0d0f::caseD_4();
|
|
}
|
|
pbVar14 = (byte *)(ulong)(ushort)*puVar1;
|
|
}
|
|
}
|
|
else {
|
|
if (bVar6 != 8) {
|
|
/* WARNING: Subroutine does not return */
|
|
switchD_001b0d0f::caseD_4();
|
|
}
|
|
pbVar14 = *(byte **)puVar1;
|
|
}
|
|
}
|
|
break;
|
|
case 8:
|
|
pbVar14 = (byte *)(ulong)param_1[1];
|
|
pbVar4 = param_1 + 2;
|
|
break;
|
|
case 9:
|
|
pbVar14 = (byte *)(long)(char)param_1[1];
|
|
pbVar4 = param_1 + 2;
|
|
break;
|
|
case 10:
|
|
pbVar14 = (byte *)(ulong)*(ushort *)(param_1 + 1);
|
|
pbVar4 = param_1 + 3;
|
|
break;
|
|
case 0xb:
|
|
pbVar14 = (byte *)(long)*(short *)(param_1 + 1);
|
|
pbVar4 = param_1 + 3;
|
|
break;
|
|
case 0xc:
|
|
pbVar14 = (byte *)(ulong)*(uint *)(param_1 + 1);
|
|
pbVar4 = param_1 + 5;
|
|
break;
|
|
case 0xd:
|
|
pbVar14 = (byte *)(long)*(int *)(param_1 + 1);
|
|
pbVar4 = param_1 + 5;
|
|
break;
|
|
case 0x10:
|
|
pbVar14 = (byte *)0x0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar7 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
pbVar14 = (byte *)((ulong)pbVar14 | (ulong)(bVar7 & 0x7f) << bVar2);
|
|
} while ((char)bVar7 < '\0');
|
|
break;
|
|
case 0x11:
|
|
pbVar14 = (byte *)0x0;
|
|
uVar9 = 0;
|
|
do {
|
|
bVar6 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar7 = (byte)uVar9;
|
|
uVar9 = uVar9 + 7;
|
|
pbVar14 = (byte *)((ulong)pbVar14 | (ulong)(bVar6 & 0x7f) << (bVar7 & 0x3f));
|
|
} while ((char)bVar6 < '\0');
|
|
if ((uVar9 < 0x40) && ((bVar6 & 0x40) != 0)) {
|
|
pbVar14 = (byte *)((ulong)pbVar14 | -1L << ((byte)uVar9 & 0x3f));
|
|
}
|
|
break;
|
|
case 0x12:
|
|
if (iVar11 == 0) goto execute_stack_op_cold;
|
|
pbVar14 = (byte *)local_238[iVar11 + -1];
|
|
break;
|
|
case 0x13:
|
|
if (iVar11 != 0) {
|
|
iVar11 = iVar11 + -1;
|
|
goto LAB_001b0dbc;
|
|
}
|
|
goto execute_stack_op_cold;
|
|
case 0x14:
|
|
if (iVar11 < 2) goto execute_stack_op_cold;
|
|
pbVar14 = (byte *)local_238[iVar11 + -2];
|
|
break;
|
|
case 0x15:
|
|
pbVar4 = param_1 + 2;
|
|
if ((long)(iVar11 + -1) <= (long)(ulong)param_1[1]) goto execute_stack_op_cold;
|
|
pbVar14 = (byte *)local_238[(long)(iVar11 + -1) - (ulong)param_1[1]];
|
|
break;
|
|
case 0x16:
|
|
if (1 < iVar11) {
|
|
uVar13 = local_238[iVar11 + -1];
|
|
local_238[iVar11 + -1] = local_238[iVar11 + -2];
|
|
local_238[iVar11 + -2] = uVar13;
|
|
goto LAB_001b0dbc;
|
|
}
|
|
goto execute_stack_op_cold;
|
|
case 0x17:
|
|
if (2 < iVar11) {
|
|
uVar13 = local_238[iVar11 + -1];
|
|
uVar5 = local_238[iVar11 + -3];
|
|
local_238[iVar11 + -1] = local_238[iVar11 + -2];
|
|
local_238[iVar11 + -2] = uVar5;
|
|
local_238[iVar11 + -3] = uVar13;
|
|
goto LAB_001b0dbc;
|
|
}
|
|
goto execute_stack_op_cold;
|
|
case 0x1a:
|
|
case 0x1b:
|
|
case 0x1c:
|
|
case 0x1d:
|
|
case 0x1e:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x29:
|
|
case 0x2a:
|
|
case 0x2b:
|
|
case 0x2c:
|
|
case 0x2d:
|
|
case 0x2e:
|
|
if (iVar11 < 2) goto execute_stack_op_cold;
|
|
iVar12 = iVar11 + -2;
|
|
uVar13 = local_238[iVar12];
|
|
uVar5 = local_238[iVar11 + -1];
|
|
bVar6 = (byte)uVar5;
|
|
iVar11 = iVar12;
|
|
switch(uVar9 - 0x1a & 0xff) {
|
|
case 0:
|
|
pbVar14 = (byte *)(uVar13 & uVar5);
|
|
break;
|
|
case 1:
|
|
pbVar14 = (byte *)((long)uVar13 / (long)uVar5);
|
|
break;
|
|
case 2:
|
|
pbVar14 = (byte *)(uVar13 - uVar5);
|
|
break;
|
|
case 3:
|
|
pbVar14 = (byte *)(uVar13 % uVar5);
|
|
break;
|
|
case 4:
|
|
pbVar14 = (byte *)(uVar13 * uVar5);
|
|
break;
|
|
default:
|
|
goto code_r0x0011b181;
|
|
case 7:
|
|
pbVar14 = (byte *)(uVar13 | uVar5);
|
|
break;
|
|
case 8:
|
|
pbVar14 = (byte *)(uVar13 + uVar5);
|
|
break;
|
|
case 10:
|
|
pbVar14 = (byte *)(uVar13 << (bVar6 & 0x3f));
|
|
break;
|
|
case 0xb:
|
|
pbVar14 = (byte *)(uVar13 >> (bVar6 & 0x3f));
|
|
break;
|
|
case 0xc:
|
|
pbVar14 = (byte *)((long)uVar13 >> (bVar6 & 0x3f));
|
|
break;
|
|
case 0xd:
|
|
pbVar14 = (byte *)(uVar13 ^ uVar5);
|
|
break;
|
|
case 0xf:
|
|
pbVar14 = (byte *)(ulong)(uVar13 == uVar5);
|
|
break;
|
|
case 0x10:
|
|
pbVar14 = (byte *)(ulong)((long)uVar5 <= (long)uVar13);
|
|
break;
|
|
case 0x11:
|
|
pbVar14 = (byte *)(ulong)((long)uVar5 < (long)uVar13);
|
|
break;
|
|
case 0x12:
|
|
pbVar14 = (byte *)(ulong)((long)uVar13 <= (long)uVar5);
|
|
break;
|
|
case 0x13:
|
|
pbVar14 = (byte *)(ulong)((long)uVar13 < (long)uVar5);
|
|
break;
|
|
case 0x14:
|
|
pbVar14 = (byte *)(ulong)(uVar13 != uVar5);
|
|
}
|
|
break;
|
|
case 0x28:
|
|
if (iVar11 != 0) {
|
|
iVar11 = iVar11 + -1;
|
|
pbVar4 = param_1 + 3;
|
|
if (local_238[iVar11] != 0) {
|
|
pbVar4 = pbVar4 + *(short *)(param_1 + 1);
|
|
}
|
|
goto LAB_001b0dbc;
|
|
}
|
|
goto execute_stack_op_cold;
|
|
case 0x2f:
|
|
pbVar4 = param_1 + (long)*(short *)(param_1 + 1) + 3;
|
|
goto LAB_001b0dbc;
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3c:
|
|
case 0x3d:
|
|
case 0x3e:
|
|
case 0x3f:
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4a:
|
|
case 0x4b:
|
|
case 0x4c:
|
|
case 0x4d:
|
|
case 0x4e:
|
|
case 0x4f:
|
|
pbVar14 = (byte *)(ulong)(bVar6 - 0x30);
|
|
break;
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
case 0x58:
|
|
case 0x59:
|
|
case 0x5a:
|
|
case 0x5b:
|
|
case 0x5c:
|
|
case 0x5d:
|
|
case 0x5e:
|
|
case 0x5f:
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 99:
|
|
case 100:
|
|
case 0x65:
|
|
case 0x66:
|
|
case 0x67:
|
|
case 0x68:
|
|
case 0x69:
|
|
case 0x6a:
|
|
case 0x6b:
|
|
case 0x6c:
|
|
case 0x6d:
|
|
case 0x6e:
|
|
case 0x6f:
|
|
if (0x11 < (int)(bVar6 - 0x50)) goto execute_stack_op_cold;
|
|
lVar10 = (long)(int)(bVar6 - 0x50);
|
|
pbVar14 = *(byte **)(param_3 + lVar10 * 8);
|
|
if (((*(ulong *)(param_3 + 0xc0) & 0x4000000000000000) == 0) ||
|
|
(*(char *)(param_3 + 0xd8 + lVar10) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[lVar10] != '\b') goto execute_stack_op_cold;
|
|
pbVar14 = *(byte **)pbVar14;
|
|
}
|
|
break;
|
|
case 0x70:
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
case 0x76:
|
|
case 0x77:
|
|
case 0x78:
|
|
case 0x79:
|
|
case 0x7a:
|
|
case 0x7b:
|
|
case 0x7c:
|
|
case 0x7d:
|
|
case 0x7e:
|
|
case 0x7f:
|
|
case 0x80:
|
|
case 0x81:
|
|
case 0x82:
|
|
case 0x83:
|
|
case 0x84:
|
|
case 0x85:
|
|
case 0x86:
|
|
case 0x87:
|
|
case 0x88:
|
|
case 0x89:
|
|
case 0x8a:
|
|
case 0x8b:
|
|
case 0x8c:
|
|
case 0x8d:
|
|
case 0x8e:
|
|
case 0x8f:
|
|
uVar13 = 0;
|
|
uVar8 = 0;
|
|
do {
|
|
bVar6 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar7 = (byte)uVar8;
|
|
uVar8 = uVar8 + 7;
|
|
uVar13 = uVar13 | (ulong)(bVar6 & 0x7f) << (bVar7 & 0x3f);
|
|
} while ((char)bVar6 < '\0');
|
|
if ((uVar8 < 0x40) && ((bVar6 & 0x40) != 0)) {
|
|
uVar13 = uVar13 | -1L << ((byte)uVar8 & 0x3f);
|
|
}
|
|
if (0x11 < (int)(uVar9 - 0x70)) goto execute_stack_op_cold;
|
|
lVar10 = (long)(int)(uVar9 - 0x70);
|
|
puVar15 = *(undefined8 **)(param_3 + lVar10 * 8);
|
|
if (((*(ulong *)(param_3 + 0xc0) & 0x4000000000000000) == 0) ||
|
|
(*(char *)(param_3 + 0xd8 + lVar10) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[lVar10] != '\b') goto execute_stack_op_cold;
|
|
puVar15 = (undefined8 *)*puVar15;
|
|
}
|
|
pbVar14 = (byte *)((long)puVar15 + uVar13);
|
|
break;
|
|
case 0x90:
|
|
uVar13 = 0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar7 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar13 = uVar13 | (ulong)(bVar7 & 0x7f) << bVar2;
|
|
} while ((char)bVar7 < '\0');
|
|
iVar12 = (int)uVar13;
|
|
if (0x11 < iVar12) goto execute_stack_op_cold;
|
|
pbVar14 = *(byte **)(param_3 + (long)iVar12 * 8);
|
|
if (((*(ulong *)(param_3 + 0xc0) & 0x4000000000000000) == 0) ||
|
|
(*(char *)(param_3 + 0xd8 + (long)iVar12) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[iVar12] != '\b') goto execute_stack_op_cold;
|
|
pbVar14 = *(byte **)pbVar14;
|
|
}
|
|
break;
|
|
case 0x92:
|
|
uVar13 = 0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar7 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar13 = uVar13 | (ulong)(bVar7 & 0x7f) << bVar2;
|
|
} while ((char)bVar7 < '\0');
|
|
uVar5 = 0;
|
|
uVar9 = 0;
|
|
do {
|
|
bVar6 = *pbVar4;
|
|
pbVar4 = pbVar4 + 1;
|
|
bVar7 = (byte)uVar9;
|
|
uVar9 = uVar9 + 7;
|
|
uVar5 = uVar5 | (ulong)(bVar6 & 0x7f) << (bVar7 & 0x3f);
|
|
} while ((char)bVar6 < '\0');
|
|
if ((uVar9 < 0x40) && ((bVar6 & 0x40) != 0)) {
|
|
uVar5 = uVar5 | -1L << ((byte)uVar9 & 0x3f);
|
|
}
|
|
iVar12 = (int)uVar13;
|
|
if (0x11 < iVar12) goto execute_stack_op_cold;
|
|
puVar15 = *(undefined8 **)(param_3 + (long)iVar12 * 8);
|
|
if (((*(ulong *)(param_3 + 0xc0) & 0x4000000000000000) == 0) ||
|
|
(*(char *)(param_3 + 0xd8 + (long)iVar12) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[iVar12] != '\b') goto execute_stack_op_cold;
|
|
puVar15 = (undefined8 *)*puVar15;
|
|
}
|
|
pbVar14 = (byte *)((long)puVar15 + uVar5);
|
|
break;
|
|
case 0x96:
|
|
goto LAB_001b0dbc;
|
|
case 0xf1:
|
|
bVar6 = param_1[1];
|
|
uVar3 = base_of_encoded_value(bVar6,param_3);
|
|
pbVar4 = (byte *)read_encoded_value_with_base(bVar6,uVar3,param_1 + 2);
|
|
pbVar14 = local_240;
|
|
}
|
|
if (0x3f < iVar11) goto execute_stack_op_cold;
|
|
local_238[iVar11] = (ulong)pbVar14;
|
|
iVar11 = iVar11 + 1;
|
|
LAB_001b0dbc:
|
|
param_1 = pbVar4;
|
|
} while (pbVar4 < param_2);
|
|
if (iVar11 == 0) {
|
|
execute_stack_op_cold:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
param_4 = local_238[iVar11 + -1];
|
|
}
|
|
return param_4;
|
|
}
|
|
|
|
|
|
// 001b13f0 uw_update_context_1
|
|
|
|
void uw_update_context_1(undefined8 *param_1,long *param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
byte bVar2;
|
|
undefined8 *puVar3;
|
|
ulong uVar4;
|
|
long lVar5;
|
|
byte bVar6;
|
|
long lVar7;
|
|
long *plVar8;
|
|
byte *pbVar9;
|
|
long lVar10;
|
|
bool bVar11;
|
|
undefined8 local_130;
|
|
undefined8 local_128 [4];
|
|
undefined8 local_108;
|
|
undefined8 uStack_100;
|
|
undefined8 local_f8;
|
|
undefined8 *puStack_f0;
|
|
undefined8 local_e8;
|
|
undefined8 uStack_e0;
|
|
undefined8 local_d8;
|
|
undefined8 uStack_d0;
|
|
undefined8 local_c8;
|
|
undefined8 uStack_c0;
|
|
undefined8 local_b8;
|
|
undefined8 uStack_b0;
|
|
undefined8 local_a8;
|
|
undefined8 uStack_a0;
|
|
undefined8 local_98;
|
|
undefined8 uStack_90;
|
|
undefined8 local_88;
|
|
undefined8 uStack_80;
|
|
undefined8 local_78;
|
|
undefined8 uStack_70;
|
|
ulong local_68;
|
|
undefined8 uStack_60;
|
|
undefined8 local_58;
|
|
undefined8 uStack_50;
|
|
undefined8 local_48;
|
|
undefined8 uStack_40;
|
|
|
|
local_128[0] = *param_1;
|
|
local_128[1] = param_1[1];
|
|
local_128[2] = param_1[2];
|
|
local_128[3] = param_1[3];
|
|
local_108 = param_1[4];
|
|
uStack_100 = param_1[5];
|
|
local_f8 = param_1[6];
|
|
puStack_f0 = (undefined8 *)param_1[7];
|
|
local_e8 = param_1[8];
|
|
uStack_e0 = param_1[9];
|
|
local_d8 = param_1[10];
|
|
uStack_d0 = param_1[0xb];
|
|
local_c8 = param_1[0xc];
|
|
uStack_c0 = param_1[0xd];
|
|
local_b8 = param_1[0xe];
|
|
uStack_b0 = param_1[0xf];
|
|
local_a8 = param_1[0x10];
|
|
uStack_a0 = param_1[0x11];
|
|
local_98 = param_1[0x12];
|
|
uStack_90 = param_1[0x13];
|
|
local_88 = param_1[0x14];
|
|
uStack_80 = param_1[0x15];
|
|
local_78 = param_1[0x16];
|
|
uStack_70 = param_1[0x17];
|
|
local_68 = param_1[0x18];
|
|
uVar4 = param_1[0x1b];
|
|
uStack_60 = param_1[0x19];
|
|
local_58 = param_1[0x1a];
|
|
uStack_50 = uVar4;
|
|
local_48 = param_1[0x1c];
|
|
uStack_40 = param_1[0x1d];
|
|
if (((((ulong)param_1[0x18] >> 0x3e & 1) == 0) ||
|
|
(uStack_50._7_1_ = (char)(uVar4 >> 0x38), bVar11 = uStack_50._7_1_ == '\0', bVar11)) &&
|
|
((undefined8 *)param_1[7] == (undefined8 *)0x0)) {
|
|
if (DAT_001f9757 != '\b') goto code_r0x0011b186;
|
|
if ((local_68 & 0x4000000000000000) != 0) {
|
|
uStack_50 = uVar4 & 0xffffffffffffff;
|
|
}
|
|
puStack_f0 = &local_130;
|
|
local_130 = param_1[0x12];
|
|
}
|
|
if ((*(byte *)((long)param_1 + 199) & 0x40) != 0) {
|
|
*(undefined1 *)((long)param_1 + 0xdf) = 0;
|
|
}
|
|
param_1[7] = 0;
|
|
if ((int)param_2[0x28] == 1) {
|
|
if (0x11 < (int)param_2[0x26]) {
|
|
code_r0x0011b186:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
lVar7 = (long)(int)param_2[0x26];
|
|
puVar3 = (undefined8 *)local_128[lVar7];
|
|
if (((local_68 & 0x4000000000000000) == 0) || (*(char *)((long)&uStack_50 + lVar7) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[lVar7] != '\b') goto code_r0x0011b186;
|
|
puVar3 = (undefined8 *)*puVar3;
|
|
}
|
|
lVar7 = (long)puVar3 + param_2[0x25];
|
|
}
|
|
else {
|
|
if ((int)param_2[0x28] != 2) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
uVar4 = 0;
|
|
bVar6 = 0;
|
|
pbVar9 = (byte *)param_2[0x27];
|
|
do {
|
|
bVar1 = *pbVar9;
|
|
pbVar9 = pbVar9 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar4 = uVar4 | (ulong)(bVar1 & 0x7f) << bVar2;
|
|
} while ((char)bVar1 < '\0');
|
|
lVar7 = execute_stack_op(pbVar9,pbVar9 + uVar4,local_128,0);
|
|
}
|
|
param_1[0x12] = lVar7;
|
|
lVar10 = 0;
|
|
plVar8 = param_2;
|
|
LAB_001b15e0:
|
|
switch((int)plVar8[1]) {
|
|
default:
|
|
goto switchD_001b15f4_caseD_0;
|
|
case 1:
|
|
puVar3 = (undefined8 *)(*plVar8 + lVar7);
|
|
uVar4 = param_1[0x18];
|
|
break;
|
|
case 2:
|
|
lVar5 = (long)(int)*plVar8;
|
|
if (*(char *)((long)&uStack_50 + lVar5) != '\0') {
|
|
if (0x11 < (int)*plVar8) goto code_r0x0011b186;
|
|
puVar3 = (undefined8 *)local_128[lVar5];
|
|
if ((local_68 & 0x4000000000000000) != 0) goto LAB_001b1638;
|
|
if ((&dwarf_reg_size_table)[lVar5] != '\b') goto code_r0x0011b186;
|
|
puVar3 = (undefined8 *)*puVar3;
|
|
goto LAB_001b1638;
|
|
}
|
|
puVar3 = (undefined8 *)local_128[lVar5];
|
|
uVar4 = param_1[0x18];
|
|
break;
|
|
case 3:
|
|
pbVar9 = (byte *)*plVar8;
|
|
uVar4 = 0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar1 = *pbVar9;
|
|
pbVar9 = pbVar9 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar4 = uVar4 | (ulong)(bVar1 & 0x7f) << bVar2;
|
|
} while ((char)bVar1 < '\0');
|
|
puVar3 = (undefined8 *)execute_stack_op(pbVar9,pbVar9 + uVar4,local_128);
|
|
uVar4 = param_1[0x18];
|
|
break;
|
|
case 4:
|
|
puVar3 = (undefined8 *)(*plVar8 + lVar7);
|
|
if ((byte)(&dwarf_reg_size_table)[lVar10] < 9) goto LAB_001b1668;
|
|
goto code_r0x0011b186;
|
|
case 5:
|
|
pbVar9 = (byte *)*plVar8;
|
|
uVar4 = 0;
|
|
bVar6 = 0;
|
|
do {
|
|
bVar1 = *pbVar9;
|
|
pbVar9 = pbVar9 + 1;
|
|
bVar2 = bVar6 & 0x3f;
|
|
bVar6 = bVar6 + 7;
|
|
uVar4 = uVar4 | (ulong)(bVar1 & 0x7f) << bVar2;
|
|
} while ((char)bVar1 < '\0');
|
|
puVar3 = (undefined8 *)execute_stack_op(pbVar9,pbVar9 + uVar4,local_128,lVar7);
|
|
LAB_001b1638:
|
|
if (8 < (byte)(&dwarf_reg_size_table)[lVar10]) {
|
|
/* WARNING: Subroutine does not return */
|
|
uw_update_context_1_cold();
|
|
}
|
|
LAB_001b1668:
|
|
*(undefined1 *)((long)param_1 + lVar10 + 0xd8) = 1;
|
|
goto LAB_001b1671;
|
|
}
|
|
if ((uVar4 & 0x4000000000000000) != 0) {
|
|
*(undefined1 *)((long)param_1 + lVar10 + 0xd8) = 0;
|
|
}
|
|
LAB_001b1671:
|
|
param_1[lVar10] = puVar3;
|
|
switchD_001b15f4_caseD_0:
|
|
lVar10 = lVar10 + 1;
|
|
plVar8 = plVar8 + 2;
|
|
if (lVar10 == 0x12) {
|
|
uVar4 = param_1[0x18] & 0x7fffffffffffffff;
|
|
if (*(char *)((long)param_2 + 0x173) != '\0') {
|
|
uVar4 = param_1[0x18] | 0x8000000000000000;
|
|
}
|
|
param_1[0x18] = uVar4;
|
|
return;
|
|
}
|
|
goto LAB_001b15e0;
|
|
}
|
|
|
|
|
|
// 001b1820 uw_init_context_1
|
|
|
|
void uw_init_context_1(undefined8 *param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
long lVar2;
|
|
undefined8 *puVar3;
|
|
undefined8 unaff_retaddr;
|
|
undefined8 local_1b0;
|
|
undefined1 local_1a8 [296];
|
|
undefined8 local_80;
|
|
undefined8 local_78;
|
|
undefined4 local_68;
|
|
|
|
puVar3 = param_1;
|
|
for (lVar2 = 0x1e; lVar2 != 0; lVar2 = lVar2 + -1) {
|
|
*puVar3 = 0;
|
|
puVar3 = puVar3 + 1;
|
|
}
|
|
param_1[0x13] = unaff_retaddr;
|
|
param_1[0x18] = 0x4000000000000000;
|
|
iVar1 = uw_frame_state_for(param_1,local_1a8);
|
|
if (iVar1 == 0) {
|
|
iVar1 = pthread_once(&once_regsizes_10235,init_dwarf_reg_size_table);
|
|
if ((iVar1 != 0) && (dwarf_reg_size_table == '\0')) {
|
|
dwarf_reg_size_table = '\b';
|
|
DAT_001f9751 = 8;
|
|
DAT_001f9752 = 8;
|
|
DAT_001f9753 = 8;
|
|
DAT_001f9754 = 8;
|
|
DAT_001f9755 = 8;
|
|
DAT_001f9756 = 8;
|
|
DAT_001f9757 = '\b';
|
|
DAT_001f9758 = 8;
|
|
DAT_001f9759 = 8;
|
|
DAT_001f975a = 8;
|
|
DAT_001f975b = 8;
|
|
DAT_001f975c = 8;
|
|
DAT_001f975d = 8;
|
|
DAT_001f975e = 8;
|
|
DAT_001f975f = 8;
|
|
DAT_001f9760 = 8;
|
|
}
|
|
if (DAT_001f9757 == '\b') {
|
|
if ((*(byte *)((long)param_1 + 199) & 0x40) != 0) {
|
|
*(undefined1 *)((long)param_1 + 0xdf) = 0;
|
|
}
|
|
local_68 = 1;
|
|
param_1[7] = &local_1b0;
|
|
local_78 = 7;
|
|
local_80 = 0;
|
|
local_1b0 = param_2;
|
|
uw_update_context_1(param_1,local_1a8);
|
|
param_1[0x13] = param_3;
|
|
return;
|
|
}
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b19a0 uw_update_context
|
|
|
|
void uw_update_context(long param_1,long param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
long lVar2;
|
|
undefined8 *puVar3;
|
|
|
|
uw_update_context_1();
|
|
if (*(int *)(param_2 + 8 + *(long *)(param_2 + 0x168) * 0x10) == 6) {
|
|
*(undefined8 *)(param_1 + 0x98) = 0;
|
|
return;
|
|
}
|
|
iVar1 = (int)*(long *)(param_2 + 0x168);
|
|
if (iVar1 < 0x12) {
|
|
lVar2 = (long)iVar1;
|
|
puVar3 = *(undefined8 **)(param_1 + lVar2 * 8);
|
|
if (((*(byte *)(param_1 + 199) & 0x40) == 0) || (*(char *)(param_1 + 0xd8 + lVar2) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[lVar2] != '\b') goto uw_update_context_cold;
|
|
puVar3 = (undefined8 *)*puVar3;
|
|
}
|
|
*(undefined8 **)(param_1 + 0x98) = puVar3;
|
|
return;
|
|
}
|
|
uw_update_context_cold:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b1a30 _Unwind_RaiseException_Phase2
|
|
|
|
undefined8 _Unwind_RaiseException_Phase2(undefined8 *param_1,long param_2,long *param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
uint uVar3;
|
|
long lVar4;
|
|
undefined1 auStack_1b8 [336];
|
|
code *local_68;
|
|
|
|
lVar4 = 1;
|
|
do {
|
|
iVar1 = uw_frame_state_for(param_2,auStack_1b8);
|
|
uVar3 = (uint)(param_1[3] == *(long *)(param_2 + 0x90) + (*(long *)(param_2 + 0xc0) >> 0x3f));
|
|
if (iVar1 != 0) {
|
|
return 2;
|
|
}
|
|
if (local_68 != (code *)0x0) {
|
|
uVar2 = (*local_68)(1,uVar3 << 2 | 2,*param_1,param_1,param_2);
|
|
if ((int)uVar2 == 7) {
|
|
*param_3 = lVar4;
|
|
return uVar2;
|
|
}
|
|
if ((int)uVar2 != 8) {
|
|
return 2;
|
|
}
|
|
}
|
|
if (uVar3 != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_RaiseException_Phase2_cold();
|
|
}
|
|
lVar4 = lVar4 + 1;
|
|
uw_update_context(param_2,auStack_1b8);
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001b1b00 _Unwind_ForcedUnwind_Phase2
|
|
|
|
int _Unwind_ForcedUnwind_Phase2(undefined8 *param_1,undefined8 param_2,long *param_3)
|
|
|
|
{
|
|
code *pcVar1;
|
|
undefined8 uVar2;
|
|
int iVar3;
|
|
int iVar4;
|
|
long lVar5;
|
|
undefined1 local_1b8 [336];
|
|
code *local_68;
|
|
|
|
lVar5 = 1;
|
|
pcVar1 = (code *)param_1[2];
|
|
uVar2 = param_1[3];
|
|
while( true ) {
|
|
iVar3 = uw_frame_state_for(param_2,local_1b8);
|
|
if ((iVar3 != 0) && (iVar3 != 5)) {
|
|
return 2;
|
|
}
|
|
if (iVar3 == 5) break;
|
|
iVar3 = (*pcVar1)(1,10,*param_1,param_1,param_2,uVar2);
|
|
if (iVar3 != 0) {
|
|
return 2;
|
|
}
|
|
if (local_68 != (code *)0x0) {
|
|
iVar3 = (*local_68)(1,10,*param_1,param_1,param_2);
|
|
if (iVar3 == 7) goto LAB_001b1bf0;
|
|
if (iVar3 != 8) {
|
|
return 2;
|
|
}
|
|
}
|
|
lVar5 = lVar5 + 1;
|
|
uw_update_context(param_2,local_1b8);
|
|
}
|
|
iVar4 = (*pcVar1)(1,0x1a,*param_1,param_1,param_2,uVar2);
|
|
iVar3 = 5;
|
|
if (iVar4 != 0) {
|
|
return 2;
|
|
}
|
|
LAB_001b1bf0:
|
|
*param_3 = lVar5;
|
|
return iVar3;
|
|
}
|
|
|
|
|
|
// 001b1c00 _Unwind_GetGR
|
|
|
|
undefined8 * _Unwind_GetGR(long param_1,int param_2)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
long lVar2;
|
|
|
|
if (param_2 < 0x12) {
|
|
lVar2 = (long)param_2;
|
|
puVar1 = *(undefined8 **)(param_1 + lVar2 * 8);
|
|
if (((*(byte *)(param_1 + 199) & 0x40) == 0) || (*(char *)(param_1 + 0xd8 + lVar2) == '\0')) {
|
|
if ((&dwarf_reg_size_table)[lVar2] != '\b') goto _Unwind_GetGR_cold;
|
|
puVar1 = (undefined8 *)*puVar1;
|
|
}
|
|
return puVar1;
|
|
}
|
|
_Unwind_GetGR_cold:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b1c40 _Unwind_GetCFA
|
|
|
|
undefined8 _Unwind_GetCFA(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0x90);
|
|
}
|
|
|
|
|
|
// 001b1c50 _Unwind_SetGR
|
|
|
|
void _Unwind_SetGR(long param_1,int param_2,undefined8 param_3)
|
|
|
|
{
|
|
long lVar1;
|
|
|
|
if (param_2 < 0x12) {
|
|
lVar1 = (long)param_2;
|
|
if (((*(byte *)(param_1 + 199) & 0x40) != 0) && (*(char *)(param_1 + 0xd8 + lVar1) != '\0')) {
|
|
*(undefined8 *)(param_1 + lVar1 * 8) = param_3;
|
|
return;
|
|
}
|
|
if ((&dwarf_reg_size_table)[lVar1] == '\b') {
|
|
**(undefined8 **)(param_1 + lVar1 * 8) = param_3;
|
|
return;
|
|
}
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b1cb0 _Unwind_GetIP
|
|
|
|
undefined8 _Unwind_GetIP(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0x98);
|
|
}
|
|
|
|
|
|
// 001b1cc0 _Unwind_GetIPInfo
|
|
|
|
undefined8 _Unwind_GetIPInfo(long param_1,uint *param_2)
|
|
|
|
{
|
|
*param_2 = (uint)((long)*(undefined8 *)(param_1 + 0xc0) >> 0x3f) & 1;
|
|
return *(undefined8 *)(param_1 + 0x98);
|
|
}
|
|
|
|
|
|
// 001b1ce0 _Unwind_SetIP
|
|
|
|
void _Unwind_SetIP(long param_1,undefined8 param_2)
|
|
|
|
{
|
|
*(undefined8 *)(param_1 + 0x98) = param_2;
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b1cf0 _Unwind_GetLanguageSpecificData
|
|
|
|
undefined8 _Unwind_GetLanguageSpecificData(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0xa0);
|
|
}
|
|
|
|
|
|
// 001b1d00 _Unwind_GetRegionStart
|
|
|
|
undefined8 _Unwind_GetRegionStart(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0xb8);
|
|
}
|
|
|
|
|
|
// 001b1d10 _Unwind_FindEnclosingFunction
|
|
|
|
undefined8 _Unwind_FindEnclosingFunction(long param_1)
|
|
|
|
{
|
|
long lVar1;
|
|
undefined8 uVar2;
|
|
undefined1 auStack_28 [16];
|
|
undefined8 local_18;
|
|
|
|
lVar1 = _Unwind_Find_FDE(param_1 + -1,auStack_28);
|
|
uVar2 = 0;
|
|
if (lVar1 != 0) {
|
|
uVar2 = local_18;
|
|
}
|
|
return uVar2;
|
|
}
|
|
|
|
|
|
// 001b1d30 _Unwind_GetDataRelBase
|
|
|
|
undefined8 _Unwind_GetDataRelBase(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0xb0);
|
|
}
|
|
|
|
|
|
// 001b1d40 _Unwind_GetTextRelBase
|
|
|
|
undefined8 _Unwind_GetTextRelBase(long param_1)
|
|
|
|
{
|
|
return *(undefined8 *)(param_1 + 0xa8);
|
|
}
|
|
|
|
|
|
// 001b1d50 __frame_state_for
|
|
|
|
long __frame_state_for(long param_1,long param_2)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
int iVar2;
|
|
long lVar3;
|
|
undefined8 *puVar4;
|
|
char cVar5;
|
|
undefined8 *puVar6;
|
|
undefined8 auStack_288 [19];
|
|
long local_1f0;
|
|
undefined8 local_1c8;
|
|
undefined8 local_1b8;
|
|
undefined8 local_198;
|
|
undefined4 local_190 [72];
|
|
undefined8 local_70;
|
|
undefined2 local_68;
|
|
int local_58;
|
|
undefined2 local_30;
|
|
undefined8 local_20;
|
|
|
|
local_1f0 = param_1 + 1;
|
|
puVar4 = &local_198;
|
|
puVar6 = auStack_288;
|
|
for (lVar3 = 0x1e; lVar3 != 0; lVar3 = lVar3 + -1) {
|
|
*puVar6 = 0;
|
|
puVar6 = puVar6 + 1;
|
|
}
|
|
local_1c8 = 0x4000000000000000;
|
|
iVar2 = uw_frame_state_for(auStack_288,puVar4);
|
|
if ((iVar2 != 0) || (local_58 == 2)) {
|
|
return 0;
|
|
}
|
|
lVar3 = 0;
|
|
do {
|
|
while( true ) {
|
|
cVar5 = (char)*(undefined4 *)(puVar4 + 1);
|
|
*(char *)(param_2 + 0xb4 + lVar3) = cVar5;
|
|
if ((cVar5 != '\x01') && (cVar5 != '\x02')) break;
|
|
uVar1 = *puVar4;
|
|
puVar4 = puVar4 + 2;
|
|
*(undefined8 *)(param_2 + 0x20 + lVar3 * 8) = uVar1;
|
|
lVar3 = lVar3 + 1;
|
|
if (lVar3 == 0x12) goto LAB_001b1e01;
|
|
}
|
|
*(undefined8 *)(param_2 + 0x20 + lVar3 * 8) = 0;
|
|
lVar3 = lVar3 + 1;
|
|
puVar4 = puVar4 + 2;
|
|
} while (lVar3 != 0x12);
|
|
LAB_001b1e01:
|
|
*(undefined8 *)(param_2 + 0x10) = local_70;
|
|
*(undefined2 *)(param_2 + 0xb0) = local_68;
|
|
*(undefined2 *)(param_2 + 0xb2) = local_30;
|
|
*(undefined8 *)(param_2 + 0x18) = local_1b8;
|
|
*(undefined8 *)(param_2 + 8) = local_20;
|
|
return param_2;
|
|
}
|
|
|
|
|
|
// 001b1e60 _Unwind_DebugHook
|
|
|
|
void _Unwind_DebugHook(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b1e70 _Unwind_RaiseException
|
|
|
|
undefined8 _Unwind_RaiseException(undefined8 *param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 in_RAX;
|
|
undefined8 uVar2;
|
|
long lVar3;
|
|
undefined8 unaff_retaddr;
|
|
undefined8 local_3a8;
|
|
undefined8 uStack_3a0;
|
|
undefined8 local_398;
|
|
undefined8 uStack_390;
|
|
undefined8 local_388;
|
|
undefined8 uStack_380;
|
|
undefined8 local_378;
|
|
undefined8 uStack_370;
|
|
undefined8 local_368;
|
|
undefined8 uStack_360;
|
|
undefined8 local_358;
|
|
undefined8 uStack_350;
|
|
undefined8 local_348;
|
|
undefined8 uStack_340;
|
|
undefined8 local_338;
|
|
undefined8 uStack_330;
|
|
undefined8 local_328;
|
|
undefined8 uStack_320;
|
|
long local_318;
|
|
undefined8 uStack_310;
|
|
undefined8 local_308;
|
|
undefined8 uStack_300;
|
|
undefined8 local_2f8;
|
|
undefined8 uStack_2f0;
|
|
long local_2e8;
|
|
undefined8 uStack_2e0;
|
|
undefined8 local_2d8;
|
|
undefined8 uStack_2d0;
|
|
undefined8 local_2c8;
|
|
undefined8 uStack_2c0;
|
|
undefined8 local_2b8;
|
|
undefined8 uStack_2b0;
|
|
undefined8 local_2a8;
|
|
undefined8 uStack_2a0;
|
|
undefined8 local_298;
|
|
undefined8 uStack_290;
|
|
undefined8 local_288;
|
|
undefined8 uStack_280;
|
|
undefined8 local_278;
|
|
undefined8 uStack_270;
|
|
undefined8 local_268;
|
|
undefined8 uStack_260;
|
|
undefined8 local_258;
|
|
undefined8 uStack_250;
|
|
undefined8 local_248;
|
|
undefined8 uStack_240;
|
|
undefined8 local_238;
|
|
undefined8 uStack_230;
|
|
long local_228;
|
|
undefined8 uStack_220;
|
|
undefined8 local_218;
|
|
undefined8 uStack_210;
|
|
undefined8 local_208;
|
|
undefined8 uStack_200;
|
|
long local_1f8;
|
|
undefined8 uStack_1f0;
|
|
undefined8 local_1e8;
|
|
undefined8 uStack_1e0;
|
|
undefined8 local_1d8;
|
|
undefined8 uStack_1d0;
|
|
undefined1 local_1c8 [336];
|
|
code *local_78;
|
|
undefined8 local_40;
|
|
undefined8 local_38;
|
|
|
|
local_40 = in_RAX;
|
|
local_38 = param_3;
|
|
uw_init_context_1(&local_3a8,&stack0x00000008,unaff_retaddr);
|
|
local_2b8 = local_3a8;
|
|
uStack_2b0 = uStack_3a0;
|
|
local_2a8 = local_398;
|
|
uStack_2a0 = uStack_390;
|
|
local_298 = local_388;
|
|
uStack_290 = uStack_380;
|
|
local_288 = local_378;
|
|
uStack_280 = uStack_370;
|
|
local_278 = local_368;
|
|
uStack_270 = uStack_360;
|
|
local_268 = local_358;
|
|
uStack_260 = uStack_350;
|
|
local_258 = local_348;
|
|
uStack_250 = uStack_340;
|
|
local_248 = local_338;
|
|
uStack_240 = uStack_330;
|
|
local_238 = local_328;
|
|
uStack_230 = uStack_320;
|
|
local_228 = local_318;
|
|
uStack_220 = uStack_310;
|
|
local_218 = local_308;
|
|
uStack_210 = uStack_300;
|
|
local_208 = local_2f8;
|
|
uStack_200 = uStack_2f0;
|
|
local_1f8 = local_2e8;
|
|
uStack_1f0 = uStack_2e0;
|
|
local_1e8 = local_2d8;
|
|
uStack_1e0 = uStack_2d0;
|
|
local_1d8 = local_2c8;
|
|
uStack_1d0 = uStack_2c0;
|
|
do {
|
|
uVar2 = uw_frame_state_for(&local_2b8,local_1c8);
|
|
if ((int)uVar2 == 5) {
|
|
return uVar2;
|
|
}
|
|
if ((int)uVar2 != 0) {
|
|
return 3;
|
|
}
|
|
if (local_78 != (code *)0x0) {
|
|
iVar1 = (*local_78)(1,1,*param_1,param_1,&local_2b8);
|
|
if (iVar1 == 6) {
|
|
param_1[2] = 0;
|
|
local_2b8 = local_3a8;
|
|
uStack_2b0 = uStack_3a0;
|
|
local_268 = local_358;
|
|
uStack_260 = uStack_350;
|
|
local_2a8 = local_398;
|
|
uStack_2a0 = uStack_390;
|
|
param_1[3] = local_228 + (local_1f8 >> 0x3f);
|
|
local_298 = local_388;
|
|
uStack_290 = uStack_380;
|
|
local_258 = local_348;
|
|
uStack_250 = uStack_340;
|
|
local_288 = local_378;
|
|
uStack_280 = uStack_370;
|
|
local_248 = local_338;
|
|
uStack_240 = uStack_330;
|
|
local_278 = local_368;
|
|
uStack_270 = uStack_360;
|
|
local_238 = local_328;
|
|
uStack_230 = uStack_320;
|
|
local_228 = local_318;
|
|
uStack_220 = uStack_310;
|
|
local_218 = local_308;
|
|
uStack_210 = uStack_300;
|
|
local_208 = local_2f8;
|
|
uStack_200 = uStack_2f0;
|
|
local_1f8 = local_2e8;
|
|
uStack_1f0 = uStack_2e0;
|
|
local_1e8 = local_2d8;
|
|
uStack_1e0 = uStack_2d0;
|
|
local_1d8 = local_2c8;
|
|
uStack_1d0 = uStack_2c0;
|
|
uVar2 = _Unwind_RaiseException_Phase2(param_1,&local_2b8,local_1c8);
|
|
if ((int)uVar2 == 7) {
|
|
uw_install_context_1(&local_3a8,&local_2b8);
|
|
lVar3 = _Unwind_DebugHook(local_228);
|
|
*(undefined8 *)(&stack0x00000000 + lVar3) = uStack_220;
|
|
return local_40;
|
|
}
|
|
return uVar2;
|
|
}
|
|
if (iVar1 != 8) {
|
|
return 3;
|
|
}
|
|
}
|
|
uw_update_context(&local_2b8,local_1c8);
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001b2170 _Unwind_ForcedUnwind
|
|
|
|
undefined8 _Unwind_ForcedUnwind(long param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
undefined8 in_RAX;
|
|
undefined8 uVar1;
|
|
long lVar2;
|
|
undefined8 unaff_retaddr;
|
|
undefined1 local_230 [8];
|
|
undefined8 local_228;
|
|
undefined8 uStack_220;
|
|
undefined8 local_218;
|
|
undefined8 uStack_210;
|
|
undefined8 local_208;
|
|
undefined8 uStack_200;
|
|
undefined8 local_1f8;
|
|
undefined8 uStack_1f0;
|
|
undefined8 local_1e8;
|
|
undefined8 uStack_1e0;
|
|
undefined8 local_1d8;
|
|
undefined8 uStack_1d0;
|
|
undefined8 local_1c8;
|
|
undefined8 uStack_1c0;
|
|
undefined8 local_1b8;
|
|
undefined8 uStack_1b0;
|
|
undefined8 local_1a8;
|
|
undefined8 uStack_1a0;
|
|
undefined8 local_198;
|
|
undefined8 uStack_190;
|
|
undefined8 local_188;
|
|
undefined8 uStack_180;
|
|
undefined8 local_178;
|
|
undefined8 uStack_170;
|
|
undefined8 local_168;
|
|
undefined8 uStack_160;
|
|
undefined8 local_158;
|
|
undefined8 uStack_150;
|
|
undefined8 local_148;
|
|
undefined8 uStack_140;
|
|
undefined8 local_138;
|
|
undefined8 uStack_130;
|
|
undefined8 local_128;
|
|
undefined8 uStack_120;
|
|
undefined8 local_118;
|
|
undefined8 uStack_110;
|
|
undefined8 local_108;
|
|
undefined8 uStack_100;
|
|
undefined8 local_f8;
|
|
undefined8 uStack_f0;
|
|
undefined8 local_e8;
|
|
undefined8 uStack_e0;
|
|
undefined8 local_d8;
|
|
undefined8 uStack_d0;
|
|
undefined8 local_c8;
|
|
undefined8 uStack_c0;
|
|
undefined8 local_b8;
|
|
undefined8 uStack_b0;
|
|
undefined8 local_a8;
|
|
undefined8 uStack_a0;
|
|
undefined8 local_98;
|
|
undefined8 uStack_90;
|
|
undefined8 local_88;
|
|
undefined8 uStack_80;
|
|
undefined8 local_78;
|
|
undefined8 uStack_70;
|
|
undefined8 local_68;
|
|
undefined8 uStack_60;
|
|
undefined8 local_58;
|
|
undefined8 uStack_50;
|
|
undefined8 local_40;
|
|
undefined8 local_38;
|
|
|
|
local_40 = in_RAX;
|
|
local_38 = param_3;
|
|
uw_init_context_1(&local_228,&stack0x00000008,unaff_retaddr);
|
|
*(undefined8 *)(param_1 + 0x10) = param_2;
|
|
*(undefined8 *)(param_1 + 0x18) = param_3;
|
|
local_138 = local_228;
|
|
uStack_130 = uStack_220;
|
|
local_128 = local_218;
|
|
uStack_120 = uStack_210;
|
|
local_118 = local_208;
|
|
uStack_110 = uStack_200;
|
|
local_108 = local_1f8;
|
|
uStack_100 = uStack_1f0;
|
|
local_f8 = local_1e8;
|
|
uStack_f0 = uStack_1e0;
|
|
local_e8 = local_1d8;
|
|
uStack_e0 = uStack_1d0;
|
|
local_d8 = local_1c8;
|
|
uStack_d0 = uStack_1c0;
|
|
local_c8 = local_1b8;
|
|
uStack_c0 = uStack_1b0;
|
|
local_b8 = local_1a8;
|
|
uStack_b0 = uStack_1a0;
|
|
local_a8 = local_198;
|
|
uStack_a0 = uStack_190;
|
|
local_98 = local_188;
|
|
uStack_90 = uStack_180;
|
|
local_88 = local_178;
|
|
uStack_80 = uStack_170;
|
|
local_78 = local_168;
|
|
uStack_70 = uStack_160;
|
|
local_68 = local_158;
|
|
uStack_60 = uStack_150;
|
|
local_58 = local_148;
|
|
uStack_50 = uStack_140;
|
|
uVar1 = _Unwind_ForcedUnwind_Phase2(param_1,&local_138,local_230);
|
|
if ((int)uVar1 != 7) {
|
|
return uVar1;
|
|
}
|
|
uw_install_context_1(&local_228,&local_138);
|
|
lVar2 = _Unwind_DebugHook(local_a8);
|
|
*(undefined8 *)(&stack0x00000000 + lVar2) = uStack_a0;
|
|
return local_40;
|
|
}
|
|
|
|
|
|
// 001b2310 _Unwind_Resume
|
|
|
|
undefined1 [16] _Unwind_Resume(long param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 in_RAX;
|
|
undefined1 auVar2 [16];
|
|
undefined8 unaff_retaddr;
|
|
undefined1 local_230 [8];
|
|
undefined8 local_228;
|
|
undefined8 uStack_220;
|
|
undefined8 local_218;
|
|
undefined8 uStack_210;
|
|
undefined8 local_208;
|
|
undefined8 uStack_200;
|
|
undefined8 local_1f8;
|
|
undefined8 uStack_1f0;
|
|
undefined8 local_1e8;
|
|
undefined8 uStack_1e0;
|
|
undefined8 local_1d8;
|
|
undefined8 uStack_1d0;
|
|
undefined8 local_1c8;
|
|
undefined8 uStack_1c0;
|
|
undefined8 local_1b8;
|
|
undefined8 uStack_1b0;
|
|
undefined8 local_1a8;
|
|
undefined8 uStack_1a0;
|
|
undefined8 local_198;
|
|
undefined8 uStack_190;
|
|
undefined8 local_188;
|
|
undefined8 uStack_180;
|
|
undefined8 local_178;
|
|
undefined8 uStack_170;
|
|
undefined8 local_168;
|
|
undefined8 uStack_160;
|
|
undefined8 local_158;
|
|
undefined8 uStack_150;
|
|
undefined8 local_148;
|
|
undefined8 uStack_140;
|
|
undefined8 local_138;
|
|
undefined8 uStack_130;
|
|
undefined8 local_128;
|
|
undefined8 uStack_120;
|
|
undefined8 local_118;
|
|
undefined8 uStack_110;
|
|
undefined8 local_108;
|
|
undefined8 uStack_100;
|
|
undefined8 local_f8;
|
|
undefined8 uStack_f0;
|
|
undefined8 local_e8;
|
|
undefined8 uStack_e0;
|
|
undefined8 local_d8;
|
|
undefined8 uStack_d0;
|
|
undefined8 local_c8;
|
|
undefined8 uStack_c0;
|
|
undefined8 local_b8;
|
|
undefined8 uStack_b0;
|
|
undefined8 local_a8;
|
|
undefined8 uStack_a0;
|
|
undefined8 local_98;
|
|
undefined8 uStack_90;
|
|
undefined8 local_88;
|
|
undefined8 uStack_80;
|
|
undefined8 local_78;
|
|
undefined8 uStack_70;
|
|
undefined8 local_68;
|
|
undefined8 uStack_60;
|
|
undefined8 local_58;
|
|
undefined8 uStack_50;
|
|
undefined8 local_40;
|
|
undefined8 local_38;
|
|
|
|
local_40 = in_RAX;
|
|
local_38 = param_3;
|
|
uw_init_context_1(&local_228,&stack0x00000008,unaff_retaddr);
|
|
local_138 = local_228;
|
|
uStack_130 = uStack_220;
|
|
local_128 = local_218;
|
|
uStack_120 = uStack_210;
|
|
local_118 = local_208;
|
|
uStack_110 = uStack_200;
|
|
local_108 = local_1f8;
|
|
uStack_100 = uStack_1f0;
|
|
local_f8 = local_1e8;
|
|
uStack_f0 = uStack_1e0;
|
|
local_e8 = local_1d8;
|
|
uStack_e0 = uStack_1d0;
|
|
local_d8 = local_1c8;
|
|
uStack_d0 = uStack_1c0;
|
|
local_c8 = local_1b8;
|
|
uStack_c0 = uStack_1b0;
|
|
local_b8 = local_1a8;
|
|
uStack_b0 = uStack_1a0;
|
|
local_a8 = local_198;
|
|
uStack_a0 = uStack_190;
|
|
local_98 = local_188;
|
|
uStack_90 = uStack_180;
|
|
local_88 = local_178;
|
|
uStack_80 = uStack_170;
|
|
local_78 = local_168;
|
|
uStack_70 = uStack_160;
|
|
local_68 = local_158;
|
|
uStack_60 = uStack_150;
|
|
local_58 = local_148;
|
|
uStack_50 = uStack_140;
|
|
if (*(long *)(param_1 + 0x10) == 0) {
|
|
iVar1 = _Unwind_RaiseException_Phase2();
|
|
}
|
|
else {
|
|
iVar1 = _Unwind_ForcedUnwind_Phase2(param_1,&local_138,local_230);
|
|
}
|
|
if (iVar1 == 7) {
|
|
uw_install_context_1(&local_228,&local_138);
|
|
auVar2 = _Unwind_DebugHook(local_a8,uStack_a0);
|
|
*(long *)(&stack0x00000000 + auVar2._0_8_) = auVar2._8_8_;
|
|
auVar2._8_8_ = local_38;
|
|
auVar2._0_8_ = local_40;
|
|
return auVar2;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b24a0 _Unwind_Resume_or_Rethrow
|
|
|
|
undefined8 _Unwind_Resume_or_Rethrow(long param_1,undefined8 param_2,undefined8 param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 in_RAX;
|
|
undefined8 uVar2;
|
|
long lVar3;
|
|
undefined4 *puVar4;
|
|
undefined4 *puVar5;
|
|
byte bVar6;
|
|
undefined8 unaff_retaddr;
|
|
undefined1 local_230 [8];
|
|
undefined4 local_228 [60];
|
|
undefined4 local_138 [36];
|
|
undefined8 local_a8;
|
|
undefined8 local_a0;
|
|
undefined8 local_40;
|
|
undefined8 local_38;
|
|
|
|
bVar6 = 0;
|
|
local_38 = param_3;
|
|
if (*(long *)(param_1 + 0x10) == 0) {
|
|
uVar2 = _Unwind_RaiseException();
|
|
return uVar2;
|
|
}
|
|
local_40 = in_RAX;
|
|
uw_init_context_1(local_228,&stack0x00000008,unaff_retaddr);
|
|
puVar4 = local_228;
|
|
puVar5 = local_138;
|
|
for (lVar3 = 0x3c; lVar3 != 0; lVar3 = lVar3 + -1) {
|
|
*puVar5 = *puVar4;
|
|
puVar4 = puVar4 + (ulong)bVar6 * -2 + 1;
|
|
puVar5 = puVar5 + (ulong)bVar6 * -2 + 1;
|
|
}
|
|
iVar1 = _Unwind_ForcedUnwind_Phase2(param_1,local_138,local_230);
|
|
if (iVar1 == 7) {
|
|
uw_install_context_1(local_228,local_138);
|
|
lVar3 = _Unwind_DebugHook(local_a8);
|
|
*(undefined8 *)(&stack0x00000000 + lVar3) = local_a0;
|
|
return local_40;
|
|
}
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b2580 _Unwind_DeleteException
|
|
|
|
void _Unwind_DeleteException(long param_1)
|
|
|
|
{
|
|
if (*(code **)(param_1 + 8) != (code *)0x0) {
|
|
/* WARNING: Could not recover jumptable at 0x001b2591. Too many branches */
|
|
/* WARNING: Treating indirect jump as call */
|
|
(**(code **)(param_1 + 8))(1,param_1);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b25a0 _Unwind_Backtrace
|
|
|
|
undefined4 _Unwind_Backtrace(code *param_1,undefined8 param_2)
|
|
|
|
{
|
|
int iVar1;
|
|
int iVar2;
|
|
undefined8 unaff_retaddr;
|
|
undefined1 local_2a8 [240];
|
|
undefined1 local_1b8 [392];
|
|
|
|
uw_init_context_1(local_2a8,&stack0x00000008,unaff_retaddr);
|
|
while (((iVar2 = uw_frame_state_for(local_2a8,local_1b8), iVar2 == 0 || (iVar2 == 5)) &&
|
|
(iVar1 = (*param_1)(local_2a8,param_2), iVar1 == 0))) {
|
|
if (iVar2 == 5) {
|
|
return 5;
|
|
}
|
|
uw_update_context(local_2a8,local_1b8);
|
|
}
|
|
return 3;
|
|
}
|
|
|
|
|
|
// 001b2630 fde_unencoded_compare
|
|
|
|
int fde_unencoded_compare(undefined8 param_1,long param_2,long param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
|
|
iVar1 = 1;
|
|
if (*(ulong *)(param_2 + 8) <= *(ulong *)(param_3 + 8)) {
|
|
iVar1 = -(uint)(*(ulong *)(param_2 + 8) < *(ulong *)(param_3 + 8));
|
|
}
|
|
return iVar1;
|
|
}
|
|
|
|
|
|
// 001b2650 frame_downheap
|
|
|
|
void frame_downheap(undefined8 param_1,code *param_2,long param_3,int param_4,int param_5)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
int iVar4;
|
|
undefined8 uVar5;
|
|
undefined8 *puVar6;
|
|
|
|
while( true ) {
|
|
iVar4 = param_4 * 2 + 1;
|
|
if (param_5 <= iVar4) {
|
|
return;
|
|
}
|
|
iVar3 = param_4 * 2 + 2;
|
|
puVar6 = (undefined8 *)(param_3 + (long)iVar4 * 8);
|
|
uVar5 = *puVar6;
|
|
if (iVar3 < param_5) {
|
|
puVar1 = (undefined8 *)(param_3 + 8 + (long)iVar4 * 8);
|
|
iVar2 = (*param_2)(param_1,uVar5,*puVar1);
|
|
if (iVar2 < 0) {
|
|
uVar5 = *puVar1;
|
|
puVar6 = puVar1;
|
|
iVar4 = iVar3;
|
|
}
|
|
else {
|
|
uVar5 = *puVar6;
|
|
}
|
|
}
|
|
puVar1 = (undefined8 *)(param_3 + (long)param_4 * 8);
|
|
iVar3 = (*param_2)(param_1,*puVar1,uVar5);
|
|
if (-1 < iVar3) break;
|
|
uVar5 = *puVar1;
|
|
*puVar1 = *puVar6;
|
|
*puVar6 = uVar5;
|
|
param_4 = iVar4;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b2720 frame_heapsort
|
|
|
|
void frame_heapsort(undefined8 param_1,undefined8 param_2,long param_3)
|
|
|
|
{
|
|
undefined8 uVar1;
|
|
int iVar2;
|
|
int iVar3;
|
|
ulong uVar4;
|
|
ulong uVar5;
|
|
undefined4 local_40;
|
|
|
|
uVar4 = *(ulong *)(param_3 + 8);
|
|
iVar2 = (int)(uVar4 >> 1) + -1;
|
|
if (-1 < iVar2) {
|
|
do {
|
|
iVar3 = iVar2 + -1;
|
|
frame_downheap(param_1,param_2,param_3 + 0x10,iVar2,uVar4 & 0xffffffff);
|
|
iVar2 = iVar3;
|
|
} while (iVar3 != -1);
|
|
}
|
|
local_40 = (int)uVar4;
|
|
local_40 = local_40 + -1;
|
|
uVar4 = (ulong)local_40;
|
|
while (0 < local_40) {
|
|
uVar1 = *(undefined8 *)(param_3 + 0x10);
|
|
uVar5 = uVar4 & 0xffffffff;
|
|
*(undefined8 *)(param_3 + 0x10) = *(undefined8 *)(param_3 + 0x10 + uVar4 * 8);
|
|
*(undefined8 *)(param_3 + 0x10 + uVar4 * 8) = uVar1;
|
|
uVar4 = uVar4 - 1;
|
|
frame_downheap(param_1,param_2,param_3 + 0x10,0,uVar5);
|
|
local_40 = (int)uVar4;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b27d0 size_of_encoded_value
|
|
|
|
undefined8 size_of_encoded_value(byte param_1)
|
|
|
|
{
|
|
if (param_1 == 0xff) {
|
|
return 0;
|
|
}
|
|
param_1 = param_1 & 7;
|
|
if (param_1 == 2) {
|
|
return 2;
|
|
}
|
|
if (param_1 < 3) {
|
|
if (param_1 != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
size_of_encoded_value_cold();
|
|
}
|
|
}
|
|
else {
|
|
if (param_1 == 3) {
|
|
return 4;
|
|
}
|
|
if (param_1 != 4) {
|
|
/* WARNING: Subroutine does not return */
|
|
size_of_encoded_value_cold();
|
|
}
|
|
}
|
|
return 8;
|
|
}
|
|
|
|
|
|
// 001b2840 base_from_object
|
|
|
|
undefined8 base_from_object(byte param_1,long param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
|
|
if (param_1 == 0xff) {
|
|
return 0;
|
|
}
|
|
bVar1 = param_1 & 0x70;
|
|
if (bVar1 == 0x20) {
|
|
return *(undefined8 *)(param_2 + 8);
|
|
}
|
|
if (bVar1 < 0x21) {
|
|
if ((param_1 & 0x60) != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
}
|
|
else {
|
|
if (bVar1 == 0x30) {
|
|
return *(undefined8 *)(param_2 + 0x10);
|
|
}
|
|
if (bVar1 != 0x50) {
|
|
/* WARNING: Subroutine does not return */
|
|
base_from_object_cold();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001b28a0 base_from_cb_data
|
|
|
|
undefined8 base_from_cb_data(byte param_1,long param_2)
|
|
|
|
{
|
|
byte bVar1;
|
|
|
|
if (param_1 == 0xff) {
|
|
return 0;
|
|
}
|
|
bVar1 = param_1 & 0x70;
|
|
if (bVar1 == 0x20) {
|
|
return *(undefined8 *)(param_2 + 8);
|
|
}
|
|
if (bVar1 < 0x21) {
|
|
if ((param_1 & 0x60) != 0) {
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
}
|
|
else {
|
|
if (bVar1 == 0x30) {
|
|
return *(undefined8 *)(param_2 + 0x10);
|
|
}
|
|
if (bVar1 != 0x50) {
|
|
/* WARNING: Subroutine does not return */
|
|
base_from_cb_data_cold();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001b2900 read_encoded_value_with_base
|
|
|
|
ulong * read_encoded_value_with_base(byte param_1,ulong *param_2,ulong *param_3,undefined8 *param_4)
|
|
|
|
{
|
|
ulong uVar1;
|
|
undefined8 *puVar2;
|
|
ulong *puVar3;
|
|
byte bVar4;
|
|
byte bVar5;
|
|
uint uVar6;
|
|
byte *pbVar7;
|
|
ulong uVar8;
|
|
|
|
if (param_1 == 0x50) {
|
|
puVar2 = (undefined8 *)((ulong)((long)param_3 + 7U) & 0xfffffffffffffff8);
|
|
*param_4 = *puVar2;
|
|
return puVar2 + 1;
|
|
}
|
|
puVar3 = param_3;
|
|
switch(param_1 & 0xf) {
|
|
case 0:
|
|
case 4:
|
|
case 0xc:
|
|
uVar8 = *param_3;
|
|
puVar3 = param_3 + 1;
|
|
break;
|
|
case 1:
|
|
uVar8 = 0;
|
|
bVar4 = 0;
|
|
do {
|
|
uVar1 = *puVar3;
|
|
puVar3 = (ulong *)((long)puVar3 + 1);
|
|
bVar5 = bVar4 & 0x3f;
|
|
bVar4 = bVar4 + 7;
|
|
uVar8 = uVar8 | (ulong)((byte)uVar1 & 0x7f) << bVar5;
|
|
} while ((char)(byte)uVar1 < '\0');
|
|
break;
|
|
case 2:
|
|
uVar8 = (ulong)(ushort)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 2);
|
|
break;
|
|
case 3:
|
|
uVar8 = (ulong)(uint)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 4);
|
|
break;
|
|
default:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
case 9:
|
|
uVar8 = 0;
|
|
uVar6 = 0;
|
|
do {
|
|
bVar4 = (byte)*puVar3;
|
|
puVar3 = (ulong *)((long)puVar3 + 1);
|
|
bVar5 = (byte)uVar6;
|
|
uVar6 = uVar6 + 7;
|
|
uVar8 = uVar8 | (ulong)(bVar4 & 0x7f) << (bVar5 & 0x3f);
|
|
} while ((char)bVar4 < '\0');
|
|
if ((0x3f < uVar6) || ((bVar4 & 0x40) == 0)) break;
|
|
uVar8 = uVar8 | -1L << ((byte)uVar6 & 0x3f);
|
|
goto LAB_001b293c;
|
|
case 10:
|
|
uVar8 = (ulong)(short)(ushort)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 2);
|
|
break;
|
|
case 0xb:
|
|
uVar8 = (ulong)(int)(uint)*param_3;
|
|
puVar3 = (ulong *)((long)param_3 + 4);
|
|
}
|
|
pbVar7 = (byte *)0x0;
|
|
if (uVar8 != 0) {
|
|
LAB_001b293c:
|
|
if ((param_1 & 0x70) == 0x10) {
|
|
param_2 = param_3;
|
|
}
|
|
pbVar7 = (byte *)(uVar8 + (long)param_2);
|
|
if ((char)param_1 < '\0') {
|
|
*param_4 = *(undefined8 *)pbVar7;
|
|
return puVar3;
|
|
}
|
|
}
|
|
*param_4 = pbVar7;
|
|
return puVar3;
|
|
}
|
|
|
|
|
|
// 001b2a50 fde_single_encoding_compare
|
|
|
|
int fde_single_encoding_compare(long param_1,long param_2,long param_3)
|
|
|
|
{
|
|
int iVar1;
|
|
undefined8 uVar2;
|
|
undefined1 uVar3;
|
|
ulong local_38;
|
|
ulong local_30;
|
|
|
|
uVar3 = (undefined1)(*(ushort *)(param_1 + 0x20) >> 3);
|
|
uVar2 = base_from_object(uVar3,param_1);
|
|
read_encoded_value_with_base(uVar3,uVar2,param_2 + 8,&local_38);
|
|
read_encoded_value_with_base((char)(*(ushort *)(param_1 + 0x20) >> 3),uVar2,param_3 + 8,&local_30)
|
|
;
|
|
iVar1 = 1;
|
|
if (local_38 <= local_30) {
|
|
iVar1 = -(uint)(local_38 < local_30);
|
|
}
|
|
return iVar1;
|
|
}
|
|
|
|
|
|
// 001b2ad0 get_cie_encoding
|
|
|
|
byte get_cie_encoding(long param_1)
|
|
|
|
{
|
|
byte bVar1;
|
|
size_t sVar2;
|
|
byte *pbVar3;
|
|
byte *pbVar4;
|
|
char cVar5;
|
|
char *pcVar6;
|
|
undefined1 local_20 [16];
|
|
|
|
sVar2 = strlen((char *)(param_1 + 9));
|
|
pbVar4 = (byte *)(param_1 + 10 + sVar2);
|
|
if (3 < *(byte *)(param_1 + 8)) {
|
|
if (*pbVar4 != 8) {
|
|
return 0xff;
|
|
}
|
|
if (pbVar4[1] != 0) {
|
|
return 0xff;
|
|
}
|
|
pbVar4 = pbVar4 + 2;
|
|
}
|
|
if (*(char *)(param_1 + 9) != 'z') {
|
|
return 0;
|
|
}
|
|
do {
|
|
bVar1 = *pbVar4;
|
|
pbVar3 = pbVar4 + 1;
|
|
pbVar4 = pbVar4 + 1;
|
|
} while ((char)bVar1 < '\0');
|
|
do {
|
|
pbVar4 = pbVar3;
|
|
pbVar3 = pbVar4 + 1;
|
|
} while ((char)*pbVar4 < '\0');
|
|
if (*(byte *)(param_1 + 8) == 1) {
|
|
pbVar4 = pbVar4 + 2;
|
|
}
|
|
else {
|
|
do {
|
|
pbVar4 = pbVar3 + 1;
|
|
bVar1 = *pbVar3;
|
|
pbVar3 = pbVar4;
|
|
} while ((char)bVar1 < '\0');
|
|
}
|
|
pcVar6 = (char *)(param_1 + 10);
|
|
do {
|
|
pbVar3 = pbVar4 + 1;
|
|
bVar1 = *pbVar4;
|
|
pbVar4 = pbVar3;
|
|
} while ((char)bVar1 < '\0');
|
|
cVar5 = *(char *)(param_1 + 10);
|
|
while (cVar5 != 'R') {
|
|
while (cVar5 != 'P') {
|
|
if (cVar5 != 'L') {
|
|
return 0;
|
|
}
|
|
cVar5 = pcVar6[1];
|
|
pcVar6 = pcVar6 + 1;
|
|
pbVar3 = pbVar3 + 1;
|
|
if (cVar5 == 'R') goto LAB_001b2bab;
|
|
}
|
|
pcVar6 = pcVar6 + 1;
|
|
pbVar3 = (byte *)read_encoded_value_with_base(*pbVar3 & 0x7f,0,pbVar3 + 1,local_20);
|
|
cVar5 = *pcVar6;
|
|
}
|
|
LAB_001b2bab:
|
|
return *pbVar3;
|
|
}
|
|
|
|
|
|
// 001b2c00 linear_search_fdes
|
|
|
|
uint * linear_search_fdes(long param_1,uint *param_2,long param_3)
|
|
|
|
{
|
|
uint uVar1;
|
|
uint uVar2;
|
|
undefined8 uVar3;
|
|
undefined8 uVar4;
|
|
long lVar5;
|
|
ulong uVar6;
|
|
byte bVar7;
|
|
long lVar8;
|
|
ulong local_48;
|
|
ulong local_40 [2];
|
|
|
|
bVar7 = (byte)(*(ushort *)(param_1 + 0x20) >> 3);
|
|
uVar1 = (uint)bVar7;
|
|
uVar3 = base_from_object(bVar7,param_1);
|
|
uVar2 = *param_2;
|
|
lVar8 = 0;
|
|
do {
|
|
if (uVar2 == 0) {
|
|
return (uint *)0x0;
|
|
}
|
|
if (param_2[1] != 0) {
|
|
if (((*(byte *)(param_1 + 0x20) & 4) != 0) &&
|
|
(lVar5 = (long)param_2 + (4 - (long)(int)param_2[1]), lVar5 != lVar8)) {
|
|
uVar1 = get_cie_encoding(lVar5);
|
|
uVar3 = base_from_object((char)uVar1,param_1);
|
|
lVar8 = lVar5;
|
|
}
|
|
if (uVar1 == 0) {
|
|
local_48 = *(ulong *)(param_2 + 2);
|
|
local_40[0] = *(ulong *)(param_2 + 4);
|
|
if ((local_48 != 0) && (param_3 - local_48 < local_40[0])) {
|
|
return param_2;
|
|
}
|
|
}
|
|
else {
|
|
uVar4 = read_encoded_value_with_base(uVar1 & 0xff,uVar3,param_2 + 2,&local_48);
|
|
read_encoded_value_with_base(uVar1 & 0xf,0,uVar4,local_40);
|
|
uVar2 = size_of_encoded_value(uVar1 & 0xff);
|
|
uVar6 = 0xffffffffffffffff;
|
|
if (uVar2 < 8) {
|
|
uVar6 = (1L << ((char)uVar2 * '\b' & 0x3fU)) - 1;
|
|
}
|
|
if (((local_48 & uVar6) != 0) && (param_3 - local_48 < local_40[0])) {
|
|
return param_2;
|
|
}
|
|
}
|
|
}
|
|
param_2 = (uint *)((long)param_2 + (ulong)*param_2 + 4);
|
|
uVar2 = *param_2;
|
|
} while( true );
|
|
}
|
|
|
|
|
|
// 001b2d80 _Unwind_IteratePhdrCallback
|
|
|
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
|
|
|
|
undefined8 _Unwind_IteratePhdrCallback(ulong *param_1,ulong param_2,ulong *param_3)
|
|
|
|
{
|
|
int *piVar1;
|
|
char cVar2;
|
|
int iVar3;
|
|
ulong *puVar4;
|
|
bool bVar5;
|
|
int *piVar6;
|
|
undefined1 uVar7;
|
|
byte bVar8;
|
|
uint uVar9;
|
|
ulong *puVar10;
|
|
undefined8 uVar11;
|
|
ulong uVar12;
|
|
undefined8 uVar13;
|
|
int *piVar14;
|
|
undefined8 *puVar15;
|
|
int *piVar16;
|
|
int *piVar17;
|
|
ulong uVar18;
|
|
char *pcVar19;
|
|
ulong *puVar20;
|
|
ulong uVar21;
|
|
ulong uVar22;
|
|
char *pcVar23;
|
|
ulong *local_80;
|
|
undefined8 local_78;
|
|
ulong local_70;
|
|
long local_68;
|
|
ulong local_60;
|
|
ulong local_58;
|
|
undefined8 local_50;
|
|
undefined8 local_48;
|
|
|
|
puVar10 = frame_hdr_cache_head;
|
|
piVar14 = (int *)param_1[2];
|
|
uVar12 = *param_1;
|
|
if (((int)param_3[5] == 0) || (param_2 < 0x30)) {
|
|
if (param_2 < 0x1a) {
|
|
return 0xffffffff;
|
|
}
|
|
}
|
|
else {
|
|
if ((param_1[4] != adds_10132) || (subs_10133 != param_1[5])) {
|
|
puVar15 = &DAT_001f97d0;
|
|
adds_10132 = param_1[4];
|
|
subs_10133 = param_1[5];
|
|
do {
|
|
puVar15[-6] = 0;
|
|
puVar15[-5] = 0;
|
|
puVar15[-1] = puVar15;
|
|
puVar15 = puVar15 + 6;
|
|
} while (puVar15 != &seen_objects);
|
|
puVar20 = (ulong *)0x0;
|
|
_DAT_001f9918 = 0;
|
|
frame_hdr_cache_head = &frame_hdr_cache;
|
|
*(undefined4 *)(param_3 + 5) = 0;
|
|
local_80 = (ulong *)0x0;
|
|
goto LAB_001b2dbf;
|
|
}
|
|
if (frame_hdr_cache_head != (ulong *)0x0) {
|
|
uVar21 = *frame_hdr_cache_head;
|
|
uVar22 = frame_hdr_cache_head[1];
|
|
local_80 = (ulong *)0x0;
|
|
puVar20 = frame_hdr_cache_head;
|
|
while( true ) {
|
|
if ((uVar21 <= *param_3) && (*param_3 < uVar22)) {
|
|
uVar12 = puVar20[2];
|
|
piVar16 = (int *)puVar20[3];
|
|
if (puVar20 != frame_hdr_cache_head) {
|
|
frame_hdr_cache_head = puVar20;
|
|
local_80[5] = puVar20[5];
|
|
puVar20[5] = (ulong)puVar10;
|
|
}
|
|
goto LAB_001b2e98;
|
|
}
|
|
if ((uVar21 == 0 && uVar22 == 0) || (puVar4 = (ulong *)puVar20[5], puVar4 == (ulong *)0x0))
|
|
break;
|
|
uVar21 = *puVar4;
|
|
uVar22 = puVar4[1];
|
|
local_80 = puVar20;
|
|
puVar20 = puVar4;
|
|
}
|
|
goto LAB_001b2dbf;
|
|
}
|
|
}
|
|
local_80 = (ulong *)0x0;
|
|
puVar20 = (ulong *)0x0;
|
|
LAB_001b2dbf:
|
|
puVar10 = frame_hdr_cache_head;
|
|
if ((ushort)param_1[3] == 0) {
|
|
return 0;
|
|
}
|
|
uVar21 = 0;
|
|
uVar22 = 0;
|
|
piVar17 = (int *)0x0;
|
|
bVar5 = false;
|
|
piVar16 = (int *)0x0;
|
|
piVar1 = piVar14 + (ulong)(ushort)param_1[3] * 0xe;
|
|
do {
|
|
iVar3 = *piVar14;
|
|
piVar6 = piVar16;
|
|
if (iVar3 == 1) {
|
|
uVar18 = *(long *)(piVar14 + 4) + uVar12;
|
|
if ((uVar18 <= *param_3) && (*param_3 < *(long *)(piVar14 + 10) + uVar18)) {
|
|
bVar5 = true;
|
|
uVar21 = *(long *)(piVar14 + 10) + uVar18;
|
|
uVar22 = uVar18;
|
|
}
|
|
}
|
|
else {
|
|
piVar6 = piVar14;
|
|
if ((iVar3 != 0x6474e550) && (piVar6 = piVar16, iVar3 == 2)) {
|
|
piVar17 = piVar14;
|
|
}
|
|
}
|
|
piVar16 = piVar6;
|
|
piVar14 = piVar14 + 0xe;
|
|
} while (piVar1 != piVar14);
|
|
if (!bVar5) {
|
|
return 0;
|
|
}
|
|
if (0x2f < param_2) {
|
|
if ((puVar20 != (ulong *)0x0) && (local_80 != (ulong *)0x0)) {
|
|
frame_hdr_cache_head = puVar20;
|
|
local_80[5] = puVar20[5];
|
|
puVar20[5] = (ulong)puVar10;
|
|
puVar10 = puVar20;
|
|
}
|
|
puVar10[2] = uVar12;
|
|
puVar10[3] = (ulong)piVar16;
|
|
puVar10[4] = (ulong)piVar17;
|
|
*puVar10 = uVar22;
|
|
puVar10[1] = uVar21;
|
|
}
|
|
LAB_001b2e98:
|
|
if (piVar16 == (int *)0x0) {
|
|
return 0;
|
|
}
|
|
pcVar19 = (char *)(uVar12 + *(long *)(piVar16 + 4));
|
|
if (*pcVar19 != '\x01') {
|
|
return 1;
|
|
}
|
|
cVar2 = pcVar19[1];
|
|
uVar11 = base_from_cb_data(cVar2,param_3);
|
|
uVar11 = read_encoded_value_with_base(cVar2,uVar11,pcVar19 + 4,&local_78);
|
|
cVar2 = pcVar19[2];
|
|
if ((cVar2 == -1) || (pcVar19[3] != ';')) {
|
|
pcVar23 = (char *)*param_3;
|
|
}
|
|
else {
|
|
uVar13 = base_from_cb_data(cVar2,param_3);
|
|
piVar14 = (int *)read_encoded_value_with_base(cVar2,uVar13,uVar11,&local_70);
|
|
if (local_70 == 0) {
|
|
return 1;
|
|
}
|
|
pcVar23 = (char *)*param_3;
|
|
uVar12 = (ulong)((uint)piVar14 & 3);
|
|
if (((ulong)piVar14 & 3) == 0) {
|
|
if (pcVar23 < pcVar19 + *piVar14) {
|
|
return 1;
|
|
}
|
|
piVar16 = piVar14 + (local_70 - 1) * 2;
|
|
uVar21 = local_70 - 1;
|
|
if (pcVar23 < pcVar19 + *piVar16) {
|
|
do {
|
|
uVar22 = uVar21;
|
|
if (uVar22 <= uVar12) {
|
|
/* WARNING: Subroutine does not return */
|
|
_Unwind_IteratePhdrCallback_cold();
|
|
}
|
|
uVar18 = uVar12 + uVar22 >> 1;
|
|
piVar16 = piVar14 + uVar18 * 2;
|
|
uVar21 = uVar18;
|
|
} while ((pcVar23 < pcVar19 + *piVar16) ||
|
|
(uVar12 = uVar18 + 1, uVar21 = uVar22, pcVar19 + piVar14[uVar18 * 2 + 2] <= pcVar23)
|
|
);
|
|
}
|
|
pcVar23 = pcVar19 + piVar16[1];
|
|
bVar8 = get_cie_encoding(pcVar23 + (4 - (long)*(int *)(pcVar23 + 4)));
|
|
uVar9 = size_of_encoded_value(bVar8);
|
|
read_encoded_value_with_base(bVar8 & 0xf,0,pcVar23 + (ulong)uVar9 + 8,&local_68);
|
|
iVar3 = *piVar16;
|
|
if ((char *)*param_3 < pcVar19 + iVar3 + local_68) {
|
|
param_3[4] = (ulong)pcVar23;
|
|
}
|
|
param_3[3] = (ulong)(pcVar19 + iVar3);
|
|
return 1;
|
|
}
|
|
}
|
|
local_60 = param_3[1];
|
|
local_68 = 0;
|
|
local_48 = 4;
|
|
local_58 = param_3[2];
|
|
local_50 = local_78;
|
|
uVar12 = linear_search_fdes(&local_68,local_78,pcVar23);
|
|
param_3[4] = uVar12;
|
|
if (uVar12 != 0) {
|
|
uVar7 = get_cie_encoding((uVar12 + 4) - (long)*(int *)(uVar12 + 4));
|
|
uVar11 = base_from_cb_data(uVar7,param_3);
|
|
read_encoded_value_with_base(uVar7,uVar11,param_3[4] + 8,&local_70);
|
|
param_3[3] = local_70;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
// 001b3210 fde_mixed_encoding_compare
|
|
|
|
int fde_mixed_encoding_compare(undefined8 param_1,long param_2,long param_3)
|
|
|
|
{
|
|
undefined1 uVar1;
|
|
int iVar2;
|
|
undefined8 uVar3;
|
|
ulong local_38;
|
|
ulong local_30 [2];
|
|
|
|
uVar1 = get_cie_encoding((param_2 + 4) - (long)*(int *)(param_2 + 4));
|
|
uVar3 = base_from_object(uVar1,param_1);
|
|
read_encoded_value_with_base(uVar1,uVar3,param_2 + 8,&local_38);
|
|
uVar1 = get_cie_encoding((param_3 + 4) - (long)*(int *)(param_3 + 4));
|
|
uVar3 = base_from_object(uVar1,param_1);
|
|
read_encoded_value_with_base(uVar1,uVar3,param_3 + 8,local_30);
|
|
iVar2 = 1;
|
|
if (local_38 <= local_30[0]) {
|
|
iVar2 = -(uint)(local_38 < local_30[0]);
|
|
}
|
|
return iVar2;
|
|
}
|
|
|
|
|
|
// 001b32b0 classify_object_over_fdes
|
|
|
|
long classify_object_over_fdes(ulong *param_1,uint *param_2)
|
|
|
|
{
|
|
ushort uVar1;
|
|
uint uVar2;
|
|
undefined8 uVar3;
|
|
long lVar4;
|
|
ulong uVar5;
|
|
long lVar6;
|
|
uint uVar7;
|
|
long local_50;
|
|
ulong local_40 [2];
|
|
|
|
if (*param_2 == 0) {
|
|
local_50 = 0;
|
|
}
|
|
else {
|
|
uVar3 = 0;
|
|
local_50 = 0;
|
|
uVar2 = 0;
|
|
lVar4 = 0;
|
|
do {
|
|
lVar6 = lVar4;
|
|
if (param_2[1] != 0) {
|
|
uVar7 = uVar2 & 0xff;
|
|
lVar6 = (long)param_2 + (4 - (long)(int)param_2[1]);
|
|
if (lVar6 != lVar4) {
|
|
uVar2 = get_cie_encoding(lVar6);
|
|
if (uVar2 == 0xff) {
|
|
return -1;
|
|
}
|
|
uVar7 = uVar2 & 0xff;
|
|
uVar3 = base_from_object(uVar7,param_1);
|
|
uVar1 = (ushort)param_1[4];
|
|
if ((uVar1 & 0x7f8) == 0x7f8) {
|
|
*(ushort *)(param_1 + 4) = uVar1 & 0xf807 | (ushort)((uVar2 & 0xff) << 3);
|
|
}
|
|
else if ((byte)(uVar1 >> 3) != uVar2) {
|
|
*(byte *)(param_1 + 4) = (byte)param_1[4] | 4;
|
|
}
|
|
}
|
|
read_encoded_value_with_base(uVar7,uVar3,param_2 + 2,local_40);
|
|
uVar7 = size_of_encoded_value(uVar7);
|
|
uVar5 = 0xffffffffffffffff;
|
|
if (uVar7 < 8) {
|
|
uVar5 = (1L << ((char)uVar7 * '\b' & 0x3fU)) - 1;
|
|
}
|
|
if (((local_40[0] & uVar5) != 0) && (local_50 = local_50 + 1, local_40[0] < *param_1)) {
|
|
*param_1 = local_40[0];
|
|
}
|
|
}
|
|
param_2 = (uint *)((long)param_2 + (ulong)*param_2 + 4);
|
|
lVar4 = lVar6;
|
|
} while (*param_2 != 0);
|
|
}
|
|
return local_50;
|
|
}
|
|
|
|
|
|
// 001b3400 add_fdes
|
|
|
|
void add_fdes(long param_1,long *param_2,uint *param_3)
|
|
|
|
{
|
|
long lVar1;
|
|
uint uVar2;
|
|
uint uVar3;
|
|
undefined8 uVar4;
|
|
long lVar5;
|
|
ulong uVar6;
|
|
byte bVar7;
|
|
long lVar8;
|
|
ulong local_40 [2];
|
|
|
|
bVar7 = (byte)(*(ushort *)(param_1 + 0x20) >> 3);
|
|
uVar2 = (uint)bVar7;
|
|
uVar4 = base_from_object(bVar7,param_1);
|
|
if (*param_3 != 0) {
|
|
lVar8 = 0;
|
|
do {
|
|
while (param_3[1] != 0) {
|
|
if (((*(byte *)(param_1 + 0x20) & 4) != 0) &&
|
|
(lVar5 = (long)param_3 + (4 - (long)(int)param_3[1]), lVar5 != lVar8)) {
|
|
uVar2 = get_cie_encoding(lVar5);
|
|
uVar4 = base_from_object((char)uVar2,param_1);
|
|
lVar8 = lVar5;
|
|
}
|
|
if (uVar2 == 0) {
|
|
if (*(long *)(param_3 + 2) != 0) goto LAB_001b344f;
|
|
break;
|
|
}
|
|
read_encoded_value_with_base(uVar2 & 0xff,uVar4,param_3 + 2,local_40);
|
|
uVar3 = size_of_encoded_value(uVar2 & 0xff);
|
|
uVar6 = 0xffffffffffffffff;
|
|
if (uVar3 < 8) {
|
|
uVar6 = (1L << ((char)uVar3 * '\b' & 0x3fU)) - 1;
|
|
}
|
|
if ((local_40[0] & uVar6) != 0) {
|
|
LAB_001b344f:
|
|
lVar5 = *param_2;
|
|
if (lVar5 != 0) {
|
|
lVar1 = *(long *)(lVar5 + 8);
|
|
*(long *)(lVar5 + 8) = lVar1 + 1;
|
|
*(uint **)(lVar5 + 0x10 + lVar1 * 8) = param_3;
|
|
}
|
|
break;
|
|
}
|
|
param_3 = (uint *)((long)param_3 + (ulong)*param_3 + 4);
|
|
if (*param_3 == 0) {
|
|
return;
|
|
}
|
|
}
|
|
param_3 = (uint *)((long)param_3 + (ulong)*param_3 + 4);
|
|
} while (*param_3 != 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3530 search_object
|
|
|
|
long search_object(ulong *param_1,ulong param_2)
|
|
|
|
{
|
|
long *plVar1;
|
|
ulong *puVar2;
|
|
size_t __size;
|
|
undefined8 *puVar3;
|
|
ulong *puVar4;
|
|
void *pvVar5;
|
|
byte bVar6;
|
|
int iVar7;
|
|
ulong uVar8;
|
|
long lVar9;
|
|
undefined8 uVar10;
|
|
undefined8 uVar11;
|
|
ulong uVar12;
|
|
undefined1 uVar13;
|
|
ushort uVar14;
|
|
ulong uVar15;
|
|
long *plVar16;
|
|
code *pcVar17;
|
|
long lVar18;
|
|
ulong uVar19;
|
|
undefined8 *puVar20;
|
|
ulong local_78;
|
|
ulong local_50;
|
|
ulong *local_48;
|
|
void *local_40;
|
|
|
|
bVar6 = (byte)param_1[4];
|
|
if ((bVar6 & 1) != 0) goto LAB_001b3552;
|
|
local_78 = (ulong)((uint)param_1[4] >> 0xb);
|
|
if (local_78 == 0) {
|
|
plVar16 = (long *)param_1[3];
|
|
if ((bVar6 & 2) == 0) {
|
|
local_78 = classify_object_over_fdes();
|
|
if (local_78 != 0xffffffffffffffff) goto LAB_001b3737;
|
|
LAB_001b362a:
|
|
param_1[4] = 0x7f8;
|
|
param_1[3] = (ulong)&terminator_9976;
|
|
}
|
|
else {
|
|
local_78 = 0;
|
|
if (*plVar16 != 0) {
|
|
do {
|
|
lVar9 = classify_object_over_fdes(param_1);
|
|
if (lVar9 == -1) goto LAB_001b362a;
|
|
plVar1 = plVar16 + 1;
|
|
plVar16 = plVar16 + 1;
|
|
local_78 = local_78 + lVar9;
|
|
} while (*plVar1 != 0);
|
|
LAB_001b3737:
|
|
if ((local_78 & 0xffffffffffe00000) == 0) {
|
|
*(uint *)(param_1 + 4) = (uint)param_1[4] & 0x7ff | (int)local_78 << 0xb;
|
|
}
|
|
else {
|
|
*(uint *)(param_1 + 4) = (uint)param_1[4] & 0x7ff;
|
|
}
|
|
if (local_78 != 0) goto LAB_001b38a0;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
LAB_001b38a0:
|
|
__size = local_78 * 8 + 0x10;
|
|
local_48 = malloc(__size);
|
|
if (local_48 != (ulong *)0x0) {
|
|
local_48[1] = 0;
|
|
local_40 = malloc(__size);
|
|
if (local_40 != (void *)0x0) {
|
|
*(undefined8 *)((long)local_40 + 8) = 0;
|
|
}
|
|
plVar16 = (long *)param_1[3];
|
|
if ((param_1[4] & 2) == 0) {
|
|
add_fdes(param_1,&local_48,plVar16);
|
|
}
|
|
else {
|
|
if (*plVar16 == 0) goto search_object_cold;
|
|
do {
|
|
plVar16 = plVar16 + 1;
|
|
add_fdes(param_1);
|
|
} while (*plVar16 != 0);
|
|
}
|
|
pvVar5 = local_40;
|
|
puVar4 = local_48;
|
|
if ((local_48 != (ulong *)0x0) && (local_48[1] != local_78)) {
|
|
search_object_cold:
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
pcVar17 = fde_mixed_encoding_compare;
|
|
if (((param_1[4] & 4) == 0) && (pcVar17 = fde_unencoded_compare, (param_1[4] & 0x7f8) != 0)) {
|
|
pcVar17 = fde_single_encoding_compare;
|
|
}
|
|
if (local_40 == (void *)0x0) {
|
|
frame_heapsort(param_1,pcVar17,local_48);
|
|
}
|
|
else {
|
|
uVar15 = local_48[1];
|
|
if (uVar15 == 0) {
|
|
lVar9 = 0;
|
|
uVar12 = 0;
|
|
}
|
|
else {
|
|
puVar20 = &marker_9870;
|
|
puVar2 = local_48 + 2;
|
|
lVar9 = 0x10;
|
|
while( true ) {
|
|
*(undefined8 **)((long)pvVar5 + lVar9) = puVar20;
|
|
puVar20 = (undefined8 *)((long)puVar4 + lVar9);
|
|
if (uVar15 * 8 + 8 == lVar9) break;
|
|
if (puVar20 != &marker_9870) {
|
|
do {
|
|
iVar7 = (*pcVar17)(param_1,*(undefined8 *)((long)puVar4 + lVar9 + 8),*puVar20);
|
|
if (-1 < iVar7) goto LAB_001b3a2c;
|
|
puVar3 = *(undefined8 **)((long)pvVar5 + (long)puVar20 + (0x10 - (long)puVar2));
|
|
*(undefined8 *)((long)pvVar5 + (long)puVar20 + (0x10 - (long)puVar2)) = 0;
|
|
puVar20 = puVar3;
|
|
} while (puVar3 != &marker_9870);
|
|
}
|
|
puVar20 = &marker_9870;
|
|
LAB_001b3a2c:
|
|
lVar9 = lVar9 + 8;
|
|
}
|
|
lVar9 = 0;
|
|
uVar12 = 0;
|
|
uVar8 = 0;
|
|
do {
|
|
if (*(long *)((long)pvVar5 + uVar8 * 8 + 0x10) == 0) {
|
|
*(ulong *)((long)pvVar5 + lVar9 * 8 + 0x10) = puVar4[uVar8 + 2];
|
|
lVar9 = lVar9 + 1;
|
|
}
|
|
else {
|
|
puVar4[uVar12 + 2] = puVar4[uVar8 + 2];
|
|
uVar12 = uVar12 + 1;
|
|
}
|
|
uVar8 = uVar8 + 1;
|
|
} while (uVar15 != uVar8);
|
|
}
|
|
puVar4[1] = uVar12;
|
|
*(long *)((long)pvVar5 + 8) = lVar9;
|
|
if (*(long *)((long)local_40 + 8) + local_48[1] != local_78) goto search_object_cold;
|
|
frame_heapsort(param_1,pcVar17,local_40);
|
|
pvVar5 = local_40;
|
|
puVar4 = local_48;
|
|
local_78 = *(long *)((long)local_40 + 8);
|
|
if (local_78 != 0) {
|
|
uVar15 = local_48[1];
|
|
do {
|
|
lVar9 = local_78 + -1;
|
|
puVar2 = (ulong *)((long)pvVar5 + local_78 * 8);
|
|
uVar12 = puVar2[1];
|
|
if (uVar15 == 0) {
|
|
puVar4[local_78 + 1] = uVar12;
|
|
if (lVar9 == 0) break;
|
|
lVar18 = local_78 + -2;
|
|
uVar12 = *puVar2;
|
|
local_78 = lVar18;
|
|
}
|
|
else {
|
|
lVar18 = (uVar15 - 1) + local_78;
|
|
do {
|
|
uVar8 = uVar15 - 1;
|
|
iVar7 = (*pcVar17)(param_1,puVar4[uVar15 + 1],uVar12);
|
|
local_78 = lVar9;
|
|
if (iVar7 < 1) goto LAB_001b3b50;
|
|
puVar4[lVar18 + 2] = puVar4[uVar15 + 1];
|
|
lVar18 = lVar18 + -1;
|
|
uVar15 = uVar8;
|
|
} while (uVar8 != 0);
|
|
uVar15 = 0;
|
|
lVar18 = lVar9;
|
|
}
|
|
LAB_001b3b50:
|
|
puVar4[lVar18 + 2] = uVar12;
|
|
} while (local_78 != 0);
|
|
puVar4[1] = puVar4[1] + *(long *)((long)pvVar5 + 8);
|
|
}
|
|
free(local_40);
|
|
}
|
|
*local_48 = param_1[3];
|
|
*(byte *)(param_1 + 4) = (byte)param_1[4] | 1;
|
|
param_1[3] = (ulong)local_48;
|
|
}
|
|
}
|
|
if (param_2 < *param_1) {
|
|
return 0;
|
|
}
|
|
bVar6 = (byte)param_1[4];
|
|
plVar16 = (long *)param_1[3];
|
|
if ((bVar6 & 1) == 0) {
|
|
if ((bVar6 & 2) == 0) {
|
|
lVar9 = linear_search_fdes(param_1,plVar16,param_2);
|
|
return lVar9;
|
|
}
|
|
lVar9 = *plVar16;
|
|
while( true ) {
|
|
if (lVar9 == 0) {
|
|
return 0;
|
|
}
|
|
lVar9 = linear_search_fdes(param_1,lVar9,param_2);
|
|
if (lVar9 != 0) break;
|
|
lVar9 = plVar16[1];
|
|
plVar16 = plVar16 + 1;
|
|
}
|
|
return lVar9;
|
|
}
|
|
LAB_001b3552:
|
|
uVar15 = param_1[3];
|
|
if ((bVar6 & 4) == 0) {
|
|
if (((ushort)param_1[4] & 0x7f8) == 0) {
|
|
uVar12 = 0;
|
|
uVar8 = *(ulong *)(uVar15 + 8);
|
|
while (uVar19 = uVar8, uVar12 < uVar19) {
|
|
while( true ) {
|
|
uVar8 = uVar19 + uVar12 >> 1;
|
|
lVar9 = *(long *)(uVar15 + 0x10 + uVar8 * 8);
|
|
if (param_2 < *(ulong *)(lVar9 + 8)) break;
|
|
if (param_2 < *(ulong *)(lVar9 + 8) + *(long *)(lVar9 + 0x10)) {
|
|
return lVar9;
|
|
}
|
|
uVar12 = uVar8 + 1;
|
|
if (uVar19 <= uVar12) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
uVar14 = (ushort)param_1[4] >> 3;
|
|
uVar13 = (undefined1)uVar14;
|
|
uVar10 = base_from_object(uVar13,param_1);
|
|
if (*(ulong *)(uVar15 + 8) != 0) {
|
|
uVar12 = 0;
|
|
uVar8 = *(ulong *)(uVar15 + 8);
|
|
do {
|
|
uVar19 = uVar8 + uVar12 >> 1;
|
|
lVar9 = *(long *)(uVar15 + 0x10 + uVar19 * 8);
|
|
uVar11 = read_encoded_value_with_base(uVar13,uVar10,lVar9 + 8,&local_50);
|
|
read_encoded_value_with_base(uVar14 & 0xf,0,uVar11,&local_48);
|
|
if (local_50 <= param_2) {
|
|
if (param_2 < local_50 + (long)local_48) {
|
|
return lVar9;
|
|
}
|
|
uVar12 = uVar19 + 1;
|
|
uVar19 = uVar8;
|
|
}
|
|
uVar8 = uVar19;
|
|
} while (uVar12 < uVar19);
|
|
}
|
|
}
|
|
}
|
|
else if (*(ulong *)(uVar15 + 8) != 0) {
|
|
uVar12 = 0;
|
|
uVar8 = *(ulong *)(uVar15 + 8);
|
|
do {
|
|
uVar19 = uVar12 + uVar8 >> 1;
|
|
lVar9 = *(long *)(uVar15 + 0x10 + uVar19 * 8);
|
|
bVar6 = get_cie_encoding((lVar9 + 4) - (long)*(int *)(lVar9 + 4));
|
|
uVar10 = base_from_object(bVar6,param_1);
|
|
uVar10 = read_encoded_value_with_base(bVar6,uVar10,lVar9 + 8,&local_50);
|
|
read_encoded_value_with_base(bVar6 & 0xf,0,uVar10,&local_48);
|
|
if (local_50 <= param_2) {
|
|
if (param_2 < local_50 + (long)local_48) {
|
|
return lVar9;
|
|
}
|
|
uVar12 = uVar19 + 1;
|
|
uVar19 = uVar8;
|
|
}
|
|
uVar8 = uVar19;
|
|
} while (uVar12 < uVar19);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 001b3c80 __register_frame_info_bases.part.0
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x001b3cf0) */
|
|
|
|
void __register_frame_info_bases_part_0
|
|
(undefined8 param_1,undefined8 *param_2,undefined8 param_3,undefined8 param_4)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
|
|
*param_2 = 0xffffffffffffffff;
|
|
param_2[1] = param_3;
|
|
param_2[2] = param_4;
|
|
param_2[3] = param_1;
|
|
param_2[4] = 0x7f8;
|
|
pthread_mutex_lock((pthread_mutex_t *)object_mutex);
|
|
puVar1 = param_2;
|
|
param_2[5] = unseen_objects;
|
|
unseen_objects = puVar1;
|
|
if (any_objects_registered == 0) {
|
|
any_objects_registered = 1;
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3d10 __register_frame_info_bases
|
|
|
|
void __register_frame_info_bases(int *param_1)
|
|
|
|
{
|
|
if ((param_1 != (int *)0x0) && (*param_1 != 0)) {
|
|
__register_frame_info_bases_part_0();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3d30 __register_frame_info
|
|
|
|
void __register_frame_info(int *param_1,undefined8 param_2)
|
|
|
|
{
|
|
if ((param_1 != (int *)0x0) && (*param_1 != 0)) {
|
|
__register_frame_info_bases_part_0(param_1,param_2,0,0);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3d50 __register_frame
|
|
|
|
void __register_frame(int *param_1)
|
|
|
|
{
|
|
void *pvVar1;
|
|
|
|
if (*param_1 == 0) {
|
|
return;
|
|
}
|
|
pvVar1 = malloc(0x30);
|
|
__register_frame_info_bases_part_0(param_1,pvVar1,0,0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3d80 __register_frame_info_table_bases
|
|
|
|
/* WARNING: Removing unreachable block (ram,0x001b3df0) */
|
|
|
|
void __register_frame_info_table_bases
|
|
(undefined8 param_1,undefined8 *param_2,undefined8 param_3,undefined8 param_4)
|
|
|
|
{
|
|
undefined8 *puVar1;
|
|
|
|
*param_2 = 0xffffffffffffffff;
|
|
param_2[1] = param_3;
|
|
param_2[2] = param_4;
|
|
param_2[3] = param_1;
|
|
param_2[4] = 0x7fa;
|
|
pthread_mutex_lock((pthread_mutex_t *)object_mutex);
|
|
puVar1 = param_2;
|
|
param_2[5] = unseen_objects;
|
|
unseen_objects = puVar1;
|
|
if (any_objects_registered == 0) {
|
|
any_objects_registered = 1;
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3e10 __register_frame_info_table
|
|
|
|
void __register_frame_info_table(undefined8 param_1,undefined8 param_2)
|
|
|
|
{
|
|
__register_frame_info_table_bases(param_1,param_2,0,0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3e20 __register_frame_table
|
|
|
|
void __register_frame_table(undefined8 param_1)
|
|
|
|
{
|
|
void *pvVar1;
|
|
|
|
pvVar1 = malloc(0x30);
|
|
__register_frame_info_table_bases(param_1,pvVar1,0,0);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3e40 __deregister_frame_info_bases
|
|
|
|
long __deregister_frame_info_bases(int *param_1)
|
|
|
|
{
|
|
long lVar1;
|
|
int *__ptr;
|
|
long lVar2;
|
|
undefined8 *puVar3;
|
|
long *plVar4;
|
|
|
|
if ((param_1 == (int *)0x0) || (*param_1 == 0)) {
|
|
return 0;
|
|
}
|
|
pthread_mutex_lock((pthread_mutex_t *)object_mutex);
|
|
if (unseen_objects != 0) {
|
|
plVar4 = &unseen_objects;
|
|
lVar2 = unseen_objects;
|
|
do {
|
|
lVar1 = *(long *)(lVar2 + 0x28);
|
|
if (param_1 == *(int **)(lVar2 + 0x18)) {
|
|
*plVar4 = lVar1;
|
|
goto LAB_001b3ead;
|
|
}
|
|
plVar4 = (long *)(lVar2 + 0x28);
|
|
lVar2 = lVar1;
|
|
} while (lVar1 != 0);
|
|
}
|
|
if (seen_objects != 0) {
|
|
puVar3 = &seen_objects;
|
|
lVar2 = seen_objects;
|
|
do {
|
|
__ptr = *(int **)(lVar2 + 0x18);
|
|
if ((*(byte *)(lVar2 + 0x20) & 1) == 0) {
|
|
if (param_1 == __ptr) {
|
|
*puVar3 = *(undefined8 *)(lVar2 + 0x28);
|
|
goto LAB_001b3ead;
|
|
}
|
|
}
|
|
else if (param_1 == *(int **)__ptr) {
|
|
*puVar3 = *(undefined8 *)(lVar2 + 0x28);
|
|
free(__ptr);
|
|
LAB_001b3ead:
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
return lVar2;
|
|
}
|
|
puVar3 = (undefined8 *)(lVar2 + 0x28);
|
|
lVar2 = *(long *)(lVar2 + 0x28);
|
|
} while (lVar2 != 0);
|
|
}
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
/* WARNING: Subroutine does not return */
|
|
abort();
|
|
}
|
|
|
|
|
|
// 001b3f80 __deregister_frame
|
|
|
|
void __deregister_frame(int *param_1)
|
|
|
|
{
|
|
void *__ptr;
|
|
|
|
if (*param_1 == 0) {
|
|
return;
|
|
}
|
|
__ptr = (void *)__deregister_frame_info_bases();
|
|
free(__ptr);
|
|
return;
|
|
}
|
|
|
|
|
|
// 001b3fb0 _Unwind_Find_FDE
|
|
|
|
long _Unwind_Find_FDE(ulong param_1,ulong *param_2)
|
|
|
|
{
|
|
undefined1 uVar1;
|
|
int iVar2;
|
|
undefined8 uVar3;
|
|
long lVar4;
|
|
ulong *puVar5;
|
|
ulong *puVar6;
|
|
ulong *puVar7;
|
|
ulong local_68;
|
|
ulong local_60;
|
|
ulong local_58;
|
|
ulong local_50;
|
|
long local_48;
|
|
undefined4 local_40;
|
|
|
|
if (any_objects_registered == 0) {
|
|
LAB_001b3fd2:
|
|
local_60 = 0;
|
|
local_58 = 0;
|
|
local_50 = 0;
|
|
local_48 = 0;
|
|
local_40 = 1;
|
|
local_68 = param_1;
|
|
iVar2 = dl_iterate_phdr(_Unwind_IteratePhdrCallback,&local_68);
|
|
if (iVar2 < 0) {
|
|
lVar4 = 0;
|
|
}
|
|
else {
|
|
lVar4 = local_48;
|
|
if (local_48 != 0) {
|
|
*param_2 = local_60;
|
|
param_2[1] = local_58;
|
|
param_2[2] = local_50;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
pthread_mutex_lock((pthread_mutex_t *)object_mutex);
|
|
for (puVar7 = seen_objects; puVar7 != (ulong *)0x0; puVar7 = (ulong *)puVar7[5]) {
|
|
if (*puVar7 <= param_1) {
|
|
lVar4 = search_object(puVar7,param_1);
|
|
if (lVar4 != 0) goto LAB_001b40aa;
|
|
break;
|
|
}
|
|
}
|
|
do {
|
|
puVar7 = unseen_objects;
|
|
if (unseen_objects == (ulong *)0x0) {
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
goto LAB_001b3fd2;
|
|
}
|
|
unseen_objects = (ulong *)unseen_objects[5];
|
|
lVar4 = search_object(puVar7,param_1);
|
|
puVar5 = (ulong *)&seen_objects;
|
|
puVar6 = seen_objects;
|
|
if (seen_objects != (ulong *)0x0) {
|
|
do {
|
|
if (*puVar6 < *puVar7) break;
|
|
puVar5 = puVar6 + 5;
|
|
puVar6 = (ulong *)puVar6[5];
|
|
} while (puVar6 != (ulong *)0x0);
|
|
}
|
|
puVar7[5] = (ulong)puVar6;
|
|
*puVar5 = (ulong)puVar7;
|
|
} while (lVar4 == 0);
|
|
LAB_001b40aa:
|
|
pthread_mutex_unlock((pthread_mutex_t *)object_mutex);
|
|
*param_2 = puVar7[1];
|
|
param_2[1] = puVar7[2];
|
|
if ((puVar7[4] & 4) == 0) {
|
|
uVar1 = (undefined1)((ushort)puVar7[4] >> 3);
|
|
}
|
|
else {
|
|
uVar1 = get_cie_encoding((lVar4 + 4) - (long)*(int *)(lVar4 + 4));
|
|
}
|
|
uVar3 = base_from_object(uVar1,puVar7);
|
|
read_encoded_value_with_base(uVar1,uVar3,lVar4 + 8,&local_68);
|
|
param_2[2] = local_68;
|
|
}
|
|
return lVar4;
|
|
}
|
|
|
|
|
|
// 001b41e4 _fini
|
|
|
|
void _fini(void)
|
|
|
|
{
|
|
return;
|
|
}
|
|
|
|
|