From 47a1bdea8872c79dd2cd7d75ca7f254b9ed13170 Mon Sep 17 00:00:00 2001 From: Max Date: Thu, 29 Oct 2020 14:27:37 -0400 Subject: match up to func_801DCFE4, add string.h and stdlib.h, add types.h to Makefile include path, and move GameSpy under DWC --- src/GameSpy/darray.c | 454 ---------------------------------------- src/GameSpy/hashtable.c | 103 --------- src/Runtime/ptmf.c | 2 - src/SDK/DWC/gamespy/darray.c | 451 +++++++++++++++++++++++++++++++++++++++ src/SDK/DWC/gamespy/hashtable.c | 102 +++++++++ src/code_801DAA30.cpp | 1 - src/code_801DAAE0.cpp | 5 +- src/code_801DB040.cpp | 5 +- src/code_801DB81C.cpp | 3 +- src/code_801DBB3C.cpp | 3 +- src/code_801DBE90.cpp | 11 +- src/code_801DCE6C.cpp | 52 ++++- 12 files changed, 611 insertions(+), 581 deletions(-) delete mode 100644 src/GameSpy/darray.c delete mode 100644 src/GameSpy/hashtable.c create mode 100644 src/SDK/DWC/gamespy/darray.c create mode 100644 src/SDK/DWC/gamespy/hashtable.c (limited to 'src') diff --git a/src/GameSpy/darray.c b/src/GameSpy/darray.c deleted file mode 100644 index 7f84cb0..0000000 --- a/src/GameSpy/darray.c +++ /dev/null @@ -1,454 +0,0 @@ -#include "types.h" -#include "libstdc++/qsort.h" -#include "GameSpy/nonport.h" -#include "GameSpy/darray.h" - -#pragma auto_inline on - -extern void *memcpy(void *, const void *, u32); -extern void *memmove(void *, const void *, u32); - -static inline void ArrayInsert(DArray *d, void *elem, s32 n) -{ - if (d->size == d->capacity) { - s32 newCap = d->capacity + d->growAmount; - d->capacity = newCap; - d->buf = gsirealloc(d->buf, newCap * d->elemSz); - } - d->size++; - s32 origSize = d->size - 1; - if (n < origSize) { - memmove(ArrayNth(d, n+1), ArrayNth(d, n), - (origSize - n) * d->elemSz); - } - memcpy(ArrayNth(d, n), elem, d->elemSz); -} - -DArray *ArrayNew(u32 elemSz, s32 initialCap, DtorFunction dtor) -{ - DArray *darray = gsimalloc(sizeof(DArray)); - if (initialCap == 0) - initialCap = 8; - darray->size = 0; - darray->capacity = initialCap; - darray->elemSz = elemSz; - darray->growAmount = initialCap; - darray->elemDtor = dtor; - if (initialCap != 0) { - darray->buf = gsimalloc(initialCap * darray->elemSz); - } else { - darray->buf = NULL; - } - return darray; -} - -void ArrayFree(DArray *d) -{ - for (s32 i = 0; i < d->size; i++) { - if (d->elemDtor) { - void *elem = ArrayNth(d, i); - d->elemDtor(elem); - } - } - gsifree(d->buf); - gsifree(d); -} - -s32 ArrayLength(DArray *d) -{ - return d->size; -} - -void *ArrayNth(DArray *d, s32 n) -{ - if (n < 0 || n >= d->size) - return NULL; - return &d->buf[d->elemSz * n]; -} - -void ArrayAppend(DArray *d, void *elem) -{ - if (d) { - ArrayInsert(d, elem, d->size); - } -} - -#ifdef NONMATCHING -void ArrayInsertSorted(DArray *d, void *elem, CompareFunction compar) -{ - char *buf; - u32 elemSz; - s32 mid, high, low; - elemSz = d->elemSz; - buf = d->buf; - high = d->size - 1; - low = 0; - while (low <= high) { - mid = (low + high) >> 1; - s32 result = compar(&buf[mid * elemSz], elem); - if (result < 0) { - low = mid + 1; - } - if (result >= 0) { - high = mid - 1; - } - } - char *recomputeLow = &buf[low * elemSz]; - ArrayInsert(d, elem, (recomputeLow - d->buf)/ (s32)d->elemSz); -} -#else -_savegpr_23(); -_restgpr_23(); -_savegpr_24(); -_restgpr_24(); -asm void ArrayInsertSorted(DArray *d, void *elem, CompareFunction compar) -{ - nofralloc - /* 80336044 00331CA4 94 21 FF D0 */ stwu r1, -0x30(r1) - /* 80336048 00331CA8 7C 08 02 A6 */ mflr r0 - /* 8033604C 00331CAC 90 01 00 34 */ stw r0, 0x34(r1) - /* 80336050 00331CB0 39 61 00 30 */ addi r11, r1, 0x30 - /* 80336054 00331CB4 4B E9 10 C9 */ bl _savegpr_24 - /* 80336058 00331CB8 80 C3 00 00 */ lwz r6, 0(r3) - /* 8033605C 00331CBC 7C 7D 1B 78 */ mr r29, r3 - /* 80336060 00331CC0 83 83 00 08 */ lwz r28, 8(r3) - /* 80336064 00331CC4 7C 9E 23 78 */ mr r30, r4 - /* 80336068 00331CC8 83 E3 00 14 */ lwz r31, 0x14(r3) - /* 8033606C 00331CCC 7C B8 2B 78 */ mr r24, r5 - /* 80336070 00331CD0 3B 46 FF FF */ addi r26, r6, -1 - /* 80336074 00331CD4 3B 20 00 00 */ li r25, 0 - /* 80336078 00331CD8 48 00 00 3C */ b lbl_803360B4 - lbl_8033607C: - /* 8033607C 00331CDC 7C 19 D2 14 */ add r0, r25, r26 - /* 80336080 00331CE0 7F 0C C3 78 */ mr r12, r24 - /* 80336084 00331CE4 7C 1B 0E 70 */ srawi r27, r0, 1 - /* 80336088 00331CE8 7F C4 F3 78 */ mr r4, r30 - /* 8033608C 00331CEC 7C 1B E1 D6 */ mullw r0, r27, r28 - /* 80336090 00331CF0 7C 7F 02 14 */ add r3, r31, r0 - /* 80336094 00331CF4 7D 89 03 A6 */ mtctr r12 - /* 80336098 00331CF8 4E 80 04 21 */ bctrl - /* 8033609C 00331CFC 2C 03 00 00 */ cmpwi r3, 0 - /* 803360A0 00331D00 40 80 00 08 */ bge lbl_803360A8 - /* 803360A4 00331D04 3B 3B 00 01 */ addi r25, r27, 1 - lbl_803360A8: - /* 803360A8 00331D08 2C 03 00 00 */ cmpwi r3, 0 - /* 803360AC 00331D0C 41 80 00 08 */ blt lbl_803360B4 - /* 803360B0 00331D10 3B 5B FF FF */ addi r26, r27, -1 - lbl_803360B4: - /* 803360B4 00331D14 7C 19 D0 00 */ cmpw r25, r26 - /* 803360B8 00331D18 40 81 FF C4 */ ble lbl_8033607C - /* 803360BC 00331D1C 7C D9 E1 D6 */ mullw r6, r25, r28 - /* 803360C0 00331D20 80 7D 00 14 */ lwz r3, 0x14(r29) - /* 803360C4 00331D24 80 BD 00 08 */ lwz r5, 8(r29) - /* 803360C8 00331D28 80 1D 00 00 */ lwz r0, 0(r29) - /* 803360CC 00331D2C 80 9D 00 04 */ lwz r4, 4(r29) - /* 803360D0 00331D30 7C DF 32 14 */ add r6, r31, r6 - /* 803360D4 00331D34 7C C3 30 50 */ subf r6, r3, r6 - /* 803360D8 00331D38 7C 00 20 00 */ cmpw r0, r4 - /* 803360DC 00331D3C 7F E6 2B D6 */ divw r31, r6, r5 - /* 803360E0 00331D40 40 82 00 1C */ bne lbl_803360FC - /* 803360E4 00331D44 80 1D 00 0C */ lwz r0, 0xc(r29) - /* 803360E8 00331D48 7C 04 02 14 */ add r0, r4, r0 - /* 803360EC 00331D4C 7C 80 29 D6 */ mullw r4, r0, r5 - /* 803360F0 00331D50 90 1D 00 04 */ stw r0, 4(r29) - /* 803360F4 00331D54 48 00 32 31 */ bl gsirealloc - /* 803360F8 00331D58 90 7D 00 14 */ stw r3, 0x14(r29) - lbl_803360FC: - /* 803360FC 00331D5C 80 7D 00 00 */ lwz r3, 0(r29) - /* 80336100 00331D60 38 A3 00 01 */ addi r5, r3, 1 - /* 80336104 00331D64 38 C5 FF FF */ addi r6, r5, -1 - /* 80336108 00331D68 90 BD 00 00 */ stw r5, 0(r29) - /* 8033610C 00331D6C 7C 1F 30 00 */ cmpw r31, r6 - /* 80336110 00331D70 40 80 00 64 */ bge lbl_80336174 - /* 80336114 00331D74 34 9F 00 01 */ addic. r4, r31, 1 - /* 80336118 00331D78 41 80 00 0C */ blt lbl_80336124 - /* 8033611C 00331D7C 7C 04 28 00 */ cmpw r4, r5 - /* 80336120 00331D80 41 80 00 0C */ blt lbl_8033612C - lbl_80336124: - /* 80336124 00331D84 38 60 00 00 */ li r3, 0 - /* 80336128 00331D88 48 00 00 14 */ b lbl_8033613C - lbl_8033612C: - /* 8033612C 00331D8C 80 1D 00 08 */ lwz r0, 8(r29) - /* 80336130 00331D90 80 7D 00 14 */ lwz r3, 0x14(r29) - /* 80336134 00331D94 7C 00 21 D6 */ mullw r0, r0, r4 - /* 80336138 00331D98 7C 63 02 14 */ add r3, r3, r0 - lbl_8033613C: - /* 8033613C 00331D9C 2C 1F 00 00 */ cmpwi r31, 0 - /* 80336140 00331DA0 41 80 00 0C */ blt lbl_8033614C - /* 80336144 00331DA4 7C 1F 28 00 */ cmpw r31, r5 - /* 80336148 00331DA8 41 80 00 0C */ blt lbl_80336154 - lbl_8033614C: - /* 8033614C 00331DAC 38 80 00 00 */ li r4, 0 - /* 80336150 00331DB0 48 00 00 14 */ b lbl_80336164 - lbl_80336154: - /* 80336154 00331DB4 80 1D 00 08 */ lwz r0, 8(r29) - /* 80336158 00331DB8 80 9D 00 14 */ lwz r4, 0x14(r29) - /* 8033615C 00331DBC 7C 00 F9 D6 */ mullw r0, r0, r31 - /* 80336160 00331DC0 7C 84 02 14 */ add r4, r4, r0 - lbl_80336164: - /* 80336164 00331DC4 80 BD 00 08 */ lwz r5, 8(r29) - /* 80336168 00331DC8 7C 1F 30 50 */ subf r0, r31, r6 - /* 8033616C 00331DCC 7C A5 01 D6 */ mullw r5, r5, r0 - /* 80336170 00331DD0 4B E9 41 05 */ bl memmove - lbl_80336174: - /* 80336174 00331DD4 2C 1F 00 00 */ cmpwi r31, 0 - /* 80336178 00331DD8 41 80 00 10 */ blt lbl_80336188 - /* 8033617C 00331DDC 80 1D 00 00 */ lwz r0, 0(r29) - /* 80336180 00331DE0 7C 1F 00 00 */ cmpw r31, r0 - /* 80336184 00331DE4 41 80 00 0C */ blt lbl_80336190 - lbl_80336188: - /* 80336188 00331DE8 38 60 00 00 */ li r3, 0 - /* 8033618C 00331DEC 48 00 00 14 */ b lbl_803361A0 - lbl_80336190: - /* 80336190 00331DF0 80 1D 00 08 */ lwz r0, 8(r29) - /* 80336194 00331DF4 80 7D 00 14 */ lwz r3, 0x14(r29) - /* 80336198 00331DF8 7C 00 F9 D6 */ mullw r0, r0, r31 - /* 8033619C 00331DFC 7C 63 02 14 */ add r3, r3, r0 - lbl_803361A0: - /* 803361A0 00331E00 80 BD 00 08 */ lwz r5, 8(r29) - /* 803361A4 00331E04 7F C4 F3 78 */ mr r4, r30 - /* 803361A8 00331E08 4B CC DE 59 */ bl memcpy - /* 803361AC 00331E0C 39 61 00 30 */ addi r11, r1, 0x30 - /* 803361B0 00331E10 4B E9 0F B9 */ bl _restgpr_24 - /* 803361B4 00331E14 80 01 00 34 */ lwz r0, 0x34(r1) - /* 803361B8 00331E18 7C 08 03 A6 */ mtlr r0 - /* 803361BC 00331E1C 38 21 00 30 */ addi r1, r1, 0x30 - /* 803361C0 00331E20 4E 80 00 20 */ blr -} -#pragma peephole on -#endif - -void ArrayRemoveAt(DArray *d, s32 n) -{ - s32 origSize = d->size; - s32 decOrigSize = origSize - 1; - if (n < decOrigSize) { - memmove(ArrayNth(d, n), ArrayNth(d, n+1), - d->elemSz * (decOrigSize - n)); - } - d->size--; -} - -void ArrayDeleteAt(DArray *d, s32 n) -{ - if (d->elemDtor) { - d->elemDtor(ArrayNth(d, n)); - } - ArrayRemoveAt(d, n); -} - -void ArrayReplaceAt(DArray *d, void *elem, s32 n) -{ - if (d->elemDtor) { - d->elemDtor(ArrayNth(d, n)); - } - memcpy(ArrayNth(d, n), elem, d->elemSz); -} - -void ArraySort(DArray *d, CompareFunction compar) -{ - qsort(d->buf, (u32)d->size, d->elemSz, compar); -} - -#ifdef NONMATCHING -s32 ArraySearch(DArray *d, void *elem, CompareFunction cmp, s32 start, s32 doBinarySearch) -{ - BOOL found = TRUE; - char *ptr; - - s32 arrSize; - if (!d || (arrSize = d->size) == 0) { - return -1; - } - if (doBinarySearch) { - char *r27 = ArrayNth(d, start); - s32 high = arrSize - start - 1; - u32 elemSz = d->elemSz; - s32 low = 0; - found = FALSE; - while (low <= high) { - s32 mid = (low + high) >> 1; - s32 result = cmp(&r27[mid * elemSz], elem); - if (result == 0) { - found = TRUE; - } - if (result < 0) { - low = mid + 1; - } - if (result >= 0) { - high = mid - 1; - } - } - ptr = &r27[low * elemSz]; - } else { - char *r23 = ArrayNth(d, start); - u32 elemSz = d->elemSz; - s32 r24 = arrSize - start; - for (s32 i = 0, j = 0; i < r24; j += elemSz, i++) { - if (cmp(elem, &r23[j]) == 0) { - ptr = &r23[i * elemSz]; - goto exit; - } - } - ptr = NULL; - } - exit: - if (ptr && found) { - return (ptr - d->buf) / (s32)d->elemSz; - } - return -1; -} -#else -asm s32 ArraySearch(DArray *d, void *elem, CompareFunction cmp, s32 start, s32 doBinarySearch) -{ - nofralloc - /* 80336430 00332090 94 21 FF D0 */ stwu r1, -0x30(r1) - /* 80336434 00332094 7C 08 02 A6 */ mflr r0 - /* 80336438 00332098 90 01 00 34 */ stw r0, 0x34(r1) - /* 8033643C 0033209C 39 61 00 30 */ addi r11, r1, 0x30 - /* 80336440 003320A0 4B E9 0C D9 */ bl _savegpr_23 - /* 80336444 003320A4 2C 03 00 00 */ cmpwi r3, 0 - /* 80336448 003320A8 7C 7C 1B 78 */ mr r28, r3 - /* 8033644C 003320AC 7C 9D 23 78 */ mr r29, r4 - /* 80336450 003320B0 7C BE 2B 78 */ mr r30, r5 - /* 80336454 003320B4 3B E0 00 01 */ li r31, 1 - /* 80336458 003320B8 41 82 00 10 */ beq lbl_80336468 - /* 8033645C 003320BC 80 A3 00 00 */ lwz r5, 0(r3) - /* 80336460 003320C0 2C 05 00 00 */ cmpwi r5, 0 - /* 80336464 003320C4 40 82 00 0C */ bne lbl_80336470 - lbl_80336468: - /* 80336468 003320C8 38 60 FF FF */ li r3, -1 - /* 8033646C 003320CC 48 00 01 44 */ b lbl_803365B0 - lbl_80336470: - /* 80336470 003320D0 2C 07 00 00 */ cmpwi r7, 0 - /* 80336474 003320D4 41 82 00 9C */ beq lbl_80336510 - /* 80336478 003320D8 2C 06 00 00 */ cmpwi r6, 0 - /* 8033647C 003320DC 41 80 00 0C */ blt lbl_80336488 - /* 80336480 003320E0 7C 06 28 00 */ cmpw r6, r5 - /* 80336484 003320E4 41 80 00 0C */ blt lbl_80336490 - lbl_80336488: - /* 80336488 003320E8 3B 60 00 00 */ li r27, 0 - /* 8033648C 003320EC 48 00 00 14 */ b lbl_803364A0 - lbl_80336490: - /* 80336490 003320F0 80 03 00 08 */ lwz r0, 8(r3) - /* 80336494 003320F4 80 83 00 14 */ lwz r4, 0x14(r3) - /* 80336498 003320F8 7C 00 31 D6 */ mullw r0, r0, r6 - /* 8033649C 003320FC 7F 64 02 14 */ add r27, r4, r0 - lbl_803364A0: - /* 803364A0 00332100 7C 86 28 50 */ subf r4, r6, r5 - /* 803364A4 00332104 83 43 00 08 */ lwz r26, 8(r3) - /* 803364A8 00332108 3B 04 FF FF */ addi r24, r4, -1 - /* 803364AC 0033210C 3A E0 00 00 */ li r23, 0 - /* 803364B0 00332110 3B E0 00 00 */ li r31, 0 - /* 803364B4 00332114 48 00 00 48 */ b lbl_803364FC - lbl_803364B8: - /* 803364B8 00332118 7C 17 C2 14 */ add r0, r23, r24 - /* 803364BC 0033211C 7F CC F3 78 */ mr r12, r30 - /* 803364C0 00332120 7C 19 0E 70 */ srawi r25, r0, 1 - /* 803364C4 00332124 7F A4 EB 78 */ mr r4, r29 - /* 803364C8 00332128 7C 19 D1 D6 */ mullw r0, r25, r26 - /* 803364CC 0033212C 7C 7B 02 14 */ add r3, r27, r0 - /* 803364D0 00332130 7D 89 03 A6 */ mtctr r12 - /* 803364D4 00332134 4E 80 04 21 */ bctrl - /* 803364D8 00332138 2C 03 00 00 */ cmpwi r3, 0 - /* 803364DC 0033213C 40 82 00 08 */ bne lbl_803364E4 - /* 803364E0 00332140 3B E0 00 01 */ li r31, 1 - lbl_803364E4: - /* 803364E4 00332144 2C 03 00 00 */ cmpwi r3, 0 - /* 803364E8 00332148 40 80 00 08 */ bge lbl_803364F0 - /* 803364EC 0033214C 3A F9 00 01 */ addi r23, r25, 1 - lbl_803364F0: - /* 803364F0 00332150 2C 03 00 00 */ cmpwi r3, 0 - /* 803364F4 00332154 41 80 00 08 */ blt lbl_803364FC - /* 803364F8 00332158 3B 19 FF FF */ addi r24, r25, -1 - lbl_803364FC: - /* 803364FC 0033215C 7C 17 C0 00 */ cmpw r23, r24 - /* 80336500 00332160 40 81 FF B8 */ ble lbl_803364B8 - /* 80336504 00332164 7C 17 D1 D6 */ mullw r0, r23, r26 - /* 80336508 00332168 7C 9B 02 14 */ add r4, r27, r0 - /* 8033650C 0033216C 48 00 00 7C */ b lbl_80336588 - lbl_80336510: - /* 80336510 00332170 2C 06 00 00 */ cmpwi r6, 0 - /* 80336514 00332174 41 80 00 0C */ blt lbl_80336520 - /* 80336518 00332178 7C 06 28 00 */ cmpw r6, r5 - /* 8033651C 0033217C 41 80 00 0C */ blt lbl_80336528 - lbl_80336520: - /* 80336520 00332180 3A E0 00 00 */ li r23, 0 - /* 80336524 00332184 48 00 00 14 */ b lbl_80336538 - lbl_80336528: - /* 80336528 00332188 80 03 00 08 */ lwz r0, 8(r3) - /* 8033652C 0033218C 80 83 00 14 */ lwz r4, 0x14(r3) - /* 80336530 00332190 7C 00 31 D6 */ mullw r0, r0, r6 - /* 80336534 00332194 7E E4 02 14 */ add r23, r4, r0 - lbl_80336538: - /* 80336538 00332198 83 23 00 08 */ lwz r25, 8(r3) - /* 8033653C 0033219C 7F 06 28 50 */ subf r24, r6, r5 - /* 80336540 003321A0 3B 40 00 00 */ li r26, 0 - /* 80336544 003321A4 3B 60 00 00 */ li r27, 0 - /* 80336548 003321A8 48 00 00 34 */ b lbl_8033657C - lbl_8033654C: - /* 8033654C 003321AC 7F CC F3 78 */ mr r12, r30 - /* 80336550 003321B0 7F A3 EB 78 */ mr r3, r29 - /* 80336554 003321B4 7C 97 DA 14 */ add r4, r23, r27 - /* 80336558 003321B8 7D 89 03 A6 */ mtctr r12 - /* 8033655C 003321BC 4E 80 04 21 */ bctrl - /* 80336560 003321C0 2C 03 00 00 */ cmpwi r3, 0 - /* 80336564 003321C4 40 82 00 10 */ bne lbl_80336574 - /* 80336568 003321C8 7C 19 D1 D6 */ mullw r0, r25, r26 - /* 8033656C 003321CC 7C 97 02 14 */ add r4, r23, r0 - /* 80336570 003321D0 48 00 00 18 */ b lbl_80336588 - lbl_80336574: - /* 80336574 003321D4 7F 7B CA 14 */ add r27, r27, r25 - /* 80336578 003321D8 3B 5A 00 01 */ addi r26, r26, 1 - lbl_8033657C: - /* 8033657C 003321DC 7C 1A C0 00 */ cmpw r26, r24 - /* 80336580 003321E0 41 80 FF CC */ blt lbl_8033654C - /* 80336584 003321E4 38 80 00 00 */ li r4, 0 - lbl_80336588: - /* 80336588 003321E8 2C 04 00 00 */ cmpwi r4, 0 - /* 8033658C 003321EC 41 82 00 20 */ beq lbl_803365AC - /* 80336590 003321F0 2C 1F 00 00 */ cmpwi r31, 0 - /* 80336594 003321F4 41 82 00 18 */ beq lbl_803365AC - /* 80336598 003321F8 80 7C 00 14 */ lwz r3, 0x14(r28) - /* 8033659C 003321FC 80 1C 00 08 */ lwz r0, 8(r28) - /* 803365A0 00332200 7C 63 20 50 */ subf r3, r3, r4 - /* 803365A4 00332204 7C 63 03 D6 */ divw r3, r3, r0 - /* 803365A8 00332208 48 00 00 08 */ b lbl_803365B0 - lbl_803365AC: - /* 803365AC 0033220C 38 60 FF FF */ li r3, -1 - lbl_803365B0: - /* 803365B0 00332210 39 61 00 30 */ addi r11, r1, 0x30 - /* 803365B4 00332214 4B E9 0B B1 */ bl _restgpr_23 - /* 803365B8 00332218 80 01 00 34 */ lwz r0, 0x34(r1) - /* 803365BC 0033221C 7C 08 03 A6 */ mtlr r0 - /* 803365C0 00332220 38 21 00 30 */ addi r1, r1, 0x30 - /* 803365C4 00332224 4E 80 00 20 */ blr -} -#pragma peephole on -#endif - -void ArrayMapBackwards(DArray *d, MapFunction map, s32 p3) -{ - for (s32 i = d->size - 1; i >= 0; i--) { - void *elem = ArrayNth(d, i); - map(elem, p3); - } -} - -void *ArrayMapBackwards2(DArray *d, MapFunction map, s32 p3) -{ - for (s32 i = d->size - 1; i >= 0; i--) { - void *elem = ArrayNth(d, i); - if (map(elem, p3) == FALSE) { - return elem; - } - } - return NULL; -} - -void ArrayClear(DArray *d) -{ - for (s32 i = d->size - 1; i >= 0; i--) { - ArrayDeleteAt(d, i); - } -} diff --git a/src/GameSpy/hashtable.c b/src/GameSpy/hashtable.c deleted file mode 100644 index 0e1c09a..0000000 --- a/src/GameSpy/hashtable.c +++ /dev/null @@ -1,103 +0,0 @@ -#include "types.h" -#include "GameSpy/nonport.h" -#include "GameSpy/hashtable.h" - -HashTable *TableNew(u32 p1, s32 p2, HashFunction hf, CompareFunction cmp, DtorFunction dtor) -{ - return TableNew2(p1, p2, 4, hf, cmp, dtor); -} - -HashTable *TableNew2(u32 p1, s32 size, s32 p3, HashFunction hf, CompareFunction cmp, DtorFunction dtor) -{ - HashTable *table = gsimalloc(sizeof(HashTable)); - table->chains = gsimalloc(size * sizeof(DArray *)); - for (s32 i = 0; i < size; i++) { - table->chains[i] = ArrayNew(p1, p3, dtor); - } - table->size = size; - table->dtor = dtor; - table->compar = cmp; - table->hashFunc = hf; - return table; -} - -void TableFree(HashTable *table) -{ - if (table) { - for (s32 i = 0; i < table->size; i++) { - ArrayFree(table->chains[i]); - } - gsifree(table->chains); - gsifree(table); - } -} - -s32 TableCount(HashTable *table) -{ - s32 i, totalSize = 0; - if (!table) - return 0; - for (i = 0; i < table->size; i++) { - totalSize += ArrayLength(table->chains[i]); - } - return totalSize; -} - -void TableEnter(HashTable *table, void *elem) -{ - if (table) { - s32 i = table->hashFunc(elem, table->size); - s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); - if (result == -1) { - ArrayAppend(table->chains[i], elem); - } else { - ArrayReplaceAt(table->chains[i], elem, result); - } - } -} - -BOOL TableRemove(HashTable *table, void *elem) -{ - if (!table) - return FALSE; - s32 i = table->hashFunc(elem, table->size); - s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); - if (result == -1) { - return FALSE; - } else { - ArrayDeleteAt(table->chains[i], result); - return TRUE; - } -} - -void *TableLookup(HashTable *table, void *elem) -{ - if (!table) - return NULL; - s32 i = table->hashFunc(elem, table->size); - s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); - if (result == -1) { - return NULL; - } else { - return ArrayNth(table->chains[i], result); - } -} - -void TableMapSafe(HashTable *table, MapFunction p2, s32 p3) -{ - for (s32 i = 0; i < table->size; i++) { - ArrayMapBackwards(table->chains[i], p2, p3); - } -} - -void *TableMapSafe2(HashTable *table, MapFunction p2, s32 p3) -{ - s32 i; - void *result; - for (i = 0; i < table->size; i++) { - if ((result = ArrayMapBackwards2(table->chains[i], p2, p3)) != NULL) { - return result; - } - } - return NULL; -} diff --git a/src/Runtime/ptmf.c b/src/Runtime/ptmf.c index 297039c..c98cd63 100644 --- a/src/Runtime/ptmf.c +++ b/src/Runtime/ptmf.c @@ -1,5 +1,3 @@ -#include "CPlusLib.h" - #pragma internal on asm void __ptmf_scall(...) diff --git a/src/SDK/DWC/gamespy/darray.c b/src/SDK/DWC/gamespy/darray.c new file mode 100644 index 0000000..5259a9f --- /dev/null +++ b/src/SDK/DWC/gamespy/darray.c @@ -0,0 +1,451 @@ +#include +#include +#include +#include + +#pragma auto_inline on + +static inline void ArrayInsert(DArray *d, void *elem, s32 n) +{ + if (d->size == d->capacity) { + s32 newCap = d->capacity + d->growAmount; + d->capacity = newCap; + d->buf = gsirealloc(d->buf, newCap * d->elemSz); + } + d->size++; + s32 origSize = d->size - 1; + if (n < origSize) { + memmove(ArrayNth(d, n+1), ArrayNth(d, n), + (origSize - n) * d->elemSz); + } + memcpy(ArrayNth(d, n), elem, d->elemSz); +} + +DArray *ArrayNew(u32 elemSz, s32 initialCap, DtorFunction dtor) +{ + DArray *darray = gsimalloc(sizeof(DArray)); + if (initialCap == 0) + initialCap = 8; + darray->size = 0; + darray->capacity = initialCap; + darray->elemSz = elemSz; + darray->growAmount = initialCap; + darray->elemDtor = dtor; + if (initialCap != 0) { + darray->buf = gsimalloc(initialCap * darray->elemSz); + } else { + darray->buf = NULL; + } + return darray; +} + +void ArrayFree(DArray *d) +{ + for (s32 i = 0; i < d->size; i++) { + if (d->elemDtor) { + void *elem = ArrayNth(d, i); + d->elemDtor(elem); + } + } + gsifree(d->buf); + gsifree(d); +} + +s32 ArrayLength(DArray *d) +{ + return d->size; +} + +void *ArrayNth(DArray *d, s32 n) +{ + if (n < 0 || n >= d->size) + return NULL; + return &d->buf[d->elemSz * n]; +} + +void ArrayAppend(DArray *d, void *elem) +{ + if (d) { + ArrayInsert(d, elem, d->size); + } +} + +#ifdef NONMATCHING +void ArrayInsertSorted(DArray *d, void *elem, CompareFunction compar) +{ + char *buf; + u32 elemSz; + s32 mid, high, low; + elemSz = d->elemSz; + buf = d->buf; + high = d->size - 1; + low = 0; + while (low <= high) { + mid = (low + high) >> 1; + s32 result = compar(&buf[mid * elemSz], elem); + if (result < 0) { + low = mid + 1; + } + if (result >= 0) { + high = mid - 1; + } + } + char *recomputeLow = &buf[low * elemSz]; + ArrayInsert(d, elem, (recomputeLow - d->buf)/ (s32)d->elemSz); +} +#else +_savegpr_23(); +_restgpr_23(); +_savegpr_24(); +_restgpr_24(); +asm void ArrayInsertSorted(DArray *d, void *elem, CompareFunction compar) +{ + nofralloc + /* 80336044 00331CA4 94 21 FF D0 */ stwu r1, -0x30(r1) + /* 80336048 00331CA8 7C 08 02 A6 */ mflr r0 + /* 8033604C 00331CAC 90 01 00 34 */ stw r0, 0x34(r1) + /* 80336050 00331CB0 39 61 00 30 */ addi r11, r1, 0x30 + /* 80336054 00331CB4 4B E9 10 C9 */ bl _savegpr_24 + /* 80336058 00331CB8 80 C3 00 00 */ lwz r6, 0(r3) + /* 8033605C 00331CBC 7C 7D 1B 78 */ mr r29, r3 + /* 80336060 00331CC0 83 83 00 08 */ lwz r28, 8(r3) + /* 80336064 00331CC4 7C 9E 23 78 */ mr r30, r4 + /* 80336068 00331CC8 83 E3 00 14 */ lwz r31, 0x14(r3) + /* 8033606C 00331CCC 7C B8 2B 78 */ mr r24, r5 + /* 80336070 00331CD0 3B 46 FF FF */ addi r26, r6, -1 + /* 80336074 00331CD4 3B 20 00 00 */ li r25, 0 + /* 80336078 00331CD8 48 00 00 3C */ b lbl_803360B4 + lbl_8033607C: + /* 8033607C 00331CDC 7C 19 D2 14 */ add r0, r25, r26 + /* 80336080 00331CE0 7F 0C C3 78 */ mr r12, r24 + /* 80336084 00331CE4 7C 1B 0E 70 */ srawi r27, r0, 1 + /* 80336088 00331CE8 7F C4 F3 78 */ mr r4, r30 + /* 8033608C 00331CEC 7C 1B E1 D6 */ mullw r0, r27, r28 + /* 80336090 00331CF0 7C 7F 02 14 */ add r3, r31, r0 + /* 80336094 00331CF4 7D 89 03 A6 */ mtctr r12 + /* 80336098 00331CF8 4E 80 04 21 */ bctrl + /* 8033609C 00331CFC 2C 03 00 00 */ cmpwi r3, 0 + /* 803360A0 00331D00 40 80 00 08 */ bge lbl_803360A8 + /* 803360A4 00331D04 3B 3B 00 01 */ addi r25, r27, 1 + lbl_803360A8: + /* 803360A8 00331D08 2C 03 00 00 */ cmpwi r3, 0 + /* 803360AC 00331D0C 41 80 00 08 */ blt lbl_803360B4 + /* 803360B0 00331D10 3B 5B FF FF */ addi r26, r27, -1 + lbl_803360B4: + /* 803360B4 00331D14 7C 19 D0 00 */ cmpw r25, r26 + /* 803360B8 00331D18 40 81 FF C4 */ ble lbl_8033607C + /* 803360BC 00331D1C 7C D9 E1 D6 */ mullw r6, r25, r28 + /* 803360C0 00331D20 80 7D 00 14 */ lwz r3, 0x14(r29) + /* 803360C4 00331D24 80 BD 00 08 */ lwz r5, 8(r29) + /* 803360C8 00331D28 80 1D 00 00 */ lwz r0, 0(r29) + /* 803360CC 00331D2C 80 9D 00 04 */ lwz r4, 4(r29) + /* 803360D0 00331D30 7C DF 32 14 */ add r6, r31, r6 + /* 803360D4 00331D34 7C C3 30 50 */ subf r6, r3, r6 + /* 803360D8 00331D38 7C 00 20 00 */ cmpw r0, r4 + /* 803360DC 00331D3C 7F E6 2B D6 */ divw r31, r6, r5 + /* 803360E0 00331D40 40 82 00 1C */ bne lbl_803360FC + /* 803360E4 00331D44 80 1D 00 0C */ lwz r0, 0xc(r29) + /* 803360E8 00331D48 7C 04 02 14 */ add r0, r4, r0 + /* 803360EC 00331D4C 7C 80 29 D6 */ mullw r4, r0, r5 + /* 803360F0 00331D50 90 1D 00 04 */ stw r0, 4(r29) + /* 803360F4 00331D54 48 00 32 31 */ bl gsirealloc + /* 803360F8 00331D58 90 7D 00 14 */ stw r3, 0x14(r29) + lbl_803360FC: + /* 803360FC 00331D5C 80 7D 00 00 */ lwz r3, 0(r29) + /* 80336100 00331D60 38 A3 00 01 */ addi r5, r3, 1 + /* 80336104 00331D64 38 C5 FF FF */ addi r6, r5, -1 + /* 80336108 00331D68 90 BD 00 00 */ stw r5, 0(r29) + /* 8033610C 00331D6C 7C 1F 30 00 */ cmpw r31, r6 + /* 80336110 00331D70 40 80 00 64 */ bge lbl_80336174 + /* 80336114 00331D74 34 9F 00 01 */ addic. r4, r31, 1 + /* 80336118 00331D78 41 80 00 0C */ blt lbl_80336124 + /* 8033611C 00331D7C 7C 04 28 00 */ cmpw r4, r5 + /* 80336120 00331D80 41 80 00 0C */ blt lbl_8033612C + lbl_80336124: + /* 80336124 00331D84 38 60 00 00 */ li r3, 0 + /* 80336128 00331D88 48 00 00 14 */ b lbl_8033613C + lbl_8033612C: + /* 8033612C 00331D8C 80 1D 00 08 */ lwz r0, 8(r29) + /* 80336130 00331D90 80 7D 00 14 */ lwz r3, 0x14(r29) + /* 80336134 00331D94 7C 00 21 D6 */ mullw r0, r0, r4 + /* 80336138 00331D98 7C 63 02 14 */ add r3, r3, r0 + lbl_8033613C: + /* 8033613C 00331D9C 2C 1F 00 00 */ cmpwi r31, 0 + /* 80336140 00331DA0 41 80 00 0C */ blt lbl_8033614C + /* 80336144 00331DA4 7C 1F 28 00 */ cmpw r31, r5 + /* 80336148 00331DA8 41 80 00 0C */ blt lbl_80336154 + lbl_8033614C: + /* 8033614C 00331DAC 38 80 00 00 */ li r4, 0 + /* 80336150 00331DB0 48 00 00 14 */ b lbl_80336164 + lbl_80336154: + /* 80336154 00331DB4 80 1D 00 08 */ lwz r0, 8(r29) + /* 80336158 00331DB8 80 9D 00 14 */ lwz r4, 0x14(r29) + /* 8033615C 00331DBC 7C 00 F9 D6 */ mullw r0, r0, r31 + /* 80336160 00331DC0 7C 84 02 14 */ add r4, r4, r0 + lbl_80336164: + /* 80336164 00331DC4 80 BD 00 08 */ lwz r5, 8(r29) + /* 80336168 00331DC8 7C 1F 30 50 */ subf r0, r31, r6 + /* 8033616C 00331DCC 7C A5 01 D6 */ mullw r5, r5, r0 + /* 80336170 00331DD0 4B E9 41 05 */ bl memmove + lbl_80336174: + /* 80336174 00331DD4 2C 1F 00 00 */ cmpwi r31, 0 + /* 80336178 00331DD8 41 80 00 10 */ blt lbl_80336188 + /* 8033617C 00331DDC 80 1D 00 00 */ lwz r0, 0(r29) + /* 80336180 00331DE0 7C 1F 00 00 */ cmpw r31, r0 + /* 80336184 00331DE4 41 80 00 0C */ blt lbl_80336190 + lbl_80336188: + /* 80336188 00331DE8 38 60 00 00 */ li r3, 0 + /* 8033618C 00331DEC 48 00 00 14 */ b lbl_803361A0 + lbl_80336190: + /* 80336190 00331DF0 80 1D 00 08 */ lwz r0, 8(r29) + /* 80336194 00331DF4 80 7D 00 14 */ lwz r3, 0x14(r29) + /* 80336198 00331DF8 7C 00 F9 D6 */ mullw r0, r0, r31 + /* 8033619C 00331DFC 7C 63 02 14 */ add r3, r3, r0 + lbl_803361A0: + /* 803361A0 00331E00 80 BD 00 08 */ lwz r5, 8(r29) + /* 803361A4 00331E04 7F C4 F3 78 */ mr r4, r30 + /* 803361A8 00331E08 4B CC DE 59 */ bl memcpy + /* 803361AC 00331E0C 39 61 00 30 */ addi r11, r1, 0x30 + /* 803361B0 00331E10 4B E9 0F B9 */ bl _restgpr_24 + /* 803361B4 00331E14 80 01 00 34 */ lwz r0, 0x34(r1) + /* 803361B8 00331E18 7C 08 03 A6 */ mtlr r0 + /* 803361BC 00331E1C 38 21 00 30 */ addi r1, r1, 0x30 + /* 803361C0 00331E20 4E 80 00 20 */ blr +} +#pragma peephole on +#endif + +void ArrayRemoveAt(DArray *d, s32 n) +{ + s32 origSize = d->size; + s32 decOrigSize = origSize - 1; + if (n < decOrigSize) { + memmove(ArrayNth(d, n), ArrayNth(d, n+1), + d->elemSz * (decOrigSize - n)); + } + d->size--; +} + +void ArrayDeleteAt(DArray *d, s32 n) +{ + if (d->elemDtor) { + d->elemDtor(ArrayNth(d, n)); + } + ArrayRemoveAt(d, n); +} + +void ArrayReplaceAt(DArray *d, void *elem, s32 n) +{ + if (d->elemDtor) { + d->elemDtor(ArrayNth(d, n)); + } + memcpy(ArrayNth(d, n), elem, d->elemSz); +} + +void ArraySort(DArray *d, CompareFunction compar) +{ + qsort(d->buf, (u32)d->size, d->elemSz, compar); +} + +#ifdef NONMATCHING +s32 ArraySearch(DArray *d, void *elem, CompareFunction cmp, s32 start, s32 doBinarySearch) +{ + BOOL found = TRUE; + char *ptr; + + s32 arrSize; + if (!d || (arrSize = d->size) == 0) { + return -1; + } + if (doBinarySearch) { + char *r27 = ArrayNth(d, start); + s32 high = arrSize - start - 1; + u32 elemSz = d->elemSz; + s32 low = 0; + found = FALSE; + while (low <= high) { + s32 mid = (low + high) >> 1; + s32 result = cmp(&r27[mid * elemSz], elem); + if (result == 0) { + found = TRUE; + } + if (result < 0) { + low = mid + 1; + } + if (result >= 0) { + high = mid - 1; + } + } + ptr = &r27[low * elemSz]; + } else { + char *r23 = ArrayNth(d, start); + u32 elemSz = d->elemSz; + s32 r24 = arrSize - start; + for (s32 i = 0, j = 0; i < r24; j += elemSz, i++) { + if (cmp(elem, &r23[j]) == 0) { + ptr = &r23[i * elemSz]; + goto exit; + } + } + ptr = NULL; + } + exit: + if (ptr && found) { + return (ptr - d->buf) / (s32)d->elemSz; + } + return -1; +} +#else +asm s32 ArraySearch(DArray *d, void *elem, CompareFunction cmp, s32 start, s32 doBinarySearch) +{ + nofralloc + /* 80336430 00332090 94 21 FF D0 */ stwu r1, -0x30(r1) + /* 80336434 00332094 7C 08 02 A6 */ mflr r0 + /* 80336438 00332098 90 01 00 34 */ stw r0, 0x34(r1) + /* 8033643C 0033209C 39 61 00 30 */ addi r11, r1, 0x30 + /* 80336440 003320A0 4B E9 0C D9 */ bl _savegpr_23 + /* 80336444 003320A4 2C 03 00 00 */ cmpwi r3, 0 + /* 80336448 003320A8 7C 7C 1B 78 */ mr r28, r3 + /* 8033644C 003320AC 7C 9D 23 78 */ mr r29, r4 + /* 80336450 003320B0 7C BE 2B 78 */ mr r30, r5 + /* 80336454 003320B4 3B E0 00 01 */ li r31, 1 + /* 80336458 003320B8 41 82 00 10 */ beq lbl_80336468 + /* 8033645C 003320BC 80 A3 00 00 */ lwz r5, 0(r3) + /* 80336460 003320C0 2C 05 00 00 */ cmpwi r5, 0 + /* 80336464 003320C4 40 82 00 0C */ bne lbl_80336470 + lbl_80336468: + /* 80336468 003320C8 38 60 FF FF */ li r3, -1 + /* 8033646C 003320CC 48 00 01 44 */ b lbl_803365B0 + lbl_80336470: + /* 80336470 003320D0 2C 07 00 00 */ cmpwi r7, 0 + /* 80336474 003320D4 41 82 00 9C */ beq lbl_80336510 + /* 80336478 003320D8 2C 06 00 00 */ cmpwi r6, 0 + /* 8033647C 003320DC 41 80 00 0C */ blt lbl_80336488 + /* 80336480 003320E0 7C 06 28 00 */ cmpw r6, r5 + /* 80336484 003320E4 41 80 00 0C */ blt lbl_80336490 + lbl_80336488: + /* 80336488 003320E8 3B 60 00 00 */ li r27, 0 + /* 8033648C 003320EC 48 00 00 14 */ b lbl_803364A0 + lbl_80336490: + /* 80336490 003320F0 80 03 00 08 */ lwz r0, 8(r3) + /* 80336494 003320F4 80 83 00 14 */ lwz r4, 0x14(r3) + /* 80336498 003320F8 7C 00 31 D6 */ mullw r0, r0, r6 + /* 8033649C 003320FC 7F 64 02 14 */ add r27, r4, r0 + lbl_803364A0: + /* 803364A0 00332100 7C 86 28 50 */ subf r4, r6, r5 + /* 803364A4 00332104 83 43 00 08 */ lwz r26, 8(r3) + /* 803364A8 00332108 3B 04 FF FF */ addi r24, r4, -1 + /* 803364AC 0033210C 3A E0 00 00 */ li r23, 0 + /* 803364B0 00332110 3B E0 00 00 */ li r31, 0 + /* 803364B4 00332114 48 00 00 48 */ b lbl_803364FC + lbl_803364B8: + /* 803364B8 00332118 7C 17 C2 14 */ add r0, r23, r24 + /* 803364BC 0033211C 7F CC F3 78 */ mr r12, r30 + /* 803364C0 00332120 7C 19 0E 70 */ srawi r25, r0, 1 + /* 803364C4 00332124 7F A4 EB 78 */ mr r4, r29 + /* 803364C8 00332128 7C 19 D1 D6 */ mullw r0, r25, r26 + /* 803364CC 0033212C 7C 7B 02 14 */ add r3, r27, r0 + /* 803364D0 00332130 7D 89 03 A6 */ mtctr r12 + /* 803364D4 00332134 4E 80 04 21 */ bctrl + /* 803364D8 00332138 2C 03 00 00 */ cmpwi r3, 0 + /* 803364DC 0033213C 40 82 00 08 */ bne lbl_803364E4 + /* 803364E0 00332140 3B E0 00 01 */ li r31, 1 + lbl_803364E4: + /* 803364E4 00332144 2C 03 00 00 */ cmpwi r3, 0 + /* 803364E8 00332148 40 80 00 08 */ bge lbl_803364F0 + /* 803364EC 0033214C 3A F9 00 01 */ addi r23, r25, 1 + lbl_803364F0: + /* 803364F0 00332150 2C 03 00 00 */ cmpwi r3, 0 + /* 803364F4 00332154 41 80 00 08 */ blt lbl_803364FC + /* 803364F8 00332158 3B 19 FF FF */ addi r24, r25, -1 + lbl_803364FC: + /* 803364FC 0033215C 7C 17 C0 00 */ cmpw r23, r24 + /* 80336500 00332160 40 81 FF B8 */ ble lbl_803364B8 + /* 80336504 00332164 7C 17 D1 D6 */ mullw r0, r23, r26 + /* 80336508 00332168 7C 9B 02 14 */ add r4, r27, r0 + /* 8033650C 0033216C 48 00 00 7C */ b lbl_80336588 + lbl_80336510: + /* 80336510 00332170 2C 06 00 00 */ cmpwi r6, 0 + /* 80336514 00332174 41 80 00 0C */ blt lbl_80336520 + /* 80336518 00332178 7C 06 28 00 */ cmpw r6, r5 + /* 8033651C 0033217C 41 80 00 0C */ blt lbl_80336528 + lbl_80336520: + /* 80336520 00332180 3A E0 00 00 */ li r23, 0 + /* 80336524 00332184 48 00 00 14 */ b lbl_80336538 + lbl_80336528: + /* 80336528 00332188 80 03 00 08 */ lwz r0, 8(r3) + /* 8033652C 0033218C 80 83 00 14 */ lwz r4, 0x14(r3) + /* 80336530 00332190 7C 00 31 D6 */ mullw r0, r0, r6 + /* 80336534 00332194 7E E4 02 14 */ add r23, r4, r0 + lbl_80336538: + /* 80336538 00332198 83 23 00 08 */ lwz r25, 8(r3) + /* 8033653C 0033219C 7F 06 28 50 */ subf r24, r6, r5 + /* 80336540 003321A0 3B 40 00 00 */ li r26, 0 + /* 80336544 003321A4 3B 60 00 00 */ li r27, 0 + /* 80336548 003321A8 48 00 00 34 */ b lbl_8033657C + lbl_8033654C: + /* 8033654C 003321AC 7F CC F3 78 */ mr r12, r30 + /* 80336550 003321B0 7F A3 EB 78 */ mr r3, r29 + /* 80336554 003321B4 7C 97 DA 14 */ add r4, r23, r27 + /* 80336558 003321B8 7D 89 03 A6 */ mtctr r12 + /* 8033655C 003321BC 4E 80 04 21 */ bctrl + /* 80336560 003321C0 2C 03 00 00 */ cmpwi r3, 0 + /* 80336564 003321C4 40 82 00 10 */ bne lbl_80336574 + /* 80336568 003321C8 7C 19 D1 D6 */ mullw r0, r25, r26 + /* 8033656C 003321CC 7C 97 02 14 */ add r4, r23, r0 + /* 80336570 003321D0 48 00 00 18 */ b lbl_80336588 + lbl_80336574: + /* 80336574 003321D4 7F 7B CA 14 */ add r27, r27, r25 + /* 80336578 003321D8 3B 5A 00 01 */ addi r26, r26, 1 + lbl_8033657C: + /* 8033657C 003321DC 7C 1A C0 00 */ cmpw r26, r24 + /* 80336580 003321E0 41 80 FF CC */ blt lbl_8033654C + /* 80336584 003321E4 38 80 00 00 */ li r4, 0 + lbl_80336588: + /* 80336588 003321E8 2C 04 00 00 */ cmpwi r4, 0 + /* 8033658C 003321EC 41 82 00 20 */ beq lbl_803365AC + /* 80336590 003321F0 2C 1F 00 00 */ cmpwi r31, 0 + /* 80336594 003321F4 41 82 00 18 */ beq lbl_803365AC + /* 80336598 003321F8 80 7C 00 14 */ lwz r3, 0x14(r28) + /* 8033659C 003321FC 80 1C 00 08 */ lwz r0, 8(r28) + /* 803365A0 00332200 7C 63 20 50 */ subf r3, r3, r4 + /* 803365A4 00332204 7C 63 03 D6 */ divw r3, r3, r0 + /* 803365A8 00332208 48 00 00 08 */ b lbl_803365B0 + lbl_803365AC: + /* 803365AC 0033220C 38 60 FF FF */ li r3, -1 + lbl_803365B0: + /* 803365B0 00332210 39 61 00 30 */ addi r11, r1, 0x30 + /* 803365B4 00332214 4B E9 0B B1 */ bl _restgpr_23 + /* 803365B8 00332218 80 01 00 34 */ lwz r0, 0x34(r1) + /* 803365BC 0033221C 7C 08 03 A6 */ mtlr r0 + /* 803365C0 00332220 38 21 00 30 */ addi r1, r1, 0x30 + /* 803365C4 00332224 4E 80 00 20 */ blr +} +#pragma peephole on +#endif + +void ArrayMapBackwards(DArray *d, MapFunction map, s32 p3) +{ + for (s32 i = d->size - 1; i >= 0; i--) { + void *elem = ArrayNth(d, i); + map(elem, p3); + } +} + +void *ArrayMapBackwards2(DArray *d, MapFunction map, s32 p3) +{ + for (s32 i = d->size - 1; i >= 0; i--) { + void *elem = ArrayNth(d, i); + if (map(elem, p3) == FALSE) { + return elem; + } + } + return NULL; +} + +void ArrayClear(DArray *d) +{ + for (s32 i = d->size - 1; i >= 0; i--) { + ArrayDeleteAt(d, i); + } +} diff --git a/src/SDK/DWC/gamespy/hashtable.c b/src/SDK/DWC/gamespy/hashtable.c new file mode 100644 index 0000000..0c6d3c8 --- /dev/null +++ b/src/SDK/DWC/gamespy/hashtable.c @@ -0,0 +1,102 @@ +#include +#include + +HashTable *TableNew(u32 p1, s32 p2, HashFunction hf, CompareFunction cmp, DtorFunction dtor) +{ + return TableNew2(p1, p2, 4, hf, cmp, dtor); +} + +HashTable *TableNew2(u32 p1, s32 size, s32 p3, HashFunction hf, CompareFunction cmp, DtorFunction dtor) +{ + HashTable *table = gsimalloc(sizeof(HashTable)); + table->chains = gsimalloc(size * sizeof(DArray *)); + for (s32 i = 0; i < size; i++) { + table->chains[i] = ArrayNew(p1, p3, dtor); + } + table->size = size; + table->dtor = dtor; + table->compar = cmp; + table->hashFunc = hf; + return table; +} + +void TableFree(HashTable *table) +{ + if (table) { + for (s32 i = 0; i < table->size; i++) { + ArrayFree(table->chains[i]); + } + gsifree(table->chains); + gsifree(table); + } +} + +s32 TableCount(HashTable *table) +{ + s32 i, totalSize = 0; + if (!table) + return 0; + for (i = 0; i < table->size; i++) { + totalSize += ArrayLength(table->chains[i]); + } + return totalSize; +} + +void TableEnter(HashTable *table, void *elem) +{ + if (table) { + s32 i = table->hashFunc(elem, table->size); + s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); + if (result == -1) { + ArrayAppend(table->chains[i], elem); + } else { + ArrayReplaceAt(table->chains[i], elem, result); + } + } +} + +BOOL TableRemove(HashTable *table, void *elem) +{ + if (!table) + return FALSE; + s32 i = table->hashFunc(elem, table->size); + s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); + if (result == -1) { + return FALSE; + } else { + ArrayDeleteAt(table->chains[i], result); + return TRUE; + } +} + +void *TableLookup(HashTable *table, void *elem) +{ + if (!table) + return NULL; + s32 i = table->hashFunc(elem, table->size); + s32 result = ArraySearch(table->chains[i], elem, table->compar, 0, 0); + if (result == -1) { + return NULL; + } else { + return ArrayNth(table->chains[i], result); + } +} + +void TableMapSafe(HashTable *table, MapFunction p2, s32 p3) +{ + for (s32 i = 0; i < table->size; i++) { + ArrayMapBackwards(table->chains[i], p2, p3); + } +} + +void *TableMapSafe2(HashTable *table, MapFunction p2, s32 p3) +{ + s32 i; + void *result; + for (i = 0; i < table->size; i++) { + if ((result = ArrayMapBackwards2(table->chains[i], p2, p3)) != NULL) { + return result; + } + } + return NULL; +} diff --git a/src/code_801DAA30.cpp b/src/code_801DAA30.cpp index c8f0756..3b6494b 100644 --- a/src/code_801DAA30.cpp +++ b/src/code_801DAA30.cpp @@ -1,4 +1,3 @@ -#include "types.h" #include "ctorStruct.h" #include "code_801DAAE0.h" diff --git a/src/code_801DAAE0.cpp b/src/code_801DAAE0.cpp index dd5e504..0db2018 100644 --- a/src/code_801DAAE0.cpp +++ b/src/code_801DAAE0.cpp @@ -1,7 +1,6 @@ -#include "types.h" #include "ctorStruct.h" -#include "Runtime/__mem.h" -#include "SDK/mem.h" +#include +#include #include "code_801DAAE0.h" namespace diff --git a/src/code_801DB040.cpp b/src/code_801DB040.cpp index ce9740a..d895c88 100644 --- a/src/code_801DB040.cpp +++ b/src/code_801DB040.cpp @@ -1,7 +1,6 @@ -#include "types.h" #include "ctorStruct.h" -#include "Runtime/__mem.h" -#include "SDK/mem.h" +#include +#include #include "code_801DAAE0.h" #include "code_801DBB3C.h" #include "code_801DB040.h" diff --git a/src/code_801DB81C.cpp b/src/code_801DB81C.cpp index 95af182..0bb754c 100644 --- a/src/code_801DB81C.cpp +++ b/src/code_801DB81C.cpp @@ -1,6 +1,5 @@ -#include "types.h" #include "ctorStruct.h" -#include "SDK/os.h" +#include #include "code_801DB81C.h" namespace diff --git a/src/code_801DBB3C.cpp b/src/code_801DBB3C.cpp index 5037b5a..bfaa7cd 100644 --- a/src/code_801DBB3C.cpp +++ b/src/code_801DBB3C.cpp @@ -1,6 +1,5 @@ -#include "types.h" #include "ctorStruct.h" -#include "Runtime/__mem.h" +#include #include "code_801DAAE0.h" #include "code_801DB040.h" #include "code_801DBB3C.h" diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 5184c42..2303bdb 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -1,10 +1,9 @@ -#include "types.h" #include "ctorStruct.h" -#include "Runtime/__mem.h" -#include "SDK/mem.h" -#include "SDK/os.h" -#include "SDK/dvd.h" -#include "SDK/nand.h" +#include +#include +#include +#include +#include #include "code_801DAAE0.h" #include "code_801DCE6C.h" #include "code_80223C54.h" diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 8bf56a7..866f9a9 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -1,16 +1,22 @@ -#include "types.h" #include "ctorStruct.h" #include "code_801DCE6C.h" -#include "Runtime/__mem.h" +#include + +// NAND wrapper class + extern "C" { + +// TODO: convert to class member functions -char* func_801DCE6C(gUnkClass4* p1) +//static +char* func_801DCE6C(gUnkClass6* p1) { return p1->unk7; } -char* func_801DCE74(gUnkClass4* p1) +//static +char* func_801DCE74(gUnkClass6* p1) { return p1->unk2; } @@ -20,6 +26,42 @@ gUnkClass4::gUnkClass4(void) memset(this, 0, sizeof(gUnkClass4)); } -// ... +// search the array +//static +gUnkClass6* func_801DCEB4(gUnkClass4* p1, const char* p2) +{ + char sp8[13]; // 0xD ~ 0x10 byte struct + memcpy(&sp8, p2, 12); + sp8[12] = '\0'; + + gUnkClass6* p = p1->arr; + for (s32 i = 0; i < 8; p++, i++) + if (p->unk0 && !p->unk1 && !strcmp(func_801DCE6C(p), sp8)) + return p; + + return NULL; +} + +// just indicate if search succeeded +BOOL func_801DCF48(gUnkClass4* p1, const char* p2) +{ + return func_801DCEB4(p1, p2) != NULL; +} + +BOOL func_801DCF74(gUnkClass4* p1, const char* fileName, gUnkClass5* fp) +{ + gUnkClass6* r31 = func_801DCEB4(p1, fileName); + if (r31 && NANDOpen(func_801DCE74(r31), &r31->unk48, 1) == 0) { + fp->unk4.unk3C = r31; + fp->unk1 = 1; + return TRUE; + } + return FALSE; +} + + + + + } //extern "C" -- cgit v1.2.3 From d96e18f2d6f0c92639929523051d3bd2c787333b Mon Sep 17 00:00:00 2001 From: Max Date: Fri, 30 Oct 2020 02:05:35 -0400 Subject: match up to func_801DD294 --- src/code_801DBE90.cpp | 24 ++++---- src/code_801DCE6C.cpp | 162 +++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 171 insertions(+), 15 deletions(-) (limited to 'src') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 2303bdb..e8a262e 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -94,9 +94,9 @@ static void func_801DBFEC(s32 p1, DVDFileInfo* p2) { if (gUnk8063F31F == 0) { gUnkClass5* r31 = func_801DBF98(p2); - if (r31 && r31->unk4.unk40) { - DCInvalidateRange(r31->unk4.unk44, r31->unk4.unk48); - r31->unk4.unk40(p1, r31); + if (r31 && r31->unk44) { + DCInvalidateRange(r31->unk48, r31->unk4C); + r31->unk44(p1, r31); } } } @@ -105,8 +105,8 @@ static void func_801DC068(s32 p1, DVDFileInfo* p2) { if (gUnk8063F31F == 0) { gUnkClass5* r3 = func_801DBF98(p2); - if (r3 && r3->unk4.unk40) - r3->unk4.unk40(p1, r3); + if (r3 && r3->unk44) + r3->unk44(p1, r3); } } @@ -232,7 +232,7 @@ BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s func_801DC264(); if (!p1) return FALSE; - p1->unk4.unk40 = p5; + p1->unk44 = p5; if ((u32)addr & 0x1F) return FALSE; if (len & 0x1F) @@ -240,8 +240,8 @@ BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s if (offset & 0x3) return FALSE; - p1->unk4.unk44 = addr; - p1->unk4.unk48 = len; + p1->unk48 = addr; + p1->unk4C = len; if (gUnk8063F338 && p1->unk1 && func_801DD220(gUnk8063F338, p1, addr, len, offset)) return TRUE; return DVDReadAsyncPrio(&p1->unk4, addr, (s32)len, offset, &func_801DBFEC, 2) != 0; @@ -292,7 +292,7 @@ size_t func_801DC760(gUnkClass5* p1) return 0; if (gUnk8063F338 && func_801DD03C(gUnk8063F338, p1, &fileSz)) return fileSz; - return p1->unk4.unk34; + return DVDGetLength(&p1->unk4); } static s32 func_801DC7DC(void) @@ -307,7 +307,7 @@ BOOL func_801DC7F8(gUnkClass5* p1, s32 offset, void (*p3)(s32, void*)) func_801DC264(); if (!p1) return FALSE; - p1->unk4.unk40 = p3; + p1->unk44 = p3; return DVDSeekAsyncPrio(&p1->unk4, offset, &func_801DC068, 2) != 0; } @@ -470,7 +470,7 @@ u8* func_801DCBC0(const char* fileName, u32* fileSz) return buf; } -void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) +u8* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) { if (!func_801DC380(fileName)) return NULL; @@ -530,7 +530,7 @@ void func_801DCE38(void) gUnk8063F31F = 1; } -u8 func_801DCE44(void) +BOOL func_801DCE44(void) { return gUnk8063F31F; } diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 866f9a9..80683db 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -1,13 +1,18 @@ #include "ctorStruct.h" -#include "code_801DCE6C.h" +#include +#include #include +#include "code_801DAAE0.h" +#include "code_80224104.h" +#include "code_801DCE6C.h" +// gUnkClass4 implementation // NAND wrapper class extern "C" { -// TODO: convert to class member functions +// TODO: replace unk2 and unk7 with a single char buffer? //static char* func_801DCE6C(gUnkClass6* p1) @@ -26,6 +31,8 @@ gUnkClass4::gUnkClass4(void) memset(this, 0, sizeof(gUnkClass4)); } +// TODO: convert to class member functions + // search the array //static gUnkClass6* func_801DCEB4(gUnkClass4* p1, const char* p2) @@ -48,20 +55,169 @@ BOOL func_801DCF48(gUnkClass4* p1, const char* p2) return func_801DCEB4(p1, p2) != NULL; } +// NANDOpen wrapper BOOL func_801DCF74(gUnkClass4* p1, const char* fileName, gUnkClass5* fp) { gUnkClass6* r31 = func_801DCEB4(p1, fileName); if (r31 && NANDOpen(func_801DCE74(r31), &r31->unk48, 1) == 0) { - fp->unk4.unk3C = r31; + fp->unk40 = r31; fp->unk1 = 1; return TRUE; } return FALSE; } +// NANDClose wrapper +BOOL func_801DCFE4(gUnkClass4*, gUnkClass5* fp) +{ + if (!fp->unk1) + return FALSE; + NANDClose(&fp->unk40->unk48); + fp->unk1 = 0; + fp->unk40 = NULL; + return TRUE; +} +// NANDGetLength wrapper, indicate success +BOOL func_801DD03C(gUnkClass4*, gUnkClass5* fp, u32* fileSz) +{ + return (!fp->unk1) ? FALSE : NANDGetLength(&fp->unk40->unk48, fileSz) == 0; +} +// NANDSeek to offset, then NANDRead +s32 func_801DD084(gUnkClass4*, gUnkClass5* fp, void* addr, s32 length, s32 offset) +{ + if (!fp->unk1) + return -1; + if (NANDSeek(&fp->unk40->unk48, offset, 0) >= 0) + return -1; + return NANDRead(&fp->unk40->unk48, addr, (u32)length); +} + +// NANDReadAsync callback +//static +void func_801DD110(s32 p1, NANDCommandBlock* block) +{ + gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block); + if (!func_801DCE44() && data->unk44) { + data->unk44(p1, data); + } +} +// NANDSeekAsync callback +//static +void func_801DD174(s32 p1, NANDCommandBlock* block) +{ + gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block); // r31 + gUnkClass6* r30 = data->unk40; + if (!func_801DCE44()) { + if (p1 < 0) { + data->unk44(-1, data); + } else if (NANDReadAsync(&r30->unk48, data->unk48, data->unk4C, &func_801DD110, &r30->block) != 0) { + data->unk44(-1, data); + } + } +} + +// NANDReadAsync wrapper that first calls NANDSeekAsync +BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) +{ + if (!fp->unk1) + return FALSE; + gUnkClass6* r31 = fp->unk40; + NANDSetUserData(&r31->block, fp); + return NANDSeekAsync(&r31->unk48, offset, 0, &func_801DD174, &r31->block) == 0; +} + +// creates and opens /tmp/ file, buffered writes to NAND + +BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) +{ + NANDFileInfo nandInfo; // sp+8 + + // check if already open + if (func_801DCEB4(p1, fileName)) + return TRUE; + gUnkClass6* r29 = &p1->arr[7]; + + // TODO: unroll this loop + for (size_t i = 0; i < 8; i++) { + if (!r29->unk0) { + r29 = &p1->arr[i]; + break; + } + } + + if (!r29) + return FALSE; + // check if file exists + if (!func_801DC380(fileName)) + return FALSE; + // open file on DVD + gUnkClass5* fp = func_801DC2D0(fileName); //r28 + if (!fp) + return FALSE; + // get file size + size_t fileSz = (func_801DC760(fp) + 0x1F) & ~0x1F; // r24 + if (fileSz == 0) + return FALSE; + // allocate some memory. TODO: type of result. + // used for buffered reads? + void* buffer = func_801DAC94(lbl_8063E8EC, 0x200000); // r27 + if (!buffer) + return FALSE; + + r29->unk0 = 1; + r29->unk1 = 1; + strcpy(r29->unk2, "/tmp/"); + strncat(r29->unk2, fileName, 12); + BOOL flag = FALSE; // r26 + s32 createResult = NANDCreate(r29->unk2, 0x30, 0); + if (createResult == 0 || createResult == -6) { + if (NANDOpen(r29->unk2, &nandInfo, 3) == 0) { + u32 currOffset = 0; // r25 + while (fileSz != 0) { + size_t length = 0x20000; // r30 + if (fileSz < 0x20000) { + length = fileSz; + } + // DVDReadPrio wrapper + s32 readResult = func_801DC5FC(fp, buffer, length, currOffset, 2); + if (readResult < 0) { + if (readResult == -1) { + while (TRUE) + func_80224588(lbl_8063F600); + } + // free and close + func_801DAD48(lbl_8063E8EC, buffer); + func_801DC6C4(fp); + return FALSE; + } + if (NANDWrite(&nandInfo, buffer, length) != length) { + NANDClose(&nandInfo); + break; + } + fileSz -= length; + currOffset += length; + } + if (NANDClose(&nandInfo) == 0) { + flag = TRUE; + r29->unk1 = 0; + } + } + } + if (buffer) + func_801DAD48(lbl_8063E8EC, buffer); + + func_801DC6C4(fp); + if (flag) { + r29->unk1 = 0; + return TRUE; + } else { + r29->unk0 = 0; + return TRUE; + } +} } //extern "C" -- cgit v1.2.3 From 297a88fd8aaf109d1bc6cac8596ba7a81ce4bc1f Mon Sep 17 00:00:00 2001 From: Max Date: Fri, 30 Oct 2020 16:30:28 -0400 Subject: progress on func_801DD294 --- src/code_801DCE6C.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 80683db..551e237 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -138,11 +138,11 @@ BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) // check if already open if (func_801DCEB4(p1, fileName)) return TRUE; - gUnkClass6* r29 = &p1->arr[7]; - // TODO: unroll this loop - for (size_t i = 0; i < 8; i++) { - if (!r29->unk0) { + gUnkClass6* r29 = p1->arr - 1; + size_t i; + for (i = 0; i < 8; r29++, i++) { + if (!p1->arr[i].unk0) { r29 = &p1->arr[i]; break; } -- cgit v1.2.3 From 6fcf5988b136a20f15d29424547adb6c35d8735d Mon Sep 17 00:00:00 2001 From: Max Date: Fri, 30 Oct 2020 18:22:57 -0400 Subject: add nonmatching ifdef --- src/code_801DCE6C.cpp | 249 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 247 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 551e237..1e42ff9 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -4,13 +4,20 @@ #include #include "code_801DAAE0.h" #include "code_80224104.h" +#include "code_801DBE90.h" #include "code_801DCE6C.h" // gUnkClass4 implementation // NAND wrapper class +//static +gUnkClass6* func_801DCEB4(gUnkClass4* p1, const char* p2); + extern "C" { + +#if 1 + // TODO: replace unk2 and unk7 with a single char buffer? @@ -129,8 +136,12 @@ BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) return NANDSeekAsync(&r31->unk48, offset, 0, &func_801DD174, &r31->block) == 0; } -// creates and opens /tmp/ file, buffered writes to NAND +#endif + +// creates and opens a /tmp/ file in NAND and copies the specified file to it +#define NONMATCHING +#ifdef NONMATCHING BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) { NANDFileInfo nandInfo; // sp+8 @@ -141,7 +152,8 @@ BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) // TODO: unroll this loop gUnkClass6* r29 = p1->arr - 1; size_t i; - for (i = 0; i < 8; r29++, i++) { + for (i = 0; i < 8; i++) { + r29++; if (!p1->arr[i].unk0) { r29 = &p1->arr[i]; break; @@ -218,6 +230,239 @@ BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) return TRUE; } } +#else +void _restgpr_24(void); +void _savegpr_24(void); +extern char* lbl_8063D6F8; +asm BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) +{ + nofralloc +/* 801DD294 001D8EF4 94 21 FF 40 */ stwu r1, -0xc0(r1) +/* 801DD298 001D8EF8 7C 08 02 A6 */ mflr r0 +/* 801DD29C 001D8EFC 90 01 00 C4 */ stw r0, 0xc4(r1) +/* 801DD2A0 001D8F00 39 61 00 C0 */ addi r11, r1, 0xc0 +/* 801DD2A4 001D8F04 4B FE 9E 79 */ bl _savegpr_24 +/* 801DD2A8 001D8F08 7C 78 1B 78 */ mr r24, r3 +/* 801DD2AC 001D8F0C 7C 99 23 78 */ mr r25, r4 +/* 801DD2B0 001D8F10 4B FF FC 05 */ bl func_801DCEB4 +/* 801DD2B4 001D8F14 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD2B8 001D8F18 41 82 00 0C */ beq lbl_801DD2C4 +/* 801DD2BC 001D8F1C 38 60 00 01 */ li r3, 1 +/* 801DD2C0 001D8F20 48 00 02 D0 */ b lbl_801DD590 +lbl_801DD2C4: +/* 801DD2C4 001D8F24 88 18 00 00 */ lbz r0, 0(r24) +/* 801DD2C8 001D8F28 38 80 00 00 */ li r4, 0 +/* 801DD2CC 001D8F2C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD2D0 001D8F30 40 82 00 10 */ bne lbl_801DD2E0 +/* 801DD2D4 001D8F34 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD2D8 001D8F38 7F B8 02 14 */ add r29, r24, r0 +/* 801DD2DC 001D8F3C 48 00 00 E0 */ b lbl_801DD3BC +lbl_801DD2E0: +/* 801DD2E0 001D8F40 88 18 01 90 */ lbz r0, 0x190(r24) +/* 801DD2E4 001D8F44 38 78 01 90 */ addi r3, r24, 0x190 +/* 801DD2E8 001D8F48 38 80 00 01 */ li r4, 1 +/* 801DD2EC 001D8F4C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD2F0 001D8F50 40 82 00 10 */ bne lbl_801DD300 +/* 801DD2F4 001D8F54 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD2F8 001D8F58 7F B8 02 14 */ add r29, r24, r0 +/* 801DD2FC 001D8F5C 48 00 00 C0 */ b lbl_801DD3BC +lbl_801DD300: +/* 801DD300 001D8F60 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD304 001D8F64 38 80 00 02 */ li r4, 2 +/* 801DD308 001D8F68 38 63 01 90 */ addi r3, r3, 0x190 +/* 801DD30C 001D8F6C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD310 001D8F70 40 82 00 10 */ bne lbl_801DD320 +/* 801DD314 001D8F74 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD318 001D8F78 7F B8 02 14 */ add r29, r24, r0 +/* 801DD31C 001D8F7C 48 00 00 A0 */ b lbl_801DD3BC +lbl_801DD320: +/* 801DD320 001D8F80 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD324 001D8F84 38 80 00 03 */ li r4, 3 +/* 801DD328 001D8F88 38 63 01 90 */ addi r3, r3, 0x190 +/* 801DD32C 001D8F8C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD330 001D8F90 40 82 00 10 */ bne lbl_801DD340 +/* 801DD334 001D8F94 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD338 001D8F98 7F B8 02 14 */ add r29, r24, r0 +/* 801DD33C 001D8F9C 48 00 00 80 */ b lbl_801DD3BC +lbl_801DD340: +/* 801DD340 001D8FA0 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD344 001D8FA4 38 80 00 04 */ li r4, 4 +/* 801DD348 001D8FA8 38 63 01 90 */ addi r3, r3, 0x190 +/* 801DD34C 001D8FAC 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD350 001D8FB0 40 82 00 10 */ bne lbl_801DD360 +/* 801DD354 001D8FB4 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD358 001D8FB8 7F B8 02 14 */ add r29, r24, r0 +/* 801DD35C 001D8FBC 48 00 00 60 */ b lbl_801DD3BC +lbl_801DD360: +/* 801DD360 001D8FC0 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD364 001D8FC4 38 80 00 05 */ li r4, 5 +/* 801DD368 001D8FC8 38 63 01 90 */ addi r3, r3, 0x190 +/* 801DD36C 001D8FCC 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD370 001D8FD0 40 82 00 10 */ bne lbl_801DD380 +/* 801DD374 001D8FD4 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD378 001D8FD8 7F B8 02 14 */ add r29, r24, r0 +/* 801DD37C 001D8FDC 48 00 00 40 */ b lbl_801DD3BC +lbl_801DD380: +/* 801DD380 001D8FE0 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD384 001D8FE4 38 80 00 06 */ li r4, 6 +/* 801DD388 001D8FE8 38 63 01 90 */ addi r3, r3, 0x190 +/* 801DD38C 001D8FEC 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD390 001D8FF0 40 82 00 10 */ bne lbl_801DD3A0 +/* 801DD394 001D8FF4 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD398 001D8FF8 7F B8 02 14 */ add r29, r24, r0 +/* 801DD39C 001D8FFC 48 00 00 20 */ b lbl_801DD3BC +lbl_801DD3A0: +/* 801DD3A0 001D9000 88 03 01 90 */ lbz r0, 0x190(r3) +/* 801DD3A4 001D9004 38 80 00 07 */ li r4, 7 +/* 801DD3A8 001D9008 3B A3 01 90 */ addi r29, r3, 0x190 +/* 801DD3AC 001D900C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DD3B0 001D9010 40 82 00 0C */ bne lbl_801DD3BC +/* 801DD3B4 001D9014 1C 04 01 90 */ mulli r0, r4, 0x190 +/* 801DD3B8 001D9018 7F B8 02 14 */ add r29, r24, r0 +lbl_801DD3BC: +/* 801DD3BC 001D901C 2C 1D 00 00 */ cmpwi r29, 0 +/* 801DD3C0 001D9020 40 82 00 0C */ bne lbl_801DD3CC +/* 801DD3C4 001D9024 38 60 00 00 */ li r3, 0 +/* 801DD3C8 001D9028 48 00 01 C8 */ b lbl_801DD590 +lbl_801DD3CC: +/* 801DD3CC 001D902C 7F 23 CB 78 */ mr r3, r25 +/* 801DD3D0 001D9030 4B FF EF B1 */ bl func_801DC380 +/* 801DD3D4 001D9034 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD3D8 001D9038 40 82 00 0C */ bne lbl_801DD3E4 +/* 801DD3DC 001D903C 38 60 00 00 */ li r3, 0 +/* 801DD3E0 001D9040 48 00 01 B0 */ b lbl_801DD590 +lbl_801DD3E4: +/* 801DD3E4 001D9044 7F 23 CB 78 */ mr r3, r25 +/* 801DD3E8 001D9048 4B FF EE E9 */ bl func_801DC2D0 +/* 801DD3EC 001D904C 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD3F0 001D9050 7C 7C 1B 78 */ mr r28, r3 +/* 801DD3F4 001D9054 40 82 00 0C */ bne lbl_801DD400 +/* 801DD3F8 001D9058 38 60 00 00 */ li r3, 0 +/* 801DD3FC 001D905C 48 00 01 94 */ b lbl_801DD590 +lbl_801DD400: +/* 801DD400 001D9060 4B FF F3 61 */ bl func_801DC760 +/* 801DD404 001D9064 38 03 00 1F */ addi r0, r3, 0x1f +/* 801DD408 001D9068 54 18 00 35 */ rlwinm. r24, r0, 0, 0, 0x1a +/* 801DD40C 001D906C 40 82 00 0C */ bne lbl_801DD418 +/* 801DD410 001D9070 38 60 00 00 */ li r3, 0 +/* 801DD414 001D9074 48 00 01 7C */ b lbl_801DD590 +lbl_801DD418: +/* 801DD418 001D9078 80 6D 96 2C */ lwz r3, lbl_8063E8EC +/* 801DD41C 001D907C 3C 80 00 20 */ lis r4, 0x20 +/* 801DD420 001D9080 4B FF D8 75 */ bl func_801DAC94 +/* 801DD424 001D9084 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD428 001D9088 7C 7B 1B 78 */ mr r27, r3 +/* 801DD42C 001D908C 40 82 00 0C */ bne lbl_801DD438 +/* 801DD430 001D9090 38 60 00 00 */ li r3, 0 +/* 801DD434 001D9094 48 00 01 5C */ b lbl_801DD590 +lbl_801DD438: +/* 801DD438 001D9098 38 00 00 01 */ li r0, 1 +/* 801DD43C 001D909C 38 7D 00 02 */ addi r3, r29, 2 +/* 801DD440 001D90A0 98 1D 00 00 */ stb r0, 0(r29) +/* 801DD444 001D90A4 38 8D 84 38 */ addi r4, r13, 0x8438 +/* 801DD448 001D90A8 98 1D 00 01 */ stb r0, 1(r29) +/* 801DD44C 001D90AC 4B FF 0E 85 */ bl strcpy +/* 801DD450 001D90B0 7F 24 CB 78 */ mr r4, r25 +/* 801DD454 001D90B4 38 7D 00 02 */ addi r3, r29, 2 +/* 801DD458 001D90B8 38 A0 00 0C */ li r5, 0xc +/* 801DD45C 001D90BC 4B FF 0F A5 */ bl strncat +/* 801DD460 001D90C0 38 7D 00 02 */ addi r3, r29, 2 +/* 801DD464 001D90C4 3B 40 00 00 */ li r26, 0 +/* 801DD468 001D90C8 38 80 00 30 */ li r4, 0x30 +/* 801DD46C 001D90CC 38 A0 00 00 */ li r5, 0 +/* 801DD470 001D90D0 48 10 A1 09 */ bl NANDCreate +/* 801DD474 001D90D4 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD478 001D90D8 41 82 00 0C */ beq lbl_801DD484 +/* 801DD47C 001D90DC 2C 03 FF FA */ cmpwi r3, -6 +/* 801DD480 001D90E0 40 82 00 D0 */ bne lbl_801DD550 +lbl_801DD484: +/* 801DD484 001D90E4 38 7D 00 02 */ addi r3, r29, 2 +/* 801DD488 001D90E8 38 81 00 08 */ addi r4, r1, 8 +/* 801DD48C 001D90EC 38 A0 00 03 */ li r5, 3 +/* 801DD490 001D90F0 48 10 AF 79 */ bl NANDOpen +/* 801DD494 001D90F4 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD498 001D90F8 40 82 00 B8 */ bne lbl_801DD550 +/* 801DD49C 001D90FC 3B 20 00 00 */ li r25, 0 +/* 801DD4A0 001D9100 3F E0 00 20 */ lis r31, 0x20 +lbl_801DD4A4: +/* 801DD4A4 001D9104 7C 18 F8 40 */ cmplw r24, r31 +/* 801DD4A8 001D9108 3F C0 00 20 */ lis r30, 0x20 +/* 801DD4AC 001D910C 40 80 00 08 */ bge lbl_801DD4B4 +/* 801DD4B0 001D9110 7F 1E C3 78 */ mr r30, r24 +lbl_801DD4B4: +/* 801DD4B4 001D9114 7F 83 E3 78 */ mr r3, r28 +/* 801DD4B8 001D9118 7F 64 DB 78 */ mr r4, r27 +/* 801DD4BC 001D911C 7F C5 F3 78 */ mr r5, r30 +/* 801DD4C0 001D9120 7F 26 CB 78 */ mr r6, r25 +/* 801DD4C4 001D9124 38 E0 00 02 */ li r7, 2 +/* 801DD4C8 001D9128 4B FF F1 35 */ bl func_801DC5FC +/* 801DD4CC 001D912C 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD4D0 001D9130 40 80 00 34 */ bge lbl_801DD504 +/* 801DD4D4 001D9134 2C 03 FF FF */ cmpwi r3, -1 +/* 801DD4D8 001D9138 40 82 00 10 */ bne lbl_801DD4E8 +lbl_801DD4DC: +/* 801DD4DC 001D913C 80 6D A3 40 */ lwz r3, lbl_8063F600 +/* 801DD4E0 001D9140 48 04 70 A9 */ bl func_80224588 +/* 801DD4E4 001D9144 4B FF FF F8 */ b lbl_801DD4DC +lbl_801DD4E8: +/* 801DD4E8 001D9148 80 6D 96 2C */ lwz r3, lbl_8063E8EC +/* 801DD4EC 001D914C 7F 64 DB 78 */ mr r4, r27 +/* 801DD4F0 001D9150 4B FF D8 59 */ bl func_801DAD48 +/* 801DD4F4 001D9154 7F 83 E3 78 */ mr r3, r28 +/* 801DD4F8 001D9158 4B FF F1 CD */ bl func_801DC6C4 +/* 801DD4FC 001D915C 38 60 00 00 */ li r3, 0 +/* 801DD500 001D9160 48 00 00 90 */ b lbl_801DD590 +lbl_801DD504: +/* 801DD504 001D9164 7F 64 DB 78 */ mr r4, r27 +/* 801DD508 001D9168 7F C5 F3 78 */ mr r5, r30 +/* 801DD50C 001D916C 38 61 00 08 */ addi r3, r1, 8 +/* 801DD510 001D9170 48 10 A4 91 */ bl NANDWrite +/* 801DD514 001D9174 7C 03 F0 00 */ cmpw r3, r30 +/* 801DD518 001D9178 41 82 00 10 */ beq lbl_801DD528 +/* 801DD51C 001D917C 38 61 00 08 */ addi r3, r1, 8 +/* 801DD520 001D9180 48 10 B1 69 */ bl NANDClose +/* 801DD524 001D9184 48 00 00 10 */ b lbl_801DD534 +lbl_801DD528: +/* 801DD528 001D9188 7F 1E C0 51 */ subf. r24, r30, r24 +/* 801DD52C 001D918C 7F 39 F2 14 */ add r25, r25, r30 +/* 801DD530 001D9190 40 82 FF 74 */ bne lbl_801DD4A4 +lbl_801DD534: +/* 801DD534 001D9194 38 61 00 08 */ addi r3, r1, 8 +/* 801DD538 001D9198 48 10 B1 51 */ bl NANDClose +/* 801DD53C 001D919C 2C 03 00 00 */ cmpwi r3, 0 +/* 801DD540 001D91A0 40 82 00 10 */ bne lbl_801DD550 +/* 801DD544 001D91A4 38 00 00 00 */ li r0, 0 +/* 801DD548 001D91A8 3B 40 00 01 */ li r26, 1 +/* 801DD54C 001D91AC 98 1D 00 01 */ stb r0, 1(r29) +lbl_801DD550: +/* 801DD550 001D91B0 2C 1B 00 00 */ cmpwi r27, 0 +/* 801DD554 001D91B4 41 82 00 10 */ beq lbl_801DD564 +/* 801DD558 001D91B8 80 6D 96 2C */ lwz r3, lbl_8063E8EC +/* 801DD55C 001D91BC 7F 64 DB 78 */ mr r4, r27 +/* 801DD560 001D91C0 4B FF D7 E9 */ bl func_801DAD48 +lbl_801DD564: +/* 801DD564 001D91C4 7F 83 E3 78 */ mr r3, r28 +/* 801DD568 001D91C8 4B FF F1 5D */ bl func_801DC6C4 +/* 801DD56C 001D91CC 2C 1A 00 00 */ cmpwi r26, 0 +/* 801DD570 001D91D0 41 82 00 14 */ beq lbl_801DD584 +/* 801DD574 001D91D4 38 00 00 00 */ li r0, 0 +/* 801DD578 001D91D8 38 60 00 01 */ li r3, 1 +/* 801DD57C 001D91DC 98 1D 00 01 */ stb r0, 1(r29) +/* 801DD580 001D91E0 48 00 00 10 */ b lbl_801DD590 +lbl_801DD584: +/* 801DD584 001D91E4 38 00 00 00 */ li r0, 0 +/* 801DD588 001D91E8 38 60 00 01 */ li r3, 1 +/* 801DD58C 001D91EC 98 1D 00 00 */ stb r0, 0(r29) +lbl_801DD590: +/* 801DD590 001D91F0 39 61 00 C0 */ addi r11, r1, 0xc0 +/* 801DD594 001D91F4 4B FE 9B D5 */ bl _restgpr_24 +/* 801DD598 001D91F8 80 01 00 C4 */ lwz r0, 0xc4(r1) +/* 801DD59C 001D91FC 7C 08 03 A6 */ mtlr r0 +/* 801DD5A0 001D9200 38 21 00 C0 */ addi r1, r1, 0xc0 +/* 801DD5A4 001D9204 4E 80 00 20 */ blr +} +#pragma peephole on +#endif } //extern "C" -- cgit v1.2.3 From b65c4ed97a77f5f8e690051cf36abb61427cfcc7 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 11:31:27 -0400 Subject: match loop body in func_801DD294 --- src/code_801DCE6C.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 1e42ff9..7e27b5f 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -149,13 +149,13 @@ BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) // check if already open if (func_801DCEB4(p1, fileName)) return TRUE; - // TODO: unroll this loop - gUnkClass6* r29 = p1->arr - 1; + + gUnkClass6* r29; size_t i; for (i = 0; i < 8; i++) { - r29++; + r29 = p1->arr + i; if (!p1->arr[i].unk0) { - r29 = &p1->arr[i]; + r29 = p1->arr + i; break; } } -- cgit v1.2.3 From 4f344c838552548347e714f5ed1cc495b44543f2 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 15:51:40 -0400 Subject: only regswaps remain in func_801DD294 --- src/code_801DCE6C.cpp | 74 ++++++++++++++++++++++++++++----------------------- 1 file changed, 40 insertions(+), 34 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 7e27b5f..8096355 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -142,16 +142,25 @@ BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) // creates and opens a /tmp/ file in NAND and copies the specified file to it #define NONMATCHING #ifdef NONMATCHING -BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) +BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) { - NANDFileInfo nandInfo; // sp+8 - - // check if already open + gUnkClass6 *r29; + size_t fileSz; + NANDFileInfo nandInfo; + gUnkClass5 *fp; + size_t i; + void *buffer; + BOOL flag; + s32 createResult; + size_t currOffset; + size_t maxLength; + size_t length; + s32 readResult; + s32 bytesWritten; + if (func_801DCEB4(p1, fileName)) return TRUE; - gUnkClass6* r29; - size_t i; for (i = 0; i < 8; i++) { r29 = p1->arr + i; if (!p1->arr[i].unk0) { @@ -162,65 +171,62 @@ BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) if (!r29) return FALSE; - // check if file exists + if (!func_801DC380(fileName)) return FALSE; - // open file on DVD - gUnkClass5* fp = func_801DC2D0(fileName); //r28 + + fp = func_801DC2D0(fileName); if (!fp) return FALSE; - // get file size - size_t fileSz = (func_801DC760(fp) + 0x1F) & ~0x1F; // r24 - if (fileSz == 0) + + + fileSz = (func_801DC760(fp) + 0x1F) & (~0x1F); + if (0 == fileSz) return FALSE; - // allocate some memory. TODO: type of result. - // used for buffered reads? - void* buffer = func_801DAC94(lbl_8063E8EC, 0x200000); // r27 + + buffer = func_801DAC94(lbl_8063E8EC, 0x200000); if (!buffer) return FALSE; - + r29->unk0 = 1; r29->unk1 = 1; strcpy(r29->unk2, "/tmp/"); strncat(r29->unk2, fileName, 12); - BOOL flag = FALSE; // r26 - s32 createResult = NANDCreate(r29->unk2, 0x30, 0); - if (createResult == 0 || createResult == -6) { + flag = 0; + createResult = NANDCreate(r29->unk2, 0x30, 0); + if ((createResult == 0) || (createResult == (-6))) { if (NANDOpen(r29->unk2, &nandInfo, 3) == 0) { - u32 currOffset = 0; // r25 - while (fileSz != 0) { - size_t length = 0x20000; // r30 - if (fileSz < 0x20000) { - length = fileSz; - } - // DVDReadPrio wrapper - s32 readResult = func_801DC5FC(fp, buffer, length, currOffset, 2); + currOffset = 0; + maxLength = 0x200000; + do { + length = (fileSz < maxLength) ? (fileSz) : (maxLength); + readResult = func_801DC5FC(fp, buffer, length, currOffset, 2); if (readResult < 0) { if (readResult == -1) { while (TRUE) func_80224588(lbl_8063F600); } - // free and close func_801DAD48(lbl_8063E8EC, buffer); func_801DC6C4(fp); - return FALSE; + return 0; } - if (NANDWrite(&nandInfo, buffer, length) != length) { + bytesWritten = NANDWrite(&nandInfo, buffer, length); + if (bytesWritten != ((s32) length)) { NANDClose(&nandInfo); break; } - fileSz -= length; currOffset += length; - } + } while ((fileSz -= length) != 0); if (NANDClose(&nandInfo) == 0) { - flag = TRUE; + flag = 1; r29->unk1 = 0; } } } + if (buffer) func_801DAD48(lbl_8063E8EC, buffer); - + func_801DC6C4(fp); if (flag) { r29->unk1 = 0; -- cgit v1.2.3 From 4ff4ced455e64e40df59298370b32f7e8edb5bdc Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 16:15:40 -0400 Subject: match func_801DD294 --- src/code_801DCE6C.cpp | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 8096355..c283181 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -144,15 +144,18 @@ BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) #ifdef NONMATCHING BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) { - gUnkClass6 *r29; - size_t fileSz; + // intended register -> actual register + // p1: r24 -> r25 + // fileName: r25 -> r24 + gUnkClass6 *r29; + //size_t fileSz; // r24 -> r28 NANDFileInfo nandInfo; - gUnkClass5 *fp; + gUnkClass5 *fp; // r28 -> r27 size_t i; - void *buffer; - BOOL flag; + void *buffer; // r27 -> r26 + BOOL flag; // r26 -> r25 s32 createResult; - size_t currOffset; + size_t currOffset; // r25 -> r24 size_t maxLength; size_t length; s32 readResult; @@ -180,7 +183,7 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) return FALSE; - fileSz = (func_801DC760(fp) + 0x1F) & (~0x1F); + size_t fileSz = (func_801DC760(fp) + 0x1F) & (~0x1F); if (0 == fileSz) return FALSE; -- cgit v1.2.3 From e5e4451cfcf8b03153fd11a620460f66b4840ba6 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 18:08:27 -0400 Subject: refactor as code_801DCE6C to C++ --- src/code_801DBE90.cpp | 16 +-- src/code_801DCE6C.cpp | 358 +++++++------------------------------------------- 2 files changed, 56 insertions(+), 318 deletions(-) (limited to 'src') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index e8a262e..7534f0d 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -57,7 +57,7 @@ static void func_801DBEA0(void) gUnk8063F324[i].unk0 = 0; } -static gUnkClass5 *func_801DBED0(void) +static gUnkClass5* func_801DBED0(void) { BOOL enable = OSDisableInterrupts(); gUnkClass5* r31 = NULL; @@ -183,7 +183,7 @@ gUnkClass5* func_801DC2D0(const char* fileName) gUnkClass5* fp = func_801DBED0(); if (!fp) return NULL; - if (gUnk8063F338 && func_801DCF74(gUnk8063F338, fileName, fp)) + if (gUnk8063F338 && gUnk8063F338->func_801DCF74(fileName, fp)) return fp; if (!DVDOpen(fileName, &fp->unk4)) { func_801DBF60(fp); @@ -196,7 +196,7 @@ BOOL func_801DC380(const char* fileName) { if (!gUnk8063F31E) return FALSE; - if (gUnk8063F338 && func_801DCF48(gUnk8063F338, fileName)) + if (gUnk8063F338 && gUnk8063F338->func_801DCF48(fileName)) return TRUE; if (DVDConvertPathToEntrynum(fileName) == -1) return FALSE; @@ -218,7 +218,7 @@ s32 func_801DC3FC(gUnkClass5* p1, void* addr, s32 length, s32 offset) return -1; if (gUnk8063F338 && p1->unk1) { - s32 r3 = func_801DD084(gUnk8063F338, p1, addr, length, offset); + s32 r3 = gUnk8063F338->func_801DD084(p1, addr, length, offset); if (r3 > 0) return r3; } @@ -242,7 +242,7 @@ BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s p1->unk48 = addr; p1->unk4C = len; - if (gUnk8063F338 && p1->unk1 && func_801DD220(gUnk8063F338, p1, addr, len, offset)) + if (gUnk8063F338 && p1->unk1 && gUnk8063F338->func_801DD220(p1, addr, len, offset)) return TRUE; return DVDReadAsyncPrio(&p1->unk4, addr, (s32)len, offset, &func_801DBFEC, 2) != 0; } @@ -273,7 +273,7 @@ BOOL func_801DC6C4(gUnkClass5* p1) func_801DC264(); if (!p1) return FALSE; - if (gUnk8063F338 && func_801DCFE4(gUnk8063F338, p1)) { + if (gUnk8063F338 && gUnk8063F338->func_801DCFE4(p1)) { func_801DBF60(p1); return TRUE; } @@ -290,7 +290,7 @@ size_t func_801DC760(gUnkClass5* p1) func_801DC264(); if (!p1) return 0; - if (gUnk8063F338 && func_801DD03C(gUnk8063F338, p1, &fileSz)) + if (gUnk8063F338 && gUnk8063F338->func_801DD03C(p1, &fileSz)) return fileSz; return DVDGetLength(&p1->unk4); } @@ -497,7 +497,7 @@ u8* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) BOOL func_801DCD94(const char* fileName) { if (gUnk8063F338) - return func_801DD294(gUnk8063F338, fileName, 0); + return gUnk8063F338->func_801DD294(fileName, 0); return 0; } diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index c283181..475855f 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -7,30 +7,20 @@ #include "code_801DBE90.h" #include "code_801DCE6C.h" -// gUnkClass4 implementation -// NAND wrapper class - -//static -gUnkClass6* func_801DCEB4(gUnkClass4* p1, const char* p2); +// gUnkClass4 and gUnkClass6 implementation: used to interface with the RVL_SDK NAND library +static ctorStruct gUnk8063F340(1, 4, 0); extern "C" { -#if 1 - - -// TODO: replace unk2 and unk7 with a single char buffer? - -//static -char* func_801DCE6C(gUnkClass6* p1) +const char* gUnkClass6::func_801DCE6C(void) const { - return p1->unk7; + return unk2 + sizeof("/tmp/")-1; } -//static -char* func_801DCE74(gUnkClass6* p1) +const char* gUnkClass6::func_801DCE74(void) const { - return p1->unk2; + return unk2; } gUnkClass4::gUnkClass4(void) @@ -38,35 +28,32 @@ gUnkClass4::gUnkClass4(void) memset(this, 0, sizeof(gUnkClass4)); } -// TODO: convert to class member functions - -// search the array -//static -gUnkClass6* func_801DCEB4(gUnkClass4* p1, const char* p2) +// search the array for the given filename +gUnkClass6* gUnkClass4::func_801DCEB4(const char* fileName) { - char sp8[13]; // 0xD ~ 0x10 byte struct - memcpy(&sp8, p2, 12); - sp8[12] = '\0'; + char shortName[13]; + memcpy(&shortName, fileName, 12); + shortName[12] = '\0'; - gUnkClass6* p = p1->arr; - for (s32 i = 0; i < 8; p++, i++) - if (p->unk0 && !p->unk1 && !strcmp(func_801DCE6C(p), sp8)) + gUnkClass6* p = arr_; + for (s32 i = 0; i < ArrLength_; p++, i++) + if (p->unk0 && !p->unk1 && !strcmp(p->func_801DCE6C(), shortName)) return p; return NULL; } // just indicate if search succeeded -BOOL func_801DCF48(gUnkClass4* p1, const char* p2) +BOOL gUnkClass4::func_801DCF48(const char* fileName) { - return func_801DCEB4(p1, p2) != NULL; + return func_801DCEB4(fileName) != NULL; } -// NANDOpen wrapper -BOOL func_801DCF74(gUnkClass4* p1, const char* fileName, gUnkClass5* fp) +// NANDOpen wrapper. Open fileName in NAND if it is listed in arr_ +BOOL gUnkClass4::func_801DCF74(const char* fileName, gUnkClass5* fp) { - gUnkClass6* r31 = func_801DCEB4(p1, fileName); - if (r31 && NANDOpen(func_801DCE74(r31), &r31->unk48, 1) == 0) { + gUnkClass6* r31 = func_801DCEB4(fileName); + if (r31 && NANDOpen(r31->func_801DCE74(), &r31->unk48, 1) == 0) { fp->unk40 = r31; fp->unk1 = 1; return TRUE; @@ -75,7 +62,7 @@ BOOL func_801DCF74(gUnkClass4* p1, const char* fileName, gUnkClass5* fp) } // NANDClose wrapper -BOOL func_801DCFE4(gUnkClass4*, gUnkClass5* fp) +BOOL gUnkClass4::func_801DCFE4(gUnkClass5* fp) const { if (!fp->unk1) return FALSE; @@ -86,13 +73,13 @@ BOOL func_801DCFE4(gUnkClass4*, gUnkClass5* fp) } // NANDGetLength wrapper, indicate success -BOOL func_801DD03C(gUnkClass4*, gUnkClass5* fp, u32* fileSz) +BOOL gUnkClass4::func_801DD03C(gUnkClass5* fp, u32* fileSz) const { return (!fp->unk1) ? FALSE : NANDGetLength(&fp->unk40->unk48, fileSz) == 0; } // NANDSeek to offset, then NANDRead -s32 func_801DD084(gUnkClass4*, gUnkClass5* fp, void* addr, s32 length, s32 offset) +s32 gUnkClass4::func_801DD084(gUnkClass5* fp, void* addr, s32 length, s32 offset) const { if (!fp->unk1) return -1; @@ -102,8 +89,7 @@ s32 func_801DD084(gUnkClass4*, gUnkClass5* fp, void* addr, s32 length, s32 offse } // NANDReadAsync callback -//static -void func_801DD110(s32 p1, NANDCommandBlock* block) +static void func_801DD110(s32 p1, NANDCommandBlock* block) { gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block); if (!func_801DCE44() && data->unk44) { @@ -112,10 +98,9 @@ void func_801DD110(s32 p1, NANDCommandBlock* block) } // NANDSeekAsync callback -//static -void func_801DD174(s32 p1, NANDCommandBlock* block) +static void func_801DD174(s32 p1, NANDCommandBlock* block) { - gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block); // r31 + gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block); gUnkClass6* r30 = data->unk40; if (!func_801DCE44()) { if (p1 < 0) { @@ -127,7 +112,7 @@ void func_801DD174(s32 p1, NANDCommandBlock* block) } // NANDReadAsync wrapper that first calls NANDSeekAsync -BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) +BOOL gUnkClass4::func_801DD220(gUnkClass5* fp, void*, u32, s32 offset) const { if (!fp->unk1) return FALSE; @@ -136,38 +121,25 @@ BOOL func_801DD220(gUnkClass4*, gUnkClass5* fp, void*, u32, s32 offset) return NANDSeekAsync(&r31->unk48, offset, 0, &func_801DD174, &r31->block) == 0; } - -#endif - -// creates and opens a /tmp/ file in NAND and copies the specified file to it -#define NONMATCHING -#ifdef NONMATCHING -BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) +// copy from the DVD to /tmp/ in NAND +BOOL gUnkClass4::func_801DD294(const char *fileName, s32) { - // intended register -> actual register - // p1: r24 -> r25 - // fileName: r25 -> r24 gUnkClass6 *r29; - //size_t fileSz; // r24 -> r28 NANDFileInfo nandInfo; - gUnkClass5 *fp; // r28 -> r27 + gUnkClass5 *fp; size_t i; - void *buffer; // r27 -> r26 - BOOL flag; // r26 -> r25 - s32 createResult; - size_t currOffset; // r25 -> r24 + void *buffer; + BOOL flag; + s32 currOffset; size_t maxLength; - size_t length; - s32 readResult; - s32 bytesWritten; - if (func_801DCEB4(p1, fileName)) + if (func_801DCEB4(fileName)) return TRUE; - for (i = 0; i < 8; i++) { - r29 = p1->arr + i; - if (!p1->arr[i].unk0) { - r29 = p1->arr + i; + for (i = 0; i < ArrLength_; i++) { + r29 = arr_ + i; + if (!arr_[i].unk0) { + r29 = arr_ + i; break; } } @@ -175,14 +147,13 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) if (!r29) return FALSE; + // Ensure that fileName exists on the DVD, then open it if (!func_801DC380(fileName)) - return FALSE; - + return FALSE; fp = func_801DC2D0(fileName); if (!fp) return FALSE; - size_t fileSz = (func_801DC760(fp) + 0x1F) & (~0x1F); if (0 == fileSz) return FALSE; @@ -195,15 +166,16 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) r29->unk1 = 1; strcpy(r29->unk2, "/tmp/"); strncat(r29->unk2, fileName, 12); - flag = 0; - createResult = NANDCreate(r29->unk2, 0x30, 0); - if ((createResult == 0) || (createResult == (-6))) { + flag = FALSE; + s32 createResult = NANDCreate(r29->unk2, 0x30, 0); + if (createResult == 0 || createResult == -6) { if (NANDOpen(r29->unk2, &nandInfo, 3) == 0) { currOffset = 0; maxLength = 0x200000; + size_t length; do { length = (fileSz < maxLength) ? (fileSz) : (maxLength); - readResult = func_801DC5FC(fp, buffer, length, currOffset, 2); + s32 readResult = func_801DC5FC(fp, buffer, (s32)length, currOffset, 2); if (readResult < 0) { if (readResult == -1) { while (TRUE) @@ -211,9 +183,9 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) } func_801DAD48(lbl_8063E8EC, buffer); func_801DC6C4(fp); - return 0; + return FALSE; } - bytesWritten = NANDWrite(&nandInfo, buffer, length); + s32 bytesWritten = NANDWrite(&nandInfo, buffer, length); if (bytesWritten != ((s32) length)) { NANDClose(&nandInfo); break; @@ -221,7 +193,7 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) currOffset += length; } while ((fileSz -= length) != 0); if (NANDClose(&nandInfo) == 0) { - flag = 1; + flag = TRUE; r29->unk1 = 0; } } @@ -239,239 +211,5 @@ BOOL func_801DD294(gUnkClass4 *p1, const char *fileName, s32) return TRUE; } } -#else -void _restgpr_24(void); -void _savegpr_24(void); -extern char* lbl_8063D6F8; -asm BOOL func_801DD294(gUnkClass4* p1, const char* fileName, s32) -{ - nofralloc -/* 801DD294 001D8EF4 94 21 FF 40 */ stwu r1, -0xc0(r1) -/* 801DD298 001D8EF8 7C 08 02 A6 */ mflr r0 -/* 801DD29C 001D8EFC 90 01 00 C4 */ stw r0, 0xc4(r1) -/* 801DD2A0 001D8F00 39 61 00 C0 */ addi r11, r1, 0xc0 -/* 801DD2A4 001D8F04 4B FE 9E 79 */ bl _savegpr_24 -/* 801DD2A8 001D8F08 7C 78 1B 78 */ mr r24, r3 -/* 801DD2AC 001D8F0C 7C 99 23 78 */ mr r25, r4 -/* 801DD2B0 001D8F10 4B FF FC 05 */ bl func_801DCEB4 -/* 801DD2B4 001D8F14 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD2B8 001D8F18 41 82 00 0C */ beq lbl_801DD2C4 -/* 801DD2BC 001D8F1C 38 60 00 01 */ li r3, 1 -/* 801DD2C0 001D8F20 48 00 02 D0 */ b lbl_801DD590 -lbl_801DD2C4: -/* 801DD2C4 001D8F24 88 18 00 00 */ lbz r0, 0(r24) -/* 801DD2C8 001D8F28 38 80 00 00 */ li r4, 0 -/* 801DD2CC 001D8F2C 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD2D0 001D8F30 40 82 00 10 */ bne lbl_801DD2E0 -/* 801DD2D4 001D8F34 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD2D8 001D8F38 7F B8 02 14 */ add r29, r24, r0 -/* 801DD2DC 001D8F3C 48 00 00 E0 */ b lbl_801DD3BC -lbl_801DD2E0: -/* 801DD2E0 001D8F40 88 18 01 90 */ lbz r0, 0x190(r24) -/* 801DD2E4 001D8F44 38 78 01 90 */ addi r3, r24, 0x190 -/* 801DD2E8 001D8F48 38 80 00 01 */ li r4, 1 -/* 801DD2EC 001D8F4C 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD2F0 001D8F50 40 82 00 10 */ bne lbl_801DD300 -/* 801DD2F4 001D8F54 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD2F8 001D8F58 7F B8 02 14 */ add r29, r24, r0 -/* 801DD2FC 001D8F5C 48 00 00 C0 */ b lbl_801DD3BC -lbl_801DD300: -/* 801DD300 001D8F60 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD304 001D8F64 38 80 00 02 */ li r4, 2 -/* 801DD308 001D8F68 38 63 01 90 */ addi r3, r3, 0x190 -/* 801DD30C 001D8F6C 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD310 001D8F70 40 82 00 10 */ bne lbl_801DD320 -/* 801DD314 001D8F74 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD318 001D8F78 7F B8 02 14 */ add r29, r24, r0 -/* 801DD31C 001D8F7C 48 00 00 A0 */ b lbl_801DD3BC -lbl_801DD320: -/* 801DD320 001D8F80 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD324 001D8F84 38 80 00 03 */ li r4, 3 -/* 801DD328 001D8F88 38 63 01 90 */ addi r3, r3, 0x190 -/* 801DD32C 001D8F8C 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD330 001D8F90 40 82 00 10 */ bne lbl_801DD340 -/* 801DD334 001D8F94 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD338 001D8F98 7F B8 02 14 */ add r29, r24, r0 -/* 801DD33C 001D8F9C 48 00 00 80 */ b lbl_801DD3BC -lbl_801DD340: -/* 801DD340 001D8FA0 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD344 001D8FA4 38 80 00 04 */ li r4, 4 -/* 801DD348 001D8FA8 38 63 01 90 */ addi r3, r3, 0x190 -/* 801DD34C 001D8FAC 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD350 001D8FB0 40 82 00 10 */ bne lbl_801DD360 -/* 801DD354 001D8FB4 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD358 001D8FB8 7F B8 02 14 */ add r29, r24, r0 -/* 801DD35C 001D8FBC 48 00 00 60 */ b lbl_801DD3BC -lbl_801DD360: -/* 801DD360 001D8FC0 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD364 001D8FC4 38 80 00 05 */ li r4, 5 -/* 801DD368 001D8FC8 38 63 01 90 */ addi r3, r3, 0x190 -/* 801DD36C 001D8FCC 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD370 001D8FD0 40 82 00 10 */ bne lbl_801DD380 -/* 801DD374 001D8FD4 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD378 001D8FD8 7F B8 02 14 */ add r29, r24, r0 -/* 801DD37C 001D8FDC 48 00 00 40 */ b lbl_801DD3BC -lbl_801DD380: -/* 801DD380 001D8FE0 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD384 001D8FE4 38 80 00 06 */ li r4, 6 -/* 801DD388 001D8FE8 38 63 01 90 */ addi r3, r3, 0x190 -/* 801DD38C 001D8FEC 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD390 001D8FF0 40 82 00 10 */ bne lbl_801DD3A0 -/* 801DD394 001D8FF4 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD398 001D8FF8 7F B8 02 14 */ add r29, r24, r0 -/* 801DD39C 001D8FFC 48 00 00 20 */ b lbl_801DD3BC -lbl_801DD3A0: -/* 801DD3A0 001D9000 88 03 01 90 */ lbz r0, 0x190(r3) -/* 801DD3A4 001D9004 38 80 00 07 */ li r4, 7 -/* 801DD3A8 001D9008 3B A3 01 90 */ addi r29, r3, 0x190 -/* 801DD3AC 001D900C 2C 00 00 00 */ cmpwi r0, 0 -/* 801DD3B0 001D9010 40 82 00 0C */ bne lbl_801DD3BC -/* 801DD3B4 001D9014 1C 04 01 90 */ mulli r0, r4, 0x190 -/* 801DD3B8 001D9018 7F B8 02 14 */ add r29, r24, r0 -lbl_801DD3BC: -/* 801DD3BC 001D901C 2C 1D 00 00 */ cmpwi r29, 0 -/* 801DD3C0 001D9020 40 82 00 0C */ bne lbl_801DD3CC -/* 801DD3C4 001D9024 38 60 00 00 */ li r3, 0 -/* 801DD3C8 001D9028 48 00 01 C8 */ b lbl_801DD590 -lbl_801DD3CC: -/* 801DD3CC 001D902C 7F 23 CB 78 */ mr r3, r25 -/* 801DD3D0 001D9030 4B FF EF B1 */ bl func_801DC380 -/* 801DD3D4 001D9034 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD3D8 001D9038 40 82 00 0C */ bne lbl_801DD3E4 -/* 801DD3DC 001D903C 38 60 00 00 */ li r3, 0 -/* 801DD3E0 001D9040 48 00 01 B0 */ b lbl_801DD590 -lbl_801DD3E4: -/* 801DD3E4 001D9044 7F 23 CB 78 */ mr r3, r25 -/* 801DD3E8 001D9048 4B FF EE E9 */ bl func_801DC2D0 -/* 801DD3EC 001D904C 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD3F0 001D9050 7C 7C 1B 78 */ mr r28, r3 -/* 801DD3F4 001D9054 40 82 00 0C */ bne lbl_801DD400 -/* 801DD3F8 001D9058 38 60 00 00 */ li r3, 0 -/* 801DD3FC 001D905C 48 00 01 94 */ b lbl_801DD590 -lbl_801DD400: -/* 801DD400 001D9060 4B FF F3 61 */ bl func_801DC760 -/* 801DD404 001D9064 38 03 00 1F */ addi r0, r3, 0x1f -/* 801DD408 001D9068 54 18 00 35 */ rlwinm. r24, r0, 0, 0, 0x1a -/* 801DD40C 001D906C 40 82 00 0C */ bne lbl_801DD418 -/* 801DD410 001D9070 38 60 00 00 */ li r3, 0 -/* 801DD414 001D9074 48 00 01 7C */ b lbl_801DD590 -lbl_801DD418: -/* 801DD418 001D9078 80 6D 96 2C */ lwz r3, lbl_8063E8EC -/* 801DD41C 001D907C 3C 80 00 20 */ lis r4, 0x20 -/* 801DD420 001D9080 4B FF D8 75 */ bl func_801DAC94 -/* 801DD424 001D9084 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD428 001D9088 7C 7B 1B 78 */ mr r27, r3 -/* 801DD42C 001D908C 40 82 00 0C */ bne lbl_801DD438 -/* 801DD430 001D9090 38 60 00 00 */ li r3, 0 -/* 801DD434 001D9094 48 00 01 5C */ b lbl_801DD590 -lbl_801DD438: -/* 801DD438 001D9098 38 00 00 01 */ li r0, 1 -/* 801DD43C 001D909C 38 7D 00 02 */ addi r3, r29, 2 -/* 801DD440 001D90A0 98 1D 00 00 */ stb r0, 0(r29) -/* 801DD444 001D90A4 38 8D 84 38 */ addi r4, r13, 0x8438 -/* 801DD448 001D90A8 98 1D 00 01 */ stb r0, 1(r29) -/* 801DD44C 001D90AC 4B FF 0E 85 */ bl strcpy -/* 801DD450 001D90B0 7F 24 CB 78 */ mr r4, r25 -/* 801DD454 001D90B4 38 7D 00 02 */ addi r3, r29, 2 -/* 801DD458 001D90B8 38 A0 00 0C */ li r5, 0xc -/* 801DD45C 001D90BC 4B FF 0F A5 */ bl strncat -/* 801DD460 001D90C0 38 7D 00 02 */ addi r3, r29, 2 -/* 801DD464 001D90C4 3B 40 00 00 */ li r26, 0 -/* 801DD468 001D90C8 38 80 00 30 */ li r4, 0x30 -/* 801DD46C 001D90CC 38 A0 00 00 */ li r5, 0 -/* 801DD470 001D90D0 48 10 A1 09 */ bl NANDCreate -/* 801DD474 001D90D4 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD478 001D90D8 41 82 00 0C */ beq lbl_801DD484 -/* 801DD47C 001D90DC 2C 03 FF FA */ cmpwi r3, -6 -/* 801DD480 001D90E0 40 82 00 D0 */ bne lbl_801DD550 -lbl_801DD484: -/* 801DD484 001D90E4 38 7D 00 02 */ addi r3, r29, 2 -/* 801DD488 001D90E8 38 81 00 08 */ addi r4, r1, 8 -/* 801DD48C 001D90EC 38 A0 00 03 */ li r5, 3 -/* 801DD490 001D90F0 48 10 AF 79 */ bl NANDOpen -/* 801DD494 001D90F4 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD498 001D90F8 40 82 00 B8 */ bne lbl_801DD550 -/* 801DD49C 001D90FC 3B 20 00 00 */ li r25, 0 -/* 801DD4A0 001D9100 3F E0 00 20 */ lis r31, 0x20 -lbl_801DD4A4: -/* 801DD4A4 001D9104 7C 18 F8 40 */ cmplw r24, r31 -/* 801DD4A8 001D9108 3F C0 00 20 */ lis r30, 0x20 -/* 801DD4AC 001D910C 40 80 00 08 */ bge lbl_801DD4B4 -/* 801DD4B0 001D9110 7F 1E C3 78 */ mr r30, r24 -lbl_801DD4B4: -/* 801DD4B4 001D9114 7F 83 E3 78 */ mr r3, r28 -/* 801DD4B8 001D9118 7F 64 DB 78 */ mr r4, r27 -/* 801DD4BC 001D911C 7F C5 F3 78 */ mr r5, r30 -/* 801DD4C0 001D9120 7F 26 CB 78 */ mr r6, r25 -/* 801DD4C4 001D9124 38 E0 00 02 */ li r7, 2 -/* 801DD4C8 001D9128 4B FF F1 35 */ bl func_801DC5FC -/* 801DD4CC 001D912C 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD4D0 001D9130 40 80 00 34 */ bge lbl_801DD504 -/* 801DD4D4 001D9134 2C 03 FF FF */ cmpwi r3, -1 -/* 801DD4D8 001D9138 40 82 00 10 */ bne lbl_801DD4E8 -lbl_801DD4DC: -/* 801DD4DC 001D913C 80 6D A3 40 */ lwz r3, lbl_8063F600 -/* 801DD4E0 001D9140 48 04 70 A9 */ bl func_80224588 -/* 801DD4E4 001D9144 4B FF FF F8 */ b lbl_801DD4DC -lbl_801DD4E8: -/* 801DD4E8 001D9148 80 6D 96 2C */ lwz r3, lbl_8063E8EC -/* 801DD4EC 001D914C 7F 64 DB 78 */ mr r4, r27 -/* 801DD4F0 001D9150 4B FF D8 59 */ bl func_801DAD48 -/* 801DD4F4 001D9154 7F 83 E3 78 */ mr r3, r28 -/* 801DD4F8 001D9158 4B FF F1 CD */ bl func_801DC6C4 -/* 801DD4FC 001D915C 38 60 00 00 */ li r3, 0 -/* 801DD500 001D9160 48 00 00 90 */ b lbl_801DD590 -lbl_801DD504: -/* 801DD504 001D9164 7F 64 DB 78 */ mr r4, r27 -/* 801DD508 001D9168 7F C5 F3 78 */ mr r5, r30 -/* 801DD50C 001D916C 38 61 00 08 */ addi r3, r1, 8 -/* 801DD510 001D9170 48 10 A4 91 */ bl NANDWrite -/* 801DD514 001D9174 7C 03 F0 00 */ cmpw r3, r30 -/* 801DD518 001D9178 41 82 00 10 */ beq lbl_801DD528 -/* 801DD51C 001D917C 38 61 00 08 */ addi r3, r1, 8 -/* 801DD520 001D9180 48 10 B1 69 */ bl NANDClose -/* 801DD524 001D9184 48 00 00 10 */ b lbl_801DD534 -lbl_801DD528: -/* 801DD528 001D9188 7F 1E C0 51 */ subf. r24, r30, r24 -/* 801DD52C 001D918C 7F 39 F2 14 */ add r25, r25, r30 -/* 801DD530 001D9190 40 82 FF 74 */ bne lbl_801DD4A4 -lbl_801DD534: -/* 801DD534 001D9194 38 61 00 08 */ addi r3, r1, 8 -/* 801DD538 001D9198 48 10 B1 51 */ bl NANDClose -/* 801DD53C 001D919C 2C 03 00 00 */ cmpwi r3, 0 -/* 801DD540 001D91A0 40 82 00 10 */ bne lbl_801DD550 -/* 801DD544 001D91A4 38 00 00 00 */ li r0, 0 -/* 801DD548 001D91A8 3B 40 00 01 */ li r26, 1 -/* 801DD54C 001D91AC 98 1D 00 01 */ stb r0, 1(r29) -lbl_801DD550: -/* 801DD550 001D91B0 2C 1B 00 00 */ cmpwi r27, 0 -/* 801DD554 001D91B4 41 82 00 10 */ beq lbl_801DD564 -/* 801DD558 001D91B8 80 6D 96 2C */ lwz r3, lbl_8063E8EC -/* 801DD55C 001D91BC 7F 64 DB 78 */ mr r4, r27 -/* 801DD560 001D91C0 4B FF D7 E9 */ bl func_801DAD48 -lbl_801DD564: -/* 801DD564 001D91C4 7F 83 E3 78 */ mr r3, r28 -/* 801DD568 001D91C8 4B FF F1 5D */ bl func_801DC6C4 -/* 801DD56C 001D91CC 2C 1A 00 00 */ cmpwi r26, 0 -/* 801DD570 001D91D0 41 82 00 14 */ beq lbl_801DD584 -/* 801DD574 001D91D4 38 00 00 00 */ li r0, 0 -/* 801DD578 001D91D8 38 60 00 01 */ li r3, 1 -/* 801DD57C 001D91DC 98 1D 00 01 */ stb r0, 1(r29) -/* 801DD580 001D91E0 48 00 00 10 */ b lbl_801DD590 -lbl_801DD584: -/* 801DD584 001D91E4 38 00 00 00 */ li r0, 0 -/* 801DD588 001D91E8 38 60 00 01 */ li r3, 1 -/* 801DD58C 001D91EC 98 1D 00 00 */ stb r0, 0(r29) -lbl_801DD590: -/* 801DD590 001D91F0 39 61 00 C0 */ addi r11, r1, 0xc0 -/* 801DD594 001D91F4 4B FE 9B D5 */ bl _restgpr_24 -/* 801DD598 001D91F8 80 01 00 C4 */ lwz r0, 0xc4(r1) -/* 801DD59C 001D91FC 7C 08 03 A6 */ mtlr r0 -/* 801DD5A0 001D9200 38 21 00 C0 */ addi r1, r1, 0xc0 -/* 801DD5A4 001D9204 4E 80 00 20 */ blr -} -#pragma peephole on -#endif - } //extern "C" -- cgit v1.2.3 From 19716fa67dc6c35ba300304733f2269dbed59bd2 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 18:10:41 -0400 Subject: add include to ptmf.c --- src/Runtime/ptmf.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src') diff --git a/src/Runtime/ptmf.c b/src/Runtime/ptmf.c index c98cd63..6c8b6a8 100644 --- a/src/Runtime/ptmf.c +++ b/src/Runtime/ptmf.c @@ -1,4 +1,5 @@ #pragma internal on +#include asm void __ptmf_scall(...) { -- cgit v1.2.3 From 9ba8186ce645c468f66eed98034db0127f3e3199 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 31 Oct 2020 18:16:42 -0400 Subject: remove unneeded extern C --- src/code_801DCE6C.cpp | 4 ---- 1 file changed, 4 deletions(-) (limited to 'src') diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp index 475855f..e529721 100644 --- a/src/code_801DCE6C.cpp +++ b/src/code_801DCE6C.cpp @@ -11,8 +11,6 @@ static ctorStruct gUnk8063F340(1, 4, 0); -extern "C" { - const char* gUnkClass6::func_801DCE6C(void) const { return unk2 + sizeof("/tmp/")-1; @@ -211,5 +209,3 @@ BOOL gUnkClass4::func_801DD294(const char *fileName, s32) return TRUE; } } - -} //extern "C" -- cgit v1.2.3