falso
/
tp
mirror of https://github.com/zeldaret/tp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

started copying code over to new disasm

This commit is contained in:
lepelog 2021-03-30 02:45:32 +02:00
parent a868b6ae56
commit e756e1760e
35 changed files with 687 additions and 793 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -75,7 +75,8 @@ INCLUDES := -i include -i include/dolphin/ -i src
ASFLAGS := -mgekko -I include
# Linker flags
LDFLAGS := -unused -map $(MAP) -fp hard -nodefaults -w on
# LDFLAGS := -unused -map $(MAP) -fp hard -nodefaults -w on
LDFLAGS := -map $(MAP) -fp hard -nodefaults -w on
# Compiler flags
CFLAGS += -Cpp_exceptions off -proc gekko -fp hard -O3 -nodefaults -msgstyle gcc -str pool,readonly,reuse -RTTI off -maxerrors 5 -enum int $(INCLUDES)

2
asm/SSystem/SComponent/c_sxyz/__sinit_c_sxyz_cpp.s
View File

@ -10,7 +10,7 @@ lbl_8026758C:
/* 802675AC 80 01 00 08 */ lwz r0, 8(r1)
/* 802675B0 90 0D 8B E0 */ stw r0, Zero__5csXyz(r13)
/* 802675B4 A0 01 00 0C */ lhz r0, 0xc(r1)
/* 802675B8 B0 0D 8B E4 */ sth r0, data_80451164(r13)
/* 802675B8 B0 0D 8B E4 */ sth r0, Zero__5csXyz+4(r13)
/* 802675BC 38 6D 8B E0 */ la r3, Zero__5csXyz(r13) /* 80451160-_SDA_BASE_ */
/* 802675C0 3C 80 80 02 */ lis r4, __dt__5csXyzFv@ha
/* 802675C4 38 84 8B D0 */ addi r4, r4, __dt__5csXyzFv@l

2
asm/d/a/d_a_npc/update__15daNpcF_Lookat_cFP4cXyzP5csXyzPf.s
View File

@ -12,7 +12,7 @@ lbl_80151A54:
/* 80151A7C 7C DC 33 78 */ mr r28, r6
/* 80151A80 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 80151A84 90 01 00 08 */ stw r0, 8(r1)
/* 80151A88 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 80151A88 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 80151A8C B0 01 00 0C */ sth r0, 0xc(r1)
/* 80151A90 3B A0 00 00 */ li r29, 0
/* 80151A94 3B 00 00 00 */ li r24, 0

2
asm/d/d_npc_lib/action__16dNpcLib_lookat_cF4cXyz4cXyzP10fopAc_ac_cPA4_fi.s
View File

@ -392,7 +392,7 @@ lbl_80251AD8:
lbl_80251AE8:
/* 80251AE8 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 80251AEC 90 01 00 10 */ stw r0, 0x10(r1)
/* 80251AF0 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 80251AF0 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 80251AF4 B0 01 00 14 */ sth r0, 0x14(r1)
/* 80251AF8 3A C0 00 00 */ li r22, 0
/* 80251AFC 3B 20 00 00 */ li r25, 0

2
asm/d/d_npc_lib/update__16dNpcLib_lookat_cFv.s
View File

@ -9,7 +9,7 @@ lbl_80251EF8:
/* 80251F14 7C 7D 1B 78 */ mr r29, r3
/* 80251F18 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 80251F1C 90 01 00 08 */ stw r0, 8(r1)
/* 80251F20 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 80251F20 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 80251F24 B0 01 00 0C */ sth r0, 0xc(r1)
/* 80251F28 3B C0 00 00 */ li r30, 0
/* 80251F2C 3B 80 00 00 */ li r28, 0

2
asm/f_op/f_op_actor_mng/fopAcM_createItemForMidBoss__FPC4cXyziiPC5csXyzPC4cXyzii.s
View File

@ -6,7 +6,7 @@ lbl_8001C174:
/* 8001C184 7C E8 3B 78 */ mr r8, r7
/* 8001C188 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 8001C18C 90 01 00 08 */ stw r0, 8(r1)
/* 8001C190 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 8001C190 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 8001C194 B0 01 00 0C */ sth r0, 0xc(r1)
/* 8001C198 7D 25 4B 78 */ mr r5, r9
/* 8001C19C 38 E1 00 08 */ addi r7, r1, 8

2
asm/f_op/f_op_actor_mng/fopAcM_createItem__FPC4cXyziiiPC5csXyzPC4cXyzi.s
View File

@ -18,7 +18,7 @@ lbl_8001C240:
lbl_8001C280:
/* 8001C280 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 8001C284 90 01 00 08 */ stw r0, 8(r1)
/* 8001C288 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 8001C288 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 8001C28C B0 01 00 0C */ sth r0, 0xc(r1)
/* 8001C290 28 1E 00 00 */ cmplwi r30, 0
/* 8001C294 41 82 00 20 */ beq lbl_8001C2B4

2
asm/f_op/f_op_actor_mng/fopAcM_fastCreateItem2__FPC4cXyziiiiPC5csXyzPC4cXyz.s
View File

@ -13,7 +13,7 @@ lbl_8001C3E0:
/* 8001C40C 7D 3F 4B 78 */ mr r31, r9
/* 8001C410 80 0D 8B E0 */ lwz r0, Zero__5csXyz(r13)
/* 8001C414 90 01 00 10 */ stw r0, 0x10(r1)
/* 8001C418 A0 0D 8B E4 */ lhz r0, data_80451164(r13)
/* 8001C418 A0 0D 8B E4 */ lhz r0, Zero__5csXyz+4(r13)
/* 8001C41C B0 01 00 14 */ sth r0, 0x14(r1)
/* 8001C420 2C 1C 00 FF */ cmpwi r28, 0xff
/* 8001C424 40 82 00 0C */ bne lbl_8001C430

14
include/SSystem/SComponent/c_list.h
View File

@ -2,5 +2,19 @@
#define C_LIST_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_node.h"
typedef struct node_list_class {
node_class* mpHead;
node_class* mpTail;
int mSize;
} node_list_class;
void cLs_Init(node_list_class* pList);
int cLs_SingleCut(node_class* pNode);
int cLs_Addition(node_list_class* pList, node_class* pNode);
int cLs_Insert(node_list_class* pList, int idx, node_class* pNode);
node_class* cLs_GetFirst(node_list_class* pList);
void cLs_Create(node_list_class* pList);
#endif /* C_LIST_H */

5
include/SSystem/SComponent/c_list_iter.h
View File

@ -2,5 +2,10 @@
#define C_LIST_ITER_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_list.h"
#include "SSystem/SComponent/c_node_iter.h"
int cLsIt_Method(node_list_class* pList, cNdIt_MethodFunc pMethod, void* pUserData);
void* cLsIt_Judge(node_list_class* pList, cNdIt_JudgeFunc pJudge, void* pUserData);
#endif /* C_LIST_ITER_H */

13
include/SSystem/SComponent/c_malloc.h
View File

@ -3,4 +3,17 @@
#include "dolphin/types.h"
// TODO: move to correct include
struct JKRHeap {
/* 802CE4D4 */ void *alloc(u32, int);
/* 802CE548 */ void free(void*);
};
struct cMl {
static JKRHeap *Heap;
/* 80263220 */ static void init(JKRHeap*);
/* 80263228 */ static void *memalignB(int, u32);
/* 80263260 */ static void free(void*);
};
#endif /* C_MALLOC_H */

13
include/SSystem/SComponent/c_math.h
View File

@ -3,4 +3,17 @@
#include "dolphin/types.h"
s16 cM_rad2s(float);
u16 U_GetAtanTable(float, float);
s16 cM_atan2s(float, float);
float cM_atan2f(float, float);
void cM_initRnd(int, int, int);
float cM_rnd(void);
float cM_rndF(float);
float cM_rndFX(float);
void cM_initRnd2(int, int, int);
float cM_rnd2(void);
float cM_rndF2(float);
float cM_rndFX2(float);
#endif /* C_MATH_H */

23
include/SSystem/SComponent/c_node.h
View File

@ -3,4 +3,27 @@
#include "dolphin/types.h"
typedef struct node_class {
struct node_class* mpPrevNode;
void* mpData;
struct node_class* mpNextNode;
} node_class;
void cNd_Join(node_class* pA, node_class* pB);
int cNd_LengthOf(node_class* pNode);
node_class* cNd_First(node_class* pNode);
node_class* cNd_Last(node_class* pNode);
node_class* cNd_Order(node_class* pNode, int idx);
void cNd_SingleCut(node_class* pNode);
void cNd_Cut(node_class* pNode);
void cNd_Addition(node_class* pA, node_class* pB);
void cNd_Insert(node_class* pA, node_class* pB);
void cNd_SetObject(node_class* pNode, void* pData);
void cNd_ClearObject(node_class* pNode);
void cNd_ForcedClear(node_class* pNode);
void cNd_Create(node_class* pNode, void* pData);
#define NODE_GET_PREV(pNode) (pNode ? pNode->mpPrevNode : NULL)
#define NODE_GET_NEXT(pNode) (pNode ? pNode->mpNextNode : NULL)
#endif /* C_NODE_H */

7
include/SSystem/SComponent/c_node_iter.h
View File

@ -2,5 +2,12 @@
#define C_NODE_ITER_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_node.h"
typedef int (*cNdIt_MethodFunc)(node_class* pNode, void* pUserData);
int cNdIt_Method(node_class* pNode, cNdIt_MethodFunc pMethod, void* pUserData);
typedef void* (*cNdIt_JudgeFunc)(node_class* pNode, void* pUserData);
void* cNdIt_Judge(node_class* pNode, cNdIt_JudgeFunc pJudge, void* pUserData);
#endif /* C_NODE_ITER_H */

24
include/SSystem/SComponent/c_phase.h
View File

@ -3,4 +3,28 @@
#include "dolphin/types.h"
typedef int (*cPhs__Handler)(void*);
enum cPhs__Step {
cPhs_ZERO_e = 0x00,
// names from Wind Waker debug strings
cPhs_COMPLEATE_e = 0x04,
cPhs_ERROR_e = 0x05,
cPhs_NEXT_e = 0x06,
};
typedef struct request_of_phase_process_class {
cPhs__Handler* mpHandlerTable;
int mPhaseStep;
} request_of_phase_process_class;
void cPhs_Reset(request_of_phase_process_class* pPhase);
void cPhs_Set(request_of_phase_process_class* pPhase, cPhs__Handler* pHandlerTable);
void cPhs_UnCompleate(request_of_phase_process_class* pPhase);
int cPhs_Compleate(request_of_phase_process_class* pPhase);
int cPhs_Next(request_of_phase_process_class* pPhase);
int cPhs_Do(request_of_phase_process_class* pPhase, void* pUserData);
int cPhs_Handler(request_of_phase_process_class* pPhase, cPhs__Handler* pHandlerTable,
void* pUserData);
#endif /* C_PHASE_H */

18
include/SSystem/SComponent/c_tag.h
View File

@ -2,5 +2,23 @@
#define C_TAG_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_list.h"
#include "SSystem/SComponent/c_node.h"
#include "SSystem/SComponent/c_tree.h"
typedef struct create_tag_class {
node_class mpNode;
void* mpTagData;
s8 mbIsUse;
} create_tag_class;
int cTg_IsUse(create_tag_class* pTag);
int cTg_SingleCutFromTree(create_tag_class* pTag);
int cTg_AdditionToTree(node_lists_tree_class* pTree, int listIdx, create_tag_class* pTag);
int cTg_InsertToTree(node_lists_tree_class* pTree, int listIdx, create_tag_class* pTag, int idx);
node_class* cTg_GetFirst(node_list_class* pTag);
int cTg_SingleCut(create_tag_class* pTag);
int cTg_Addition(node_list_class* pList, create_tag_class* pTag);
void cTg_Create(create_tag_class* pTag, void* pData);
#endif /* C_TAG_H */

16
include/SSystem/SComponent/c_tag_iter.h
View File

@ -2,5 +2,21 @@
#define C_TAG_ITER_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_node_iter.h"
#include "SSystem/SComponent/c_tag.h"
typedef struct method_filter {
cNdIt_MethodFunc mpMethodFunc;
void* mpUserData;
} method_filter;
typedef struct judge_filter {
cNdIt_JudgeFunc mpJudgeFunc;
void* mpUserData;
} judge_filter;
int cTgIt_MethodCall(create_tag_class* pTag, method_filter* pMethodFilter);
void* cTgIt_JudgeFilter(create_tag_class* pTag, judge_filter* pJudgeFilter);
#endif /* C_TAG_ITER_H */

12
include/SSystem/SComponent/c_tree.h
View File

@ -2,5 +2,17 @@
#define C_TREE_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_list.h"
#include "SSystem/SComponent/c_node.h"
typedef struct node_lists_tree_class {
node_list_class* mpLists;
int mNumLists;
} node_lists_tree_class;
int cTr_SingleCut(node_class* pNode);
int cTr_Addition(node_lists_tree_class* pTree, int listIdx, node_class* pNode);
int cTr_Insert(node_lists_tree_class* pTree, int listIdx, node_class* pNode, int idx);
void cTr_Create(node_lists_tree_class* pTree, node_list_class* pLists, int numLists);
#endif /* C_TREE_H */

6
include/SSystem/SComponent/c_tree_iter.h
View File

@ -2,5 +2,11 @@
#define C_TREE_ITER_H
#include "dolphin/types.h"
#include "SSystem/SComponent/c_node_iter.h"
#include "SSystem/SComponent/c_tree.h"
int cTrIt_Method(node_lists_tree_class* pTree, cNdIt_MethodFunc pJudgeFunc, void* pUserData);
void* cTrIt_Judge(node_lists_tree_class* pTree, cNdIt_JudgeFunc pJudgeFunc, void* pUserData);
#endif /* C_TREE_ITER_H */

64
include/msl_c/math.h Normal file
View File

@ -0,0 +1,64 @@
#ifndef MSL_MATH_H_
#define MSL_MATH_H_
#include "dolphin/types.h"
extern "C" {
f64 acos(f64);
f32 acosf(f32);
f64 asin(f64);
f64 atan(f64);
f64 atan2(f64);
f64 ceil(f64);
f64 copysign(f64, f64);
f64 cos(f64);
f32 cosf(f32);
f64 exp(f64);
extern f32 __fabsf(f32);
inline f64 fabs(f64 f) {
return __fabsf(f);
}
inline f64 fabsf2(f32 f) {
return __fabsf(f);
}
inline f32 fabsf(f32 f) {
return fabsf2(f);
}
f64 floor(f64);
f64 fmod(f64, f64);
inline f32 fmodf(f32 f1, f32 f2) {
return fmod(f1, f2);
}
inline s32 fpclassify(f32 f) {
u32 var = *(u32*)&f;
switch (var & 0x7F800000) {
case 0x7F800000:
if ((var & 0x7FFFFF) != 0) {
return 1;
} else {
return 2;
}
case 0:
if ((var & 0x7FFFFF) != 0) {
return 5;
} else {
return 3;
}
default:
return 4;
}
}
f64 frexp(f64, s32*);
f64 ldexp(f64, s32);
f64 modf(f64, f64*);
f64 pow(f64, f64);
f64 sin(f64);
f32 sinf(f32);
f64 sqrt(f64);
f64 tan(f64);
f32 tanf(f32);
}
#endif

20
include/msl_c/string.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef MSL_STRING_H_
#define MSL_STRING_H_
#include "dolphin/types.h"
extern "C" {
void memcpy(void*, const void*, s32);
void* memset(void* dest, int ch, u32 count);
char* strrchr(const char* s, int c);
char* strchr(const char* s, int c);
int strncmp(const char* s1, const char* s2, u32 n);
int strcmp(const char* s1, const char* s2);
char* strcat(char* dest, const char* source);
char* strncpy(char* dest, const char* source, u32 n);
char* strcpy(char* dest, const char* source);
u32 strlen(const char* s);
int tolower(int);
}
#endif

65
include/mtx_vec.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef MTX_VEC_H_
#define MTX_VEC_H_
#include "dolphin/types.h"
struct Vec {
float x, y, z;
float GetX() const { return x; }
float GetY() const { return y; }
float GetZ() const { return z; }
float getXDiff(const Vec* other) const { return x - other->x; }
float getYDiff(const Vec* other) const { return y - other->y; }
float getZDiff(const Vec* other) const { return z - other->z; }
};
struct Quaternion {
float x, y, z, w;
};
typedef float Mtx[3][4];
extern "C" {
void PSMTXIdentity(Mtx matrix);
void PSMTXCopy(const Mtx src, Mtx dst);
void PSMTXConcat(const Mtx src_a, const Mtx src_b, Mtx dst);
u32 PSMTXInverse(const Mtx src, Mtx dst);
void PSMTXRotRad(Mtx matrix, u8 axis, float rad);
void PSMTXRotTrig(Mtx matrix, u8 axis, float sin, float cos);
double __PSMTXRotAxisRadInternal(double param_1, double param_2, int param_3, int param_4);
void PSMTXRotAxisRad(Mtx matrix, const Vec* axis, float rad);
void PSMTXTrans(Mtx matrix, float x_trans, float y_trans, float z_trans);
void PSMTXTransApply(const Mtx src, Mtx dst, float x, float y, float z);
void PSMTXScale(Mtx matrix, float x_scale, float y_scale, float z_scale);
void PSMTXScaleApply(const Mtx src, Mtx dst, float x_scale, float y_scale, float z_scale);
void PSMTXQuat(Mtx matrix, const Quaternion* quat);
void C_MTXLookAt(Mtx param_1, const Vec* param_2, const Vec* param_3, const Vec* param_4);
void C_MTXLightPerspective(Mtx matrix, float fov_y, float aspect, float scale_s, float scale_t,
float trans_s, float trans_t);
void C_MTXLightOrtho(Mtx matrix, float top, float bottom, float left, float right, float scale_s,
float scale_t, float trans_s, float trans_t);
void PSMTXMultVec(const Mtx matrix, const Vec* src, Vec* dst);
void PSMTXMultVecArray(const Mtx matrix, const Vec* src, Vec* dst, u32 count);
void PSMTXMultVecSR(const Mtx matrix, const Vec* src, Vec* dst);
void PSMTXMultVecArraySR(const Mtx matrix, const Vec* src, Vec* dst, u32 count);
void C_MTXPerspective(Mtx matrix, float fov_y, float aspect, float near, float far);
void C_MTXOrtho(Mtx matrix, float top, float bottom, float left, float right, float near,
float far);
void PSVECAdd(const Vec* src_a, const Vec* src_b, Vec* dst);
void PSVECSubtract(const Vec* a, const Vec* b, Vec* dst);
void PSVECScale(const Vec* src, Vec* dst, float scale);
void PSVECNormalize(const Vec* src, Vec* dst);
float PSVECSquareMag(const Vec* vec);
float PSVECMag(const Vec* data);
float PSVECDotProduct(const Vec* a, const Vec* b);
void PSVECCrossProduct(const Vec* src_a, const Vec* src_b, Vec* dst);
void C_VECHalfAngle(const Vec* incident, const Vec* line_of_sight, Vec* out_half);
void C_VECReflect(const Vec* src, const Vec* surface_normal, Vec* dst);
float PSVECSquareDistance(const Vec* a, const Vec* b);
float PSVECDistance(const Vec* a, const Vec* b);
void PSQUATMultiply(const Quaternion* src_a, const Quaternion* src_b, Quaternion* dst);
void C_QUATRotAxisRad(Quaternion* quat, const Vec* axis, float rad);
void C_QUATSlerp(const Quaternion* p, const Quaternion* q, Quaternion* r, float t);
}
#endif

4
libs/SSystem/SComponent/c_cc_s.cpp
View File

@ -175,6 +175,10 @@ extern "C" extern f32 G_CM3D_F_ABS_MIN[1 + 1 /* padding */];
// Declarations:
//
/* ############################################################################################## */
/* 80451158-80451160 0008+00 s=0 e=1 z=0 None .sbss None */
u8 data_80451158[8];
/* ############################################################################################## */
/* 803C3748-803C3778 0030+00 s=1 e=2 z=0 None .data __vt__4cCcS */
SECTION_DATA void* __vt__4cCcS[12] = {

144
libs/SSystem/SComponent/c_list.cpp
View File

@ -7,120 +7,70 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_list_class {};
struct node_class {};
//
// Forward References:
//
static void cLs_Init(node_list_class*);
void cLs_SingleCut(node_class*);
void cLs_Addition(node_list_class*, node_class*);
void cLs_Insert(node_list_class*, int, node_class*);
void cLs_GetFirst(node_list_class*);
void cLs_Create(node_list_class*);
extern "C" static void cLs_Init__FP15node_list_class();
extern "C" void cLs_SingleCut__FP10node_class();
extern "C" void cLs_Addition__FP15node_list_classP10node_class();
extern "C" void cLs_Insert__FP15node_list_classiP10node_class();
extern "C" void cLs_GetFirst__FP15node_list_class();
extern "C" void cLs_Create__FP15node_list_class();
//
// External References:
//
void cNd_LengthOf(node_class*);
void cNd_First(node_class*);
void cNd_Last(node_class*);
void cNd_Order(node_class*, int);
void cNd_SingleCut(node_class*);
void cNd_Addition(node_class*, node_class*);
void cNd_Insert(node_class*, node_class*);
void cNd_SetObject(node_class*, void*);
void cNd_ClearObject(node_class*);
extern "C" void cNd_LengthOf__FP10node_class();
extern "C" void cNd_First__FP10node_class();
extern "C" void cNd_Last__FP10node_class();
extern "C" void cNd_Order__FP10node_classi();
extern "C" void cNd_SingleCut__FP10node_class();
extern "C" void cNd_Addition__FP10node_classP10node_class();
extern "C" void cNd_Insert__FP10node_classP10node_class();
extern "C" void cNd_SetObject__FP10node_classPv();
extern "C" void cNd_ClearObject__FP10node_class();
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* 80265E64-80265E78 0014+00 s=1 e=0 z=0 None .text cLs_Init__FP15node_list_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cLs_Init(node_list_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_Init__FP15node_list_class.s"
void cLs_Init(node_list_class* pList) {
pList->mpHead = NULL;
pList->mpTail = NULL;
pList->mSize = 0;
}
#pragma pop
/* 80265E78-80265EFC 0084+00 s=1 e=4 z=0 None .text cLs_SingleCut__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLs_SingleCut(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_SingleCut__FP10node_class.s"
int cLs_SingleCut(node_class* pNode) {
node_list_class* pList = (node_list_class*)pNode->mpData;
if (pNode == pList->mpHead)
pList->mpHead = pNode->mpNextNode;
if (pNode == pList->mpTail)
pList->mpTail = pNode->mpPrevNode;
cNd_SingleCut(pNode);
cNd_ClearObject(pNode);
int newSize = pList->mSize - 1;
pList->mSize = newSize;
return newSize > 0;
}
#pragma pop
/* 80265EFC-80265F70 0074+00 s=1 e=4 z=0 None .text
* cLs_Addition__FP15node_list_classP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLs_Addition(node_list_class* param_0, node_class* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_Addition__FP15node_list_classP10node_class.s"
int cLs_Addition(node_list_class* pList, node_class* pNode) {
if (pList->mpTail == NULL) {
pList->mpHead = pNode;
} else {
cNd_Addition(pList->mpTail, pNode);
}
pList->mpTail = cNd_Last(pNode);
cNd_SetObject(pNode, pList);
pList->mSize = cNd_LengthOf(pList->mpHead);
return pList->mSize;
}
#pragma pop
/* 80265F70-80265FF8 0088+00 s=0 e=1 z=0 None .text cLs_Insert__FP15node_list_classiP10node_class
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLs_Insert(node_list_class* param_0, int param_1, node_class* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_Insert__FP15node_list_classiP10node_class.s"
int cLs_Insert(node_list_class* pList, int idx, node_class* pNode) {
node_class* pExisting = cNd_Order(pList->mpHead, idx);
if (pExisting == NULL) {
return cLs_Addition(pList, pNode);
} else {
cNd_SetObject(pNode, pList);
cNd_Insert(pExisting, pNode);
pList->mpHead = cNd_First(pNode);
pList->mSize = cNd_LengthOf(pList->mpHead);
return pList->mSize;
}
}
#pragma pop
/* 80265FF8-80266040 0048+00 s=0 e=1 z=0 None .text cLs_GetFirst__FP15node_list_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLs_GetFirst(node_list_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_GetFirst__FP15node_list_class.s"
node_class* cLs_GetFirst(node_list_class* pList) {
if (pList->mSize != 0) {
node_class* pHead = pList->mpHead;
cLs_SingleCut(pHead);
return pHead;
} else {
return NULL;
}
}
#pragma pop
/* 80266040-80266060 0020+00 s=0 e=4 z=0 None .text cLs_Create__FP15node_list_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLs_Create(node_list_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_list/cLs_Create__FP15node_list_class.s"
void cLs_Create(node_list_class* pList) {
cLs_Init(pList);
}
#pragma pop

55
libs/SSystem/SComponent/c_list_iter.cpp
View File

@ -7,56 +7,21 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_list_class {};
struct node_class {};
//
// Forward References:
//
void cLsIt_Method(node_list_class*, int (*)(node_class*, void*), void*);
void cLsIt_Judge(node_list_class*, void* (*)(node_class*, void*), void*);
extern "C" void cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv();
extern "C" void cLsIt_Judge__FP15node_list_classPFP10node_classPv_PvPv();
//
// External References:
//
void cNdIt_Method(node_class*, int (*)(node_class*, void*), void*);
void cNdIt_Judge(node_class*, void* (*)(node_class*, void*), void*);
extern "C" void cNdIt_Method__FP10node_classPFP10node_classPv_iPv();
extern "C" void cNdIt_Judge__FP10node_classPFP10node_classPv_PvPv();
//
// Declarations:
//
/* 80266060-80266098 0038+00 s=0 e=5 z=0 None .text
* cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLsIt_Method(node_list_class* param_0, int (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_list_iter/cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv.s"
int cLsIt_Method(node_list_class* pList, cNdIt_MethodFunc pMethod, void* pUserData) {
if (pList->mSize > 0)
return cNdIt_Method(pList->mpHead, pMethod, pUserData);
else
return 1;
}
#pragma pop
/* 80266098-802660D0 0038+00 s=0 e=4 z=0 None .text
* cLsIt_Judge__FP15node_list_classPFP10node_classPv_PvPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cLsIt_Judge(node_list_class* param_0, void* (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_list_iter/cLsIt_Judge__FP15node_list_classPFP10node_classPv_PvPv.s"
void* cLsIt_Judge(node_list_class* pList, cNdIt_JudgeFunc pJudge, void* pUserData) {
if (pList->mSize > 0)
return cNdIt_Judge(pList->mpHead, pJudge, pUserData);
else
return NULL;
}
#pragma pop

74
libs/SSystem/SComponent/c_malloc.cpp
View File

@ -7,75 +7,29 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JKRHeap {
/* 802CE4D4 */ void alloc(u32, int);
/* 802CE548 */ void free(void*);
};
struct cMl {
/* 80263220 */ void init(JKRHeap*);
/* 80263228 */ void memalignB(int, u32);
/* 80263260 */ void free(void*);
};
//
// Forward References:
//
extern "C" void init__3cMlFP7JKRHeap();
extern "C" void memalignB__3cMlFiUl();
extern "C" void free__3cMlFPv();
extern "C" extern u8 data_80451158[8];
//
// External References:
//
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 80451150-80451158 0004+04 s=3 e=0 z=0 None .sbss Heap__3cMl */
static u8 Heap__3cMl[4 + 4 /* padding */];
JKRHeap *cMl::Heap;
/* 80263220-80263228 0008+00 s=0 e=1 z=0 None .text init__3cMlFP7JKRHeap */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cMl::init(JKRHeap* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_malloc/init__3cMlFP7JKRHeap.s"
void cMl::init(JKRHeap* heap) {
Heap = heap;
}
#pragma pop
/* 80263228-80263260 0038+00 s=0 e=8 z=0 None .text memalignB__3cMlFiUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cMl::memalignB(int param_0, u32 param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_malloc/memalignB__3cMlFiUl.s"
void* cMl::memalignB(int alignment, unsigned long size) {
if (size == 0) {
return NULL;
} else {
return Heap->alloc(size, alignment);
}
}
#pragma pop
/* 80263260-8026328C 002C+00 s=0 e=4 z=0 None .text free__3cMlFPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cMl::free(void* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_malloc/free__3cMlFPv.s"
void cMl::free(void* ptr) {
if (ptr != NULL) {
Heap->free(ptr);
}
}
#pragma pop
/* ############################################################################################## */
/* 80451158-80451160 0008+00 s=0 e=1 z=0 None .sbss None */
u8 data_80451158[8];

2
libs/SSystem/SComponent/c_math.cpp
View File

@ -3,7 +3,7 @@
// Translation Unit: c_math
//
#include "SSystem/SComponent/c_math.h"
// #include "SSystem/SComponent/c_math.h"
#include "dol2asm.h"
#include "dolphin/types.h"

216
libs/SSystem/SComponent/c_node.cpp
View File

@ -7,182 +7,118 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_class {};
//
// Forward References:
//
static void cNd_Join(node_class*, node_class*);
void cNd_LengthOf(node_class*);
void cNd_First(node_class*);
void cNd_Last(node_class*);
void cNd_Order(node_class*, int);
void cNd_SingleCut(node_class*);
static void cNd_Cut(node_class*);
void cNd_Addition(node_class*, node_class*);
void cNd_Insert(node_class*, node_class*);
void cNd_SetObject(node_class*, void*);
void cNd_ClearObject(node_class*);
void cNd_ForcedClear(node_class*);
void cNd_Create(node_class*, void*);
extern "C" static void cNd_Join__FP10node_classP10node_class();
extern "C" void cNd_LengthOf__FP10node_class();
extern "C" void cNd_First__FP10node_class();
extern "C" void cNd_Last__FP10node_class();
extern "C" void cNd_Order__FP10node_classi();
extern "C" void cNd_SingleCut__FP10node_class();
extern "C" static void cNd_Cut__FP10node_class();
extern "C" void cNd_Addition__FP10node_classP10node_class();
extern "C" void cNd_Insert__FP10node_classP10node_class();
extern "C" void cNd_SetObject__FP10node_classPv();
extern "C" void cNd_ClearObject__FP10node_class();
extern "C" void cNd_ForcedClear__FP10node_class();
extern "C" void cNd_Create__FP10node_classPv();
//
// External References:
//
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* 802660D0-802660DC 000C+00 s=1 e=0 z=0 None .text cNd_Join__FP10node_classP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cNd_Join(node_class* param_0, node_class* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Join__FP10node_classP10node_class.s"
void cNd_Join(node_class* pA, node_class* pB) {
pA->mpNextNode = pB;
pB->mpPrevNode = pA;
}
#pragma pop
/* 802660DC-8026610C 0030+00 s=0 e=2 z=0 None .text cNd_LengthOf__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_LengthOf(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_LengthOf__FP10node_class.s"
int cNd_LengthOf(node_class* pNode) {
int count = 0;
while (pNode) {
count++;
pNode = NODE_GET_NEXT(pNode);
}
return count;
}
#pragma pop
/* 8026610C-8026613C 0030+00 s=0 e=1 z=0 None .text cNd_First__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_First(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_First__FP10node_class.s"
node_class* cNd_First(node_class* pNode) {
node_class* pRet = NULL;
while (pNode) {
pRet = pNode;
pNode = NODE_GET_PREV(pNode);
}
return pRet;
}
#pragma pop
/* 8026613C-8026616C 0030+00 s=1 e=1 z=0 None .text cNd_Last__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_Last(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Last__FP10node_class.s"
node_class* cNd_Last(node_class* pNode) {
node_class* pRet = NULL;
while (pNode) {
pRet = pNode;
pNode = NODE_GET_NEXT(pNode);
}
return pRet;
}
#pragma pop
/* 8026616C-802661BC 0050+00 s=0 e=1 z=0 None .text cNd_Order__FP10node_classi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_Order(node_class* param_0, int param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Order__FP10node_classi.s"
node_class* cNd_Order(node_class* pNode, int idx) {
node_class* pRet = NULL;
int i = 0;
while (i < idx && pNode) {
pRet = pNode;
i++;
pNode = NODE_GET_NEXT(pNode);
}
if (i < idx)
return pRet;
return NULL;
}
#pragma pop
/* 802661BC-802661F0 0034+00 s=0 e=1 z=0 None .text cNd_SingleCut__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_SingleCut(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_SingleCut__FP10node_class.s"
void cNd_SingleCut(node_class* pNode) {
node_class* pPrev = pNode->mpPrevNode;
node_class* pNext = pNode->mpNextNode;
if (pPrev)
pPrev->mpNextNode = pNode->mpNextNode;
if (pNext)
pNext->mpPrevNode = pNode->mpPrevNode;
pNode->mpPrevNode = NULL;
pNode->mpNextNode = NULL;
}
#pragma pop
/* 802661F0-80266210 0020+00 s=1 e=0 z=0 None .text cNd_Cut__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cNd_Cut(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Cut__FP10node_class.s"
void cNd_Cut(node_class* pNode) {
if (pNode->mpPrevNode)
pNode->mpPrevNode->mpNextNode = NULL;
pNode->mpPrevNode = NULL;
}
#pragma pop
/* 80266210-80266244 0034+00 s=1 e=1 z=0 None .text cNd_Addition__FP10node_classP10node_class
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_Addition(node_class* param_0, node_class* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Addition__FP10node_classP10node_class.s"
void cNd_Addition(node_class* pA, node_class* pB) {
node_class* pLast = cNd_Last(pA);
cNd_Join(pLast, pB);
}
#pragma pop
/* 80266244-802662B0 006C+00 s=0 e=1 z=0 None .text cNd_Insert__FP10node_classP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_Insert(node_class* param_0, node_class* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Insert__FP10node_classP10node_class.s"
void cNd_Insert(node_class* pA, node_class* pB) {
node_class* pPrev = pA->mpPrevNode;
if (pPrev == NULL) {
cNd_Addition(pB, pA);
} else {
cNd_Cut(pA);
cNd_Addition(pPrev, pB);
cNd_Addition(pB, pA);
}
}
#pragma pop
/* 802662B0-802662D8 0028+00 s=1 e=2 z=0 None .text cNd_SetObject__FP10node_classPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_SetObject(node_class* param_0, void* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_SetObject__FP10node_classPv.s"
void cNd_SetObject(node_class* pNode, void* pData) {
while (pNode) {
pNode->mpData = pData;
pNode = NODE_GET_NEXT(pNode);
}
}
#pragma pop
/* 802662D8-802662FC 0024+00 s=0 e=1 z=0 None .text cNd_ClearObject__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_ClearObject(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_ClearObject__FP10node_class.s"
void cNd_ClearObject(node_class* pNode) {
cNd_SetObject(pNode, NULL);
}
#pragma pop
/* 802662FC-80266310 0014+00 s=0 e=1 z=0 None .text cNd_ForcedClear__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_ForcedClear(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_ForcedClear__FP10node_class.s"
void cNd_ForcedClear(node_class* pNode) {
pNode->mpPrevNode = NULL;
pNode->mpNextNode = NULL;
pNode->mpData = NULL;
}
#pragma pop
/* 80266310-80266324 0014+00 s=0 e=2 z=0 None .text cNd_Create__FP10node_classPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNd_Create(node_class* param_0, void* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_node/cNd_Create__FP10node_classPv.s"
void cNd_Create(node_class* pNode, void* pData) {
pNode->mpPrevNode = NULL;
pNode->mpNextNode = NULL;
pNode->mpData = pData;
}
#pragma pop

68
libs/SSystem/SComponent/c_node_iter.cpp
View File

@ -7,53 +7,35 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_class {};
//
// Forward References:
//
void cNdIt_Method(node_class*, int (*)(node_class*, void*), void*);
void cNdIt_Judge(node_class*, void* (*)(node_class*, void*), void*);
extern "C" void cNdIt_Method__FP10node_classPFP10node_classPv_iPv();
extern "C" void cNdIt_Judge__FP10node_classPFP10node_classPv_PvPv();
//
// External References:
//
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* 80266324-802663B4 0090+00 s=0 e=1 z=0 None .text
* cNdIt_Method__FP10node_classPFP10node_classPv_iPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNdIt_Method(node_class* param_0, int (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_node_iter/cNdIt_Method__FP10node_classPFP10node_classPv_iPv.s"
int cNdIt_Method(node_class* pNode, cNdIt_MethodFunc pMethod, void* pUserData) {
int ret = 1;
node_class* pNext = NODE_GET_NEXT(pNode);
while (pNode) {
int methodRet = pMethod(pNode, pUserData);
if (!methodRet)
ret = 0;
pNode = pNext;
pNext = NODE_GET_NEXT(pNext);
}
return ret;
}
#pragma pop
/* 802663B4-80266440 008C+00 s=0 e=1 z=0 None .text
* cNdIt_Judge__FP10node_classPFP10node_classPv_PvPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cNdIt_Judge(node_class* param_0, void* (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_node_iter/cNdIt_Judge__FP10node_classPFP10node_classPv_PvPv.s"
void* cNdIt_Judge(node_class* pNode, cNdIt_JudgeFunc pJudge, void* pUserData) {
node_class* pNext = NODE_GET_NEXT(pNode);
while (pNode) {
void* pJudgeRet = pJudge(pNode, pUserData);
if (pJudgeRet != NULL)
return pJudgeRet;
pNode = pNext;
pNext = NODE_GET_NEXT(pNext);
}
return NULL;
}
#pragma pop

128
libs/SSystem/SComponent/c_phase.cpp
View File

@ -7,31 +7,9 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct request_of_phase_process_class {};
//
// Forward References:
//
void cPhs_Reset(request_of_phase_process_class*);
void cPhs_Set(request_of_phase_process_class*, int (**)(void*));
static void cPhs_UnCompleate(request_of_phase_process_class*);
static void cPhs_Compleate(request_of_phase_process_class*);
static void cPhs_Next(request_of_phase_process_class*);
void cPhs_Do(request_of_phase_process_class*, void*);
void cPhs_Handler(request_of_phase_process_class*, int (**)(void*), void*);
extern "C" void cPhs_Reset__FP30request_of_phase_process_class();
extern "C" void cPhs_Set__FP30request_of_phase_process_classPPFPv_i();
extern "C" static void cPhs_UnCompleate__FP30request_of_phase_process_class();
extern "C" static void cPhs_Compleate__FP30request_of_phase_process_class();
extern "C" static void cPhs_Next__FP30request_of_phase_process_class();
extern "C" void cPhs_Do__FP30request_of_phase_process_classPv();
extern "C" void cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv();
//
// External References:
@ -43,77 +21,97 @@ extern "C" void cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv();
/* 80266624-80266630 000C+00 s=1 e=2 z=0 None .text
* cPhs_Reset__FP30request_of_phase_process_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cPhs_Reset(request_of_phase_process_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Reset__FP30request_of_phase_process_class.s"
void cPhs_Reset(request_of_phase_process_class* pPhase) {
pPhase->mPhaseStep = 0;
}
#pragma pop
/* 80266630-80266640 0010+00 s=0 e=3 z=0 None .text
* cPhs_Set__FP30request_of_phase_process_classPPFPv_i */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cPhs_Set(request_of_phase_process_class* param_0, int (**)(void*)) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Set__FP30request_of_phase_process_classPPFPv_i.s"
void cPhs_Set(request_of_phase_process_class* pPhase, cPhs__Handler* pHandlerTable) {
pPhase->mpHandlerTable = pHandlerTable;
pPhase->mPhaseStep = 0;
}
#pragma pop
/* 80266640-80266668 0028+00 s=1 e=0 z=0 None .text
* cPhs_UnCompleate__FP30request_of_phase_process_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cPhs_UnCompleate(request_of_phase_process_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_UnCompleate__FP30request_of_phase_process_class.s"
void cPhs_UnCompleate(request_of_phase_process_class* pPhase) {
pPhase->mpHandlerTable = NULL;
cPhs_Reset(pPhase);
}
#pragma pop
/* 80266668-80266678 0010+00 s=2 e=0 z=0 None .text
* cPhs_Compleate__FP30request_of_phase_process_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cPhs_Compleate(request_of_phase_process_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Compleate__FP30request_of_phase_process_class.s"
int cPhs_Compleate(request_of_phase_process_class* pPhase) {
pPhase->mpHandlerTable = NULL;
return cPhs_COMPLEATE_e;
}
#pragma pop
/* 80266678-802666D8 0060+00 s=1 e=0 z=0 None .text cPhs_Next__FP30request_of_phase_process_class
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm static void cPhs_Next(request_of_phase_process_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Next__FP30request_of_phase_process_class.s"
int cPhs_Next(request_of_phase_process_class* pPhase) {
if (const cPhs__Handler* handlerTable = pPhase->mpHandlerTable) {
pPhase->mPhaseStep++;
cPhs__Handler handler = handlerTable[pPhase->mPhaseStep];
// Double null check here actually matters for emitted assembly.
// Wee old compilers.
if (handler == NULL || handler == NULL) {
return cPhs_Compleate(pPhase);
} else {
return 1;
}
}
return cPhs_COMPLEATE_e;
}
#pragma pop
/* 802666D8-802667AC 00D4+00 s=1 e=3 z=0 None .text cPhs_Do__FP30request_of_phase_process_classPv
*/
#if NON_MATCHING
int cPhs_Do(request_of_phase_process_class* pPhase, void* pUserData) {
if (const cPhs__Handler* pHandlerTable = pPhase->mpHandlerTable) {
// the load of pUserData seems to be slightly scrambled..
const cPhs__Handler pHandler = pHandlerTable[pPhase->mPhaseStep];
const int newStep = pHandler(pUserData);
switch (newStep) {
case 1:
return cPhs_Next(pPhase);
case 2: {
const int step2 = cPhs_Next(pPhase);
return step2 == 1 ? 2 : cPhs_COMPLEATE_e;
}
case cPhs_COMPLEATE_e:
return cPhs_Compleate(pPhase);
case 3: {
cPhs_UnCompleate(pPhase);
return 3;
}
case cPhs_ERROR_e:
cPhs_UnCompleate(pPhase);
return cPhs_ERROR_e;
}
return newStep;
} else {
return cPhs_Compleate(pPhase);
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cPhs_Do(request_of_phase_process_class* param_0, void* param_1) {
asm int cPhs_Do(request_of_phase_process_class* param_0, void* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Do__FP30request_of_phase_process_classPv.s"
}
#pragma pop
#endif
/* 802667AC-802667D4 0028+00 s=0 e=2 z=0 None .text
* cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cPhs_Handler(request_of_phase_process_class* param_0, int (**)(void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_phase/cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv.s"
int cPhs_Handler(request_of_phase_process_class* pPhase, cPhs__Handler* pHandlerTable,
void* pUserData) {
pPhase->mpHandlerTable = pHandlerTable;
return cPhs_Do(pPhase, pUserData);
}
#pragma pop

93
libs/SSystem/SComponent/c_sxyz.cpp
View File

@ -11,32 +11,28 @@
// Types:
//
struct csXyz {
/* 80018BD0 */ ~csXyz();
/* 802673F4 */ csXyz(s16, s16, s16);
/* 80267404 */ void operator+(csXyz&);
/* 8026745C */ void operator+=(csXyz&);
/* 80267490 */ void operator-(csXyz&);
/* 802674E8 */ void operator*(f32);
struct SVec {
s16 mX, mY, mZ;
};
//
// Forward References:
//
extern "C" void __ct__5csXyzFsss();
extern "C" void __pl__5csXyzFR5csXyz();
extern "C" void __apl__5csXyzFR5csXyz();
extern "C" void __mi__5csXyzFR5csXyz();
extern "C" void __ml__5csXyzFf();
extern "C" void __sinit_c_sxyz_cpp();
extern "C" extern u8 Zero__5csXyz[4];
extern "C" extern u8 data_80451164[4];
class csXyz : public SVec {
public:
static const csXyz Zero;
/* 80018BD0 */ ~csXyz() {}
/* inline */ csXyz() {}
/* inline */ csXyz(const csXyz& other) : SVec(other){};
/* 802673F4 */ csXyz(s16, s16, s16);
/* 80267404 */ csXyz operator+(csXyz&);
/* 8026745C */ void operator+=(csXyz&);
/* 80267490 */ csXyz operator-(csXyz&);
/* 802674E8 */ csXyz operator*(f32);
};
//
// External References:
//
extern "C" void __ct__5csXyzFsss();
extern "C" void __dt__5csXyzFv();
extern "C" void __register_global_object();
@ -45,58 +41,37 @@ extern "C" void __register_global_object();
//
/* 802673F4-80267404 0010+00 s=4 e=19 z=119 None .text __ct__5csXyzFsss */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm csXyz::csXyz(s16 param_0, s16 param_1, s16 param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_sxyz/__ct__5csXyzFsss.s"
csXyz::csXyz(s16 param_0, s16 param_1, s16 param_2) {
mX = param_0;
mY = param_1;
mZ = param_2;
}
#pragma pop
/* 80267404-8026745C 0058+00 s=0 e=0 z=3 None .text __pl__5csXyzFR5csXyz */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void csXyz::operator+(csXyz& param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_sxyz/__pl__5csXyzFR5csXyz.s"
csXyz csXyz::operator+(csXyz& param_0) {
return csXyz(mX + param_0.mX, mY + param_0.mY, mZ + param_0.mZ);
}
#pragma pop
/* 8026745C-80267490 0034+00 s=0 e=2 z=11 None .text __apl__5csXyzFR5csXyz */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void csXyz::operator+=(csXyz& param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_sxyz/__apl__5csXyzFR5csXyz.s"
void csXyz::operator+=(csXyz& param_0) {
mX += param_0.mX;
mY += param_0.mY;
mZ += param_0.mZ;
}
#pragma pop
/* 80267490-802674E8 0058+00 s=0 e=0 z=1 None .text __mi__5csXyzFR5csXyz */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void csXyz::operator-(csXyz& param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_sxyz/__mi__5csXyzFR5csXyz.s"
csXyz csXyz::operator-(csXyz& param_0) {
return csXyz(mX - param_0.mX, mY - param_0.mY, mZ - param_0.mZ);
}
#pragma pop
/* ############################################################################################## */
/* 804550A0-804550A8 0008+00 s=1 e=0 z=0 None .sdata2 @151 */
SECTION_SDATA2 static f64 lit_151 = 4503601774854144.0 /* cast s32 to float */;
/* 802674E8-8026758C 00A4+00 s=0 e=0 z=1 None .text __ml__5csXyzFf */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void csXyz::operator*(f32 param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_sxyz/__ml__5csXyzFf.s"
csXyz csXyz::operator*(f32 param_0) {
return csXyz(mX* param_0, mY * param_0, mZ * param_0);
}
#pragma pop
#ifdef NON_MATCHING
csXyz Zero__5csXyz = csXyz(0,0,0);
#else
/* ############################################################################################## */
/* 80430DA8-80430DB8 000C+04 s=1 e=0 z=0 None .bss @262 */
@ -117,3 +92,5 @@ extern "C" asm void __sinit_c_sxyz_cpp() {
#include "asm/SSystem/SComponent/c_sxyz/__sinit_c_sxyz_cpp.s"
}
#pragma pop
#endif

177
libs/SSystem/SComponent/c_tag.cpp
View File

@ -4,149 +4,94 @@
//
#include "SSystem/SComponent/c_tag.h"
#include "SSystem/SComponent/c_tree.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_lists_tree_class {};
struct node_list_class {};
struct node_class {};
struct create_tag_class {};
//
// Forward References:
//
void cTg_IsUse(create_tag_class*);
void cTg_SingleCutFromTree(create_tag_class*);
void cTg_AdditionToTree(node_lists_tree_class*, int, create_tag_class*);
void cTg_InsertToTree(node_lists_tree_class*, int, create_tag_class*, int);
void cTg_GetFirst(node_list_class*);
void cTg_SingleCut(create_tag_class*);
void cTg_Addition(node_list_class*, create_tag_class*);
void cTg_Create(create_tag_class*, void*);
extern "C" void cTg_IsUse__FP16create_tag_class();
extern "C" void cTg_SingleCutFromTree__FP16create_tag_class();
extern "C" void cTg_AdditionToTree__FP21node_lists_tree_classiP16create_tag_class();
extern "C" void cTg_InsertToTree__FP21node_lists_tree_classiP16create_tag_classi();
extern "C" void cTg_GetFirst__FP15node_list_class();
extern "C" void cTg_SingleCut__FP16create_tag_class();
extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class();
extern "C" void cTg_Create__FP16create_tag_classPv();
//
// External References:
//
void cLs_SingleCut(node_class*);
void cLs_Addition(node_list_class*, node_class*);
void cLs_GetFirst(node_list_class*);
void cNd_Create(node_class*, void*);
void cTr_SingleCut(node_class*);
void cTr_Addition(node_lists_tree_class*, int, node_class*);
void cTr_Insert(node_lists_tree_class*, int, node_class*, int);
extern "C" void cLs_SingleCut__FP10node_class();
extern "C" void cLs_Addition__FP15node_list_classP10node_class();
extern "C" void cLs_GetFirst__FP15node_list_class();
extern "C" void cNd_Create__FP10node_classPv();
extern "C" void cTr_SingleCut__FP10node_class();
extern "C" void cTr_Addition__FP21node_lists_tree_classiP10node_class();
extern "C" void cTr_Insert__FP21node_lists_tree_classiP10node_classi();
//
// Declarations:
//
/* 80266880-8026688C 000C+00 s=0 e=3 z=0 None .text cTg_IsUse__FP16create_tag_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_IsUse(create_tag_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_IsUse__FP16create_tag_class.s"
int cTg_IsUse(create_tag_class* pTag) {
return pTag->mbIsUse;
}
#pragma pop
/* 8026688C-802668CC 0040+00 s=0 e=4 z=0 None .text cTg_SingleCutFromTree__FP16create_tag_class
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_SingleCutFromTree(create_tag_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_SingleCutFromTree__FP16create_tag_class.s"
int cTg_SingleCutFromTree(create_tag_class* pTag) {
if (pTag->mbIsUse == true) {
pTag->mbIsUse = false;
cTr_SingleCut(&pTag->mpNode);
return true;
} else {
return false;
}
}
#pragma pop
/* 802668CC-8026691C 0050+00 s=0 e=3 z=0 None .text
* cTg_AdditionToTree__FP21node_lists_tree_classiP16create_tag_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_AdditionToTree(node_lists_tree_class* param_0, int param_1,
create_tag_class* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_AdditionToTree__FP21node_lists_tree_classiP16create_tag_class.s"
int cTg_AdditionToTree(node_lists_tree_class* pTree, int listIdx, create_tag_class* pTag) {
if (!pTag->mbIsUse) {
int ret = cTr_Addition(pTree, listIdx, &pTag->mpNode);
if (ret) {
pTag->mbIsUse = true;
return ret;
}
}
return 0;
}
#pragma pop
/* 8026691C-8026696C 0050+00 s=0 e=1 z=0 None .text
* cTg_InsertToTree__FP21node_lists_tree_classiP16create_tag_classi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_InsertToTree(node_lists_tree_class* param_0, int param_1, create_tag_class* param_2,
int param_3) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_InsertToTree__FP21node_lists_tree_classiP16create_tag_classi.s"
int cTg_InsertToTree(node_lists_tree_class* pTree, int listIdx, create_tag_class* pTag, int idx) {
if (!pTag->mbIsUse) {
int ret = cTr_Insert(pTree, listIdx, &pTag->mpNode, idx);
if (ret) {
pTag->mbIsUse = true;
return ret;
}
}
return 0;
}
#pragma pop
/* 8026696C-802669A4 0038+00 s=0 e=1 z=0 None .text cTg_GetFirst__FP15node_list_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_GetFirst(node_list_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_GetFirst__FP15node_list_class.s"
node_class* cTg_GetFirst(node_list_class* pList) {
create_tag_class* pTag = (create_tag_class*)cLs_GetFirst(pList);
if (pTag != NULL) {
pTag->mbIsUse = false;
} else {
pTag = NULL;
}
return &pTag->mpNode;
}
#pragma pop
/* 802669A4-802669E4 0040+00 s=0 e=7 z=0 None .text cTg_SingleCut__FP16create_tag_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_SingleCut(create_tag_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_SingleCut__FP16create_tag_class.s"
int cTg_SingleCut(create_tag_class* pTag) {
if (pTag->mbIsUse == 1) {
pTag->mbIsUse = false;
cLs_SingleCut(&pTag->mpNode);
return 1;
}
return 0;
}
#pragma pop
/* 802669E4-80266A34 0050+00 s=0 e=7 z=0 None .text
* cTg_Addition__FP15node_list_classP16create_tag_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_Addition(node_list_class* param_0, create_tag_class* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_Addition__FP15node_list_classP16create_tag_class.s"
int cTg_Addition(node_list_class* pList, create_tag_class* pTag) {
if (!pTag->mbIsUse) {
int ret = cLs_Addition(pList, &pTag->mpNode);
if (ret) {
pTag->mbIsUse = true;
return ret;
}
}
return 0;
}
#pragma pop
/* 80266A34-80266A7C 0048+00 s=0 e=10 z=0 None .text cTg_Create__FP16create_tag_classPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTg_Create(create_tag_class* param_0, void* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_tag/cTg_Create__FP16create_tag_classPv.s"
void cTg_Create(create_tag_class* pTag, void* pData) {
cNd_Create(&pTag->mpNode, NULL);
pTag->mpTagData = pData;
pTag->mbIsUse = false;
}
#pragma pop

46
libs/SSystem/SComponent/c_tag_iter.cpp
View File

@ -7,52 +7,14 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct method_filter {};
struct judge_filter {};
struct create_tag_class {};
//
// Forward References:
//
void cTgIt_MethodCall(create_tag_class*, method_filter*);
void cTgIt_JudgeFilter(create_tag_class*, judge_filter*);
extern "C" void cTgIt_MethodCall__FP16create_tag_classP13method_filter();
extern "C" void cTgIt_JudgeFilter__FP16create_tag_classP12judge_filter();
//
// External References:
//
//
// Declarations:
//
/* 80266A7C-80266AB0 0034+00 s=0 e=4 z=0 None .text
* cTgIt_MethodCall__FP16create_tag_classP13method_filter */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTgIt_MethodCall(create_tag_class* param_0, method_filter* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_tag_iter/cTgIt_MethodCall__FP16create_tag_classP13method_filter.s"
int cTgIt_MethodCall(create_tag_class* pTag, method_filter* pMethodFilter) {
return pMethodFilter->mpMethodFunc((node_class*)pTag->mpTagData, pMethodFilter->mpUserData);
}
#pragma pop
/* 80266AB0-80266AE4 0034+00 s=0 e=5 z=0 None .text
* cTgIt_JudgeFilter__FP16create_tag_classP12judge_filter */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTgIt_JudgeFilter(create_tag_class* param_0, judge_filter* param_1) {
nofralloc
#include "asm/SSystem/SComponent/c_tag_iter/cTgIt_JudgeFilter__FP16create_tag_classP12judge_filter.s"
void* cTgIt_JudgeFilter(create_tag_class* pTag, judge_filter* pJudgeFilter) {
return pJudgeFilter->mpJudgeFunc((node_class*)pTag->mpTagData, pJudgeFilter->mpUserData);
}
#pragma pop

88
libs/SSystem/SComponent/c_tree.cpp
View File

@ -7,87 +7,35 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_lists_tree_class {};
struct node_list_class {};
struct node_class {};
//
// Forward References:
//
void cTr_SingleCut(node_class*);
void cTr_Addition(node_lists_tree_class*, int, node_class*);
void cTr_Insert(node_lists_tree_class*, int, node_class*, int);
void cTr_Create(node_lists_tree_class*, node_list_class*, int);
extern "C" void cTr_SingleCut__FP10node_class();
extern "C" void cTr_Addition__FP21node_lists_tree_classiP10node_class();
extern "C" void cTr_Insert__FP21node_lists_tree_classiP10node_classi();
extern "C" void cTr_Create__FP21node_lists_tree_classP15node_list_classi();
//
// External References:
//
void cLs_SingleCut(node_class*);
void cLs_Addition(node_list_class*, node_class*);
void cLs_Insert(node_list_class*, int, node_class*);
void cLs_Create(node_list_class*);
extern "C" void cLs_SingleCut__FP10node_class();
extern "C" void cLs_Addition__FP15node_list_classP10node_class();
extern "C" void cLs_Insert__FP15node_list_classiP10node_class();
extern "C" void cLs_Create__FP15node_list_class();
//
// Declarations:
//
/* 80266440-80266460 0020+00 s=0 e=1 z=0 None .text cTr_SingleCut__FP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTr_SingleCut(node_class* param_0) {
nofralloc
#include "asm/SSystem/SComponent/c_tree/cTr_SingleCut__FP10node_class.s"
int cTr_SingleCut(node_class* pNode) {
return cLs_SingleCut(pNode);
}
#pragma pop
/* 80266460-802664A4 0044+00 s=0 e=1 z=0 None .text
* cTr_Addition__FP21node_lists_tree_classiP10node_class */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTr_Addition(node_lists_tree_class* param_0, int param_1, node_class* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_tree/cTr_Addition__FP21node_lists_tree_classiP10node_class.s"
int cTr_Addition(node_lists_tree_class* pTree, int listIdx, node_class* pNode) {
if (listIdx >= pTree->mNumLists)
return 0;
return cLs_Addition(&pTree->mpLists[listIdx], pNode);
}
#pragma pop
/* 802664A4-802664E8 0044+00 s=0 e=1 z=0 None .text
* cTr_Insert__FP21node_lists_tree_classiP10node_classi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTr_Insert(node_lists_tree_class* param_0, int param_1, node_class* param_2, int param_3) {
nofralloc
#include "asm/SSystem/SComponent/c_tree/cTr_Insert__FP21node_lists_tree_classiP10node_classi.s"
int cTr_Insert(node_lists_tree_class* pTree, int listIdx, node_class* pNode, int idx) {
if (listIdx >= pTree->mNumLists)
return 0;
return cLs_Insert(&pTree->mpLists[listIdx], idx, pNode);
}
#pragma pop
/* 802664E8-80266540 0058+00 s=0 e=2 z=0 None .text
* cTr_Create__FP21node_lists_tree_classP15node_list_classi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTr_Create(node_lists_tree_class* param_0, node_list_class* param_1, int param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_tree/cTr_Create__FP21node_lists_tree_classP15node_list_classi.s"
void cTr_Create(node_lists_tree_class* pTree, node_list_class* pLists, int numLists) {
pTree->mpLists = pLists;
pTree->mNumLists = numLists;
while (numLists-- > 0)
cLs_Create(pLists++);
}
#pragma pop

68
libs/SSystem/SComponent/c_tree_iter.cpp
View File

@ -4,65 +4,37 @@
//
#include "SSystem/SComponent/c_tree_iter.h"
#include "SSystem/SComponent/c_list_iter.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct node_lists_tree_class {};
struct node_list_class {};
struct node_class {};
//
// Forward References:
//
void cTrIt_Method(node_lists_tree_class*, int (*)(node_class*, void*), void*);
void cTrIt_Judge(node_lists_tree_class*, void* (*)(node_class*, void*), void*);
extern "C" void cTrIt_Method__FP21node_lists_tree_classPFP10node_classPv_iPv();
extern "C" void cTrIt_Judge__FP21node_lists_tree_classPFP10node_classPv_PvPv();
//
// External References:
//
void cLsIt_Method(node_list_class*, int (*)(node_class*, void*), void*);
void cLsIt_Judge(node_list_class*, void* (*)(node_class*, void*), void*);
extern "C" void cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv();
extern "C" void cLsIt_Judge__FP15node_list_classPFP10node_classPv_PvPv();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
//
// Declarations:
//
/* 80266540-802665B4 0074+00 s=0 e=2 z=0 None .text
* cTrIt_Method__FP21node_lists_tree_classPFP10node_classPv_iPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTrIt_Method(node_lists_tree_class* param_0, int (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_tree_iter/cTrIt_Method__FP21node_lists_tree_classPFP10node_classPv_iPv.s"
int cTrIt_Method(node_lists_tree_class* pTree, cNdIt_MethodFunc pMethod, void* pUserData) {
node_list_class* pList = pTree->mpLists;
int i = pTree->mNumLists;
int ret = 1;
while (i-- > 0) {
int sub = cLsIt_Method(pList++, pMethod, pUserData);
if (sub == 0)
ret = 0;
}
return ret;
}
#pragma pop
/* 802665B4-80266624 0070+00 s=0 e=2 z=0 None .text
* cTrIt_Judge__FP21node_lists_tree_classPFP10node_classPv_PvPv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void cTrIt_Judge(node_lists_tree_class* param_0, void* (*)(node_class*, void*), void* param_2) {
nofralloc
#include "asm/SSystem/SComponent/c_tree_iter/cTrIt_Judge__FP21node_lists_tree_classPFP10node_classPv_PvPv.s"
void* cTrIt_Judge(node_lists_tree_class* pTree, cNdIt_JudgeFunc pJudge, void* pUserData) {
node_list_class* pList = pTree->mpLists;
int i = pTree->mNumLists;
while (i-- > 0) {
void* pJudgeRet = cLsIt_Judge(pList++, pJudge, pUserData);
if (pJudgeRet != NULL)
return pJudgeRet;
}
return NULL;
}
#pragma pop