mirror of
https://github.com/zeldaret/oot.git
synced 2025-07-15 12:24:39 +00:00
Matched most remaining libultra files (#221)
* osPfsIsPlug.c and osContSetCh.c OK * update * __osPfsGetStatus.c OK * removed unused asm * Updated all libultra controller files to use new structs instead of the temporary structs. Added os_pfs.h * controller updates * fixed header guard * Made suggested changes * guLookAt.c OK * commit * __osPfsSelectBank.c OK * osPfsDeleteFile.c OK * pfsreadwritefile.c OK * osPfsFreeBlocks.c OK * cleaned up ospfsfreeblocks * started pfsinitpak.c * pfsallocatefile.c OK * contpfs.c decompiled with 1 non matching * osPfsFindFile.c OK * pfsinitpak.c decompiled. one non-matching * Actually fixed merge conflict * sins.c OK * cosf.c sinf.c and sins.c OK * moved osAfterPreNMI to its own file. Renamed code_801031F0 to contquery.c * pfschecker.c OK * final update and rename * Removed makefile testing thing that i accidentally added * Made suggested changes
This commit is contained in:
Lucas Shaw
GitHub
parent
e6ca2dfd70
commit
7e195a3562
59 changed files with 1769 additions and 3641 deletions
|
|
@ -5,7 +5,7 @@
|
|||
// Valid addr up to 0x7FF
|
||||
// It's the address of a block of 0x20 bytes in the mempak
|
||||
// So that means the whole mempak has a 16-bit address space
|
||||
u8 osMempakAddrCRC(u16 addr) {
|
||||
u8 __osContAddressCrc(u16 addr) {
|
||||
u32 addr32 = addr;
|
||||
u32 ret = 0;
|
||||
u32 bit;
|
||||
|
|
@ -34,7 +34,7 @@ u8 osMempakAddrCRC(u16 addr) {
|
|||
return ret & 0x1f;
|
||||
}
|
||||
|
||||
u8 osMempakDataCRC(u8* data) {
|
||||
u8 __osContDataCrc(u8* data) {
|
||||
s32 ret;
|
||||
u32 bit;
|
||||
u32 byte;
|
||||
|
|
@ -4,7 +4,9 @@
|
|||
|
||||
#define BLOCKSIZE 32
|
||||
|
||||
s32 osReadMempak(OSMesgQueue* ctrlrqueue, s32 channel, u16 addr, u8* data) {
|
||||
s32 __osPfsLastChannel = -1;
|
||||
|
||||
s32 __osContRamRead(OSMesgQueue* ctrlrqueue, s32 channel, u16 addr, u8* data) {
|
||||
s32 ret;
|
||||
s32 i;
|
||||
u8* bufptr;
|
||||
|
|
@ -31,15 +33,15 @@ s32 osReadMempak(OSMesgQueue* ctrlrqueue, s32 channel, u16 addr, u8* data) {
|
|||
} else {
|
||||
bufptr += channel;
|
||||
}
|
||||
((__OSContRamHeader*)bufptr)->hi = addr >> 3; // send byte 1
|
||||
((__OSContRamHeader*)bufptr)->lo = (s8)(osMempakAddrCRC(addr) | (addr << 5)); // send byte 2
|
||||
((__OSContRamHeader*)bufptr)->hi = addr >> 3; // send byte 1
|
||||
((__OSContRamHeader*)bufptr)->lo = (s8)(__osContAddressCrc(addr) | (addr << 5)); // send byte 2
|
||||
__osSiRawStartDma(OS_WRITE, &pifMempakBuf);
|
||||
osRecvMesg(ctrlrqueue, NULL, OS_MESG_BLOCK);
|
||||
__osSiRawStartDma(OS_READ, &pifMempakBuf);
|
||||
osRecvMesg(ctrlrqueue, NULL, OS_MESG_BLOCK);
|
||||
ret = (((__OSContRamHeader*)bufptr)->rxsize & 0xC0) >> 4;
|
||||
if (!ret) {
|
||||
if (((__OSContRamHeader*)bufptr)->datacrc != osMempakDataCRC(bufptr + 6)) {
|
||||
if (((__OSContRamHeader*)bufptr)->datacrc != __osContDataCrc(bufptr + 6)) {
|
||||
ret = __osPfsGetStatus(ctrlrqueue, channel);
|
||||
if (ret) {
|
||||
break;
|
||||
68
src/libultra_code/__osContRamWrite.c
Normal file
68
src/libultra_code/__osContRamWrite.c
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
#include <ultra64.h>
|
||||
#include <ultra64/controller.h>
|
||||
#include <global.h>
|
||||
|
||||
s32 __osContRamWrite(OSMesgQueue* mq, s32 channel, u16 address, u8* buffer, s32 force) {
|
||||
s32 ret = 0;
|
||||
s32 i;
|
||||
u8* ptr;
|
||||
s32 retry = 2;
|
||||
u8 crc;
|
||||
|
||||
if ((force != PFS_FORCE) && (address < PFS_LABEL_AREA) && (address != 0)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
__osSiGetAccess();
|
||||
|
||||
do {
|
||||
ptr = (u8*)(&pifMempakBuf);
|
||||
|
||||
if (__osContLastPoll != CONT_CMD_WRITE_MEMPACK || __osPfsLastChannel != channel) {
|
||||
__osContLastPoll = CONT_CMD_WRITE_MEMPACK;
|
||||
__osPfsLastChannel = channel;
|
||||
|
||||
// clang-format off
|
||||
for (i = 0; i < channel; i++) { *ptr++ = 0; }
|
||||
// clang-format on
|
||||
|
||||
pifMempakBuf.status = 1;
|
||||
|
||||
((__OSContRamHeader*)ptr)->unk_00 = 0xff;
|
||||
((__OSContRamHeader*)ptr)->txsize = 35;
|
||||
((__OSContRamHeader*)ptr)->rxsize = 1;
|
||||
((__OSContRamHeader*)ptr)->poll = CONT_CMD_WRITE_MEMPACK;
|
||||
((__OSContRamHeader*)ptr)->datacrc = 0xff;
|
||||
|
||||
ptr[sizeof(__OSContRamHeader)] = CONT_CMD_END;
|
||||
} else {
|
||||
ptr += channel;
|
||||
}
|
||||
((__OSContRamHeader*)ptr)->hi = address >> 3;
|
||||
((__OSContRamHeader*)ptr)->lo = ((address << 5) | __osContAddressCrc(address));
|
||||
|
||||
bcopy(buffer, ((__OSContRamHeader*)ptr)->data, BLOCKSIZE);
|
||||
|
||||
ret = __osSiRawStartDma(OS_WRITE, &pifMempakBuf);
|
||||
crc = __osContDataCrc(buffer);
|
||||
osRecvMesg(mq, (OSMesg*)NULL, OS_MESG_BLOCK);
|
||||
|
||||
ret = __osSiRawStartDma(OS_READ, &pifMempakBuf);
|
||||
osRecvMesg(mq, (OSMesg*)NULL, OS_MESG_BLOCK);
|
||||
|
||||
ret = ((((__OSContRamHeader*)ptr)->rxsize & 0xC0) >> 4);
|
||||
if (!ret) {
|
||||
if (crc != ((__OSContRamHeader*)ptr)->datacrc) {
|
||||
if ((ret = __osPfsGetStatus(mq, channel))) {
|
||||
break;
|
||||
} else {
|
||||
ret = PFS_ERR_CONTRFAIL;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ret = PFS_ERR_NOPACK;
|
||||
}
|
||||
} while ((ret == PFS_ERR_CONTRFAIL) && (retry-- >= 0));
|
||||
__osSiRelAccess();
|
||||
return ret;
|
||||
}
|
||||
18
src/libultra_code/__osPfsSelectBank.c
Normal file
18
src/libultra_code/__osPfsSelectBank.c
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
#include <ultra64/pfs.h>
|
||||
#include <global.h>
|
||||
|
||||
s32 __osPfsSelectBank(OSPfs* pfs, u8 bank) {
|
||||
u8 temp[BLOCKSIZE];
|
||||
s32 i;
|
||||
s32 ret = 0;
|
||||
|
||||
for (i = 0; i < BLOCKSIZE; i++) {
|
||||
temp[i] = bank;
|
||||
}
|
||||
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, 0x8000 / BLOCKSIZE, temp, 0);
|
||||
if (ret == 0) {
|
||||
pfs->activebank = bank;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
314
src/libultra_code/contpfs.c
Normal file
314
src/libultra_code/contpfs.c
Normal file
|
|
@ -0,0 +1,314 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
extern __OSInode __osPfsInodeCache; // bss
|
||||
s32 __osPfsInodeCacheChannel = -1;
|
||||
u8 __osPfsInodeCacheBank = 250;
|
||||
|
||||
u16 __osSumcalc(u8* ptr, s32 length) {
|
||||
s32 i;
|
||||
u32 sum = 0;
|
||||
u8* temp;
|
||||
|
||||
temp = ptr;
|
||||
for (i = 0; i < length; i++) {
|
||||
sum += *temp++;
|
||||
}
|
||||
return sum & 0xFFFF;
|
||||
}
|
||||
|
||||
s32 __osIdCheckSum(u16* ptr, u16* checkSum, u16* idSum) {
|
||||
|
||||
u16 data = 0;
|
||||
u32 i;
|
||||
|
||||
*checkSum = *idSum = 0;
|
||||
for (i = 0; i < ((sizeof(__OSPackId) - sizeof(u32)) / sizeof(u8)); i += 2) {
|
||||
data = *((u16*)((u32)ptr + i));
|
||||
*checkSum += data;
|
||||
*idSum += ~data;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 __osRepairPackId(OSPfs* pfs, __OSPackId* badid, __OSPackId* newid) {
|
||||
s32 ret = 0;
|
||||
u8 temp[BLOCKSIZE];
|
||||
u8 comp[BLOCKSIZE];
|
||||
u8 mask = 0;
|
||||
s32 i, j = 0;
|
||||
u16 index[4];
|
||||
|
||||
newid->repaired = 0xFFFFFFFF;
|
||||
newid->random = osGetCount();
|
||||
newid->serialMid = badid->serialMid;
|
||||
newid->serialLow = badid->serialLow;
|
||||
|
||||
if ((pfs->activebank != 0) && ((ret = __osPfsSelectBank(pfs, 0)) != 0)) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
do {
|
||||
if ((ret = __osPfsSelectBank(pfs, j)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
temp[0] = j | 0x80;
|
||||
for (i = 1; i < BLOCKSIZE; i++) {
|
||||
temp[i] = ~temp[i];
|
||||
}
|
||||
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, 0, temp, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, comp)) != 0) {
|
||||
return (ret);
|
||||
}
|
||||
for (i = 0; i < BLOCKSIZE; i++) {
|
||||
if (comp[i] != temp[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i != BLOCKSIZE) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (j > 0) {
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if (temp[0] != 0x80) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
j++;
|
||||
} while (j < PFS_MAX_BANKS);
|
||||
|
||||
if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
mask = (j > 0) ? 1 : 0;
|
||||
newid->deviceid = (badid->deviceid & 0xFFFE) | mask;
|
||||
newid->banks = j;
|
||||
newid->version = badid->version;
|
||||
__osIdCheckSum(newid, &newid->checksum, &newid->invertedChecksum);
|
||||
|
||||
index[0] = PFS_ID_0AREA;
|
||||
index[1] = PFS_ID_1AREA;
|
||||
index[2] = PFS_ID_2AREA;
|
||||
index[3] = PFS_ID_3AREA;
|
||||
for (i = 0; i < 4; i++) {
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, index[i], newid, PFS_FORCE)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
for (i = 0; i < BLOCKSIZE; i++) {
|
||||
if (temp[i] != *(u8*)((s32)newid + i)) {
|
||||
return PFS_ERR_DEVICE;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 __osCheckPackId(OSPfs* pfs, __OSPackId* temp) {
|
||||
|
||||
u16 index[4];
|
||||
s32 ret = 0;
|
||||
u16 sum;
|
||||
u16 idSum;
|
||||
s32 i;
|
||||
s32 j;
|
||||
|
||||
if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
index[0] = PFS_ID_0AREA;
|
||||
index[1] = PFS_ID_1AREA;
|
||||
index[2] = PFS_ID_2AREA;
|
||||
index[3] = PFS_ID_3AREA;
|
||||
for (i = 1; i < 4; i++) {
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, index[i], temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
__osIdCheckSum(temp, &sum, &idSum);
|
||||
if ((temp->checksum == sum) && (temp->invertedChecksum == idSum)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == 4) {
|
||||
return PFS_ERR_ID_FATAL;
|
||||
}
|
||||
|
||||
for (j = 0; j < 4; j++) {
|
||||
if (j != i) {
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, index[j], temp, PFS_FORCE)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
s32 __osGetId(OSPfs* pfs) {
|
||||
|
||||
u16 sum, isum;
|
||||
u8 temp[BLOCKSIZE];
|
||||
__OSPackId newid;
|
||||
s32 ret;
|
||||
__OSPackId* id;
|
||||
|
||||
if (pfs->activebank != 0) {
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
__osIdCheckSum((u16*)temp, &sum, &isum);
|
||||
id = (__OSPackId*)temp;
|
||||
if ((id->checksum != sum) || (id->invertedChecksum != isum)) {
|
||||
if ((ret = __osCheckPackId(pfs, id)) == PFS_ERR_ID_FATAL) {
|
||||
ret = __osRepairPackId(pfs, id, &newid);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
id = &newid;
|
||||
} else if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if ((id->deviceid & 0x01) == 0) {
|
||||
ret = __osRepairPackId(pfs, id, &newid);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
id = &newid;
|
||||
if ((id->deviceid & 0x01) == 0) {
|
||||
return PFS_ERR_DEVICE;
|
||||
}
|
||||
}
|
||||
|
||||
bcopy(id, pfs->id, BLOCKSIZE);
|
||||
|
||||
pfs->version = id->version;
|
||||
|
||||
pfs->banks = id->banks;
|
||||
pfs->inodeStartPage = 1 + DEF_DIR_PAGES + (2 * pfs->banks);
|
||||
pfs->dir_size = DEF_DIR_PAGES * PFS_ONE_PAGE;
|
||||
pfs->inode_table = 1 * PFS_ONE_PAGE;
|
||||
pfs->minode_table = (1 + pfs->banks) * PFS_ONE_PAGE;
|
||||
pfs->dir_table = pfs->minode_table + (pfs->banks * PFS_ONE_PAGE);
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_LABEL_AREA, pfs->label)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/contpfs/__osGetId.s")
|
||||
#endif
|
||||
|
||||
s32 __osCheckId(OSPfs* pfs) {
|
||||
u8 temp[BLOCKSIZE];
|
||||
s32 ret;
|
||||
|
||||
if (pfs->activebank != 0) {
|
||||
ret = __osPfsSelectBank(pfs, 0);
|
||||
if (ret == PFS_ERR_NEW_PACK) {
|
||||
ret = __osPfsSelectBank(pfs, 0);
|
||||
}
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
|
||||
if (ret != PFS_ERR_NEW_PACK) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (bcmp(pfs->id, temp, BLOCKSIZE) != 0) {
|
||||
return PFS_ERR_NEW_PACK;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 __osPfsRWInode(OSPfs* pfs, __OSInode* inode, u8 flag, u8 bank) {
|
||||
u8 sum;
|
||||
s32 j;
|
||||
s32 ret;
|
||||
s32 offset;
|
||||
u8* addr;
|
||||
|
||||
if (flag == PFS_READ && bank == __osPfsInodeCacheBank && (pfs->channel == __osPfsInodeCacheChannel)) {
|
||||
bcopy(&__osPfsInodeCache, inode, sizeof(__OSInode));
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
offset = ((bank > 0) ? 1 : pfs->inodeStartPage);
|
||||
|
||||
if (flag == PFS_WRITE) {
|
||||
inode->inodePage[0].inode_t.page =
|
||||
__osSumcalc(inode->inodePage + offset, (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
|
||||
}
|
||||
|
||||
for (j = 0; j < PFS_ONE_PAGE; j++) {
|
||||
addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
|
||||
if (flag == PFS_WRITE) {
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->minode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
|
||||
} else {
|
||||
ret = __osContRamRead(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr);
|
||||
}
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (flag == PFS_READ) {
|
||||
sum = __osSumcalc((u8*)(inode->inodePage + offset), (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
|
||||
if (sum != inode->inodePage[0].inode_t.page) {
|
||||
for (j = 0; j < PFS_ONE_PAGE; j++) {
|
||||
addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
|
||||
ret = __osContRamRead(pfs->queue, pfs->channel, pfs->minode_table + (bank * PFS_ONE_PAGE) + j, addr);
|
||||
}
|
||||
sum = __osSumcalc(inode->inodePage + offset, (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
|
||||
if (sum != inode->inodePage[0].inode_t.page) {
|
||||
return PFS_ERR_INCONSISTENT;
|
||||
}
|
||||
for (j = 0; j < PFS_ONE_PAGE; j++) {
|
||||
addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
__osPfsInodeCacheBank = bank;
|
||||
bcopy(inode, &__osPfsInodeCache, sizeof(__OSInode));
|
||||
__osPfsInodeCacheChannel = pfs->channel;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,15 +1,12 @@
|
|||
#include "libultra_internal.h"
|
||||
#include <global.h>
|
||||
|
||||
s32 osAfterPreNMI(void) {
|
||||
return __osSpSetPc(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* osContStartQuery:
|
||||
* Starts to read the values for SI device status and type which are connected to the controller port and joyport
|
||||
* connector.
|
||||
**/
|
||||
|
||||
s32 osContStartQuery(OSMesgQueue* mq) {
|
||||
s32 ret;
|
||||
ret = 0;
|
||||
|
|
@ -1,3 +1,64 @@
|
|||
#include "libultra_internal.h"
|
||||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/cosf/cosf.s")
|
||||
static const du P[] = {
|
||||
{ 0x3FF00000, 0x00000000 }, { 0xBFC55554, 0xBC83656D }, { 0x3F8110ED, 0x3804C2A0 },
|
||||
{ 0xBF29f6FF, 0xEEA56814 }, { 0x3EC5DBDF, 0x0E314BFE },
|
||||
};
|
||||
|
||||
static const du rpi = { 0x3FD45F30, 0x6DC9C883 };
|
||||
|
||||
static const du pihi = { 0x400921FB, 0x50000000 };
|
||||
|
||||
static const du pilo = { 0x3E6110B4, 0x611A6263 };
|
||||
|
||||
static const fu zero = { 0x00000000 };
|
||||
|
||||
f32 cosf(f32 x) {
|
||||
f32 absx;
|
||||
f64 dx;
|
||||
f64 xSq;
|
||||
f64 polyApprox;
|
||||
f64 dn;
|
||||
s32 n;
|
||||
f64 result;
|
||||
s32 ix, xpt;
|
||||
|
||||
ix = *(s32*)&x;
|
||||
xpt = (ix >> 22);
|
||||
xpt &= 0x1FF;
|
||||
|
||||
if (xpt < 0x136) {
|
||||
|
||||
absx = ULTRA_ABS(x);
|
||||
|
||||
dx = absx;
|
||||
|
||||
dn = dx * rpi.d + 0.5;
|
||||
n = ROUND(dn);
|
||||
dn = n;
|
||||
|
||||
dn -= 0.5;
|
||||
|
||||
dx -= dn * pihi.d;
|
||||
dx -= dn * pilo.d;
|
||||
|
||||
xSq = SQ(dx);
|
||||
|
||||
polyApprox = ((P[4].d * xSq + P[3].d) * xSq + P[2].d) * xSq + P[1].d;
|
||||
|
||||
result = dx + (dx * xSq) * polyApprox;
|
||||
|
||||
if (!(n & 1)) {
|
||||
return (f32)result;
|
||||
}
|
||||
|
||||
return -(f32)result;
|
||||
}
|
||||
|
||||
if (x != x) {
|
||||
return __libm_qnan_f;
|
||||
}
|
||||
|
||||
return zero.f;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,62 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/guLookAt/guLookAtF.s")
|
||||
void guLookAtF(f32 mf[4][4], f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, f32 zAt, f32 xUp, f32 yUp, f32 zUp) {
|
||||
f32 length;
|
||||
f32 xLook, yLook, zLook;
|
||||
f32 xRight, yRight, zRight;
|
||||
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/guLookAt/guLookAt.s")
|
||||
guMtxIdentF(mf);
|
||||
|
||||
xLook = xAt - xEye;
|
||||
yLook = yAt - yEye;
|
||||
zLook = zAt - zEye;
|
||||
length = -1.0 / sqrtf(SQ(xLook) + SQ(yLook) + SQ(zLook));
|
||||
xLook *= length;
|
||||
yLook *= length;
|
||||
zLook *= length;
|
||||
|
||||
xRight = yUp * zLook - zUp * yLook;
|
||||
yRight = zUp * xLook - xUp * zLook;
|
||||
zRight = xUp * yLook - yUp * xLook;
|
||||
length = 1.0 / sqrtf(SQ(xRight) + SQ(yRight) + SQ(zRight));
|
||||
xRight *= length;
|
||||
yRight *= length;
|
||||
zRight *= length;
|
||||
|
||||
xUp = yLook * zRight - zLook * yRight;
|
||||
yUp = zLook * xRight - xLook * zRight;
|
||||
zUp = xLook * yRight - yLook * xRight;
|
||||
length = 1.0 / sqrtf(SQ(xUp) + SQ(yUp) + SQ(zUp));
|
||||
xUp *= length;
|
||||
yUp *= length;
|
||||
zUp *= length;
|
||||
|
||||
mf[0][0] = xRight;
|
||||
mf[1][0] = yRight;
|
||||
mf[2][0] = zRight;
|
||||
mf[3][0] = -(xEye * xRight + yEye * yRight + zEye * zRight);
|
||||
|
||||
mf[0][1] = xUp;
|
||||
mf[1][1] = yUp;
|
||||
mf[2][1] = zUp;
|
||||
mf[3][1] = -(xEye * xUp + yEye * yUp + zEye * zUp);
|
||||
|
||||
mf[0][2] = xLook;
|
||||
mf[1][2] = yLook;
|
||||
mf[2][2] = zLook;
|
||||
mf[3][2] = -(xEye * xLook + yEye * yLook + zEye * zLook);
|
||||
|
||||
mf[0][3] = 0;
|
||||
mf[1][3] = 0;
|
||||
mf[2][3] = 0;
|
||||
mf[3][3] = 1;
|
||||
}
|
||||
|
||||
void guLookAt(Mtx* m, f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, f32 zAt, f32 xUp, f32 yUp, f32 zUp) {
|
||||
f32 mf[4][4];
|
||||
|
||||
guLookAtF(mf, xEye, yEye, zEye, xAt, yAt, zAt, xUp, yUp, zUp);
|
||||
|
||||
guMtxF2L(mf, m);
|
||||
}
|
||||
|
|
|
|||
6
src/libultra_code/osAfterPreNMI.c
Normal file
6
src/libultra_code/osAfterPreNMI.c
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
s32 osAfterPreNMI(void) {
|
||||
return __osSpSetPc(0);
|
||||
}
|
||||
70
src/libultra_code/osPfsDeleteFile.c
Normal file
70
src/libultra_code/osPfsDeleteFile.c
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
#include <ultra64/pfs.h>
|
||||
#include <global.h>
|
||||
|
||||
s32 osPfsDeleteFile(OSPfs* pfs, u16 company_code, u32 game_code, u8* game_name, u8* ext_name) {
|
||||
|
||||
s32 file_no;
|
||||
s32 ret;
|
||||
__OSInode inode;
|
||||
__OSDir dir;
|
||||
__OSInodeUnit last_page;
|
||||
u8 startpage;
|
||||
u8 bank;
|
||||
|
||||
if ((company_code == 0) || (game_code == 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
if ((ret = osPfsFindFile(pfs, company_code, game_code, game_name, ext_name, &file_no)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + file_no, (u8*)&dir)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
startpage = dir.start_page.inode_t.page;
|
||||
for (bank = dir.start_page.inode_t.bank; bank < pfs->banks;) {
|
||||
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osPfsReleasePages(pfs, &inode, startpage, bank, &last_page)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osPfsRWInode(pfs, &inode, PFS_WRITE, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if (last_page.ipage == PFS_EOF) {
|
||||
break;
|
||||
}
|
||||
bank = last_page.inode_t.bank;
|
||||
startpage = last_page.inode_t.page;
|
||||
}
|
||||
|
||||
if (bank >= pfs->banks) {
|
||||
return PFS_ERR_INCONSISTENT;
|
||||
}
|
||||
bzero(&dir, sizeof(__OSDir));
|
||||
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + file_no, (u8*)&dir, 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
s32 __osPfsReleasePages(OSPfs* pfs, __OSInode* inode, u8 initialPage, u8 bank, __OSInodeUnit* finalPage) {
|
||||
__OSInodeUnit next;
|
||||
__OSInodeUnit prev;
|
||||
s32 ret = 0;
|
||||
|
||||
next.ipage = (u16)((bank << 8) + initialPage);
|
||||
|
||||
do {
|
||||
prev = next;
|
||||
next = inode->inodePage[next.inode_t.page];
|
||||
inode->inodePage[prev.inode_t.page].ipage = PFS_PAGE_NOT_USED;
|
||||
} while (next.ipage >= pfs->inodeStartPage && next.inode_t.bank == bank);
|
||||
|
||||
*finalPage = next;
|
||||
|
||||
return ret;
|
||||
}
|
||||
53
src/libultra_code/osPfsFindFile.c
Normal file
53
src/libultra_code/osPfsFindFile.c
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
s32 osPfsFindFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32* fileNo) {
|
||||
s32 j;
|
||||
s32 i;
|
||||
__OSDir dir;
|
||||
s32 ret = 0;
|
||||
s32 err;
|
||||
|
||||
if (!(pfs->status & PFS_INITIALIZED)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
|
||||
if ((ret = __osCheckId(pfs)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (j = 0; j < pfs->dir_size; j++) {
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, &dir)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osPfsGetStatus(pfs->queue, pfs->channel)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((dir.company_code == companyCode) && (dir.game_code == gameCode)) {
|
||||
err = 0;
|
||||
if (gameName != 0) {
|
||||
for (i = 0; i < PFS_FILE_NAME_LEN; i++) {
|
||||
if (dir.game_name[i] != gameName[i]) {
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((extName != 0) && (err == 0)) {
|
||||
for (i = 0; i < PFS_FILE_EXT_LEN; i++) {
|
||||
if (dir.ext_name[i] != extName[i]) {
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (err == 0) {
|
||||
*fileNo = j;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
*fileNo = -1;
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
36
src/libultra_code/osPfsFreeBlocks.c
Normal file
36
src/libultra_code/osPfsFreeBlocks.c
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
#include <ultra64/pfs.h>
|
||||
|
||||
s32 osPfsFreeBlocks(OSPfs* pfs, s32* leftoverBytes) {
|
||||
s32 j;
|
||||
s32 pages = 0;
|
||||
__OSInode inode;
|
||||
s32 ret = 0;
|
||||
u8 bank;
|
||||
s32 offset;
|
||||
|
||||
if (!(pfs->status & PFS_INITIALIZED)) {
|
||||
return (PFS_ERR_INVALID);
|
||||
}
|
||||
|
||||
if ((ret = __osCheckId(pfs)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
|
||||
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
|
||||
for (j = offset; j < PFS_INODE_SIZE_PER_PAGE; j++) {
|
||||
if (inode.inodePage[j].ipage == PFS_PAGE_NOT_USED) {
|
||||
pages++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*leftoverBytes = pages * PFS_ONE_PAGE * BLOCKSIZE;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -54,7 +54,7 @@ void osSetUpMempakWrite(s32 channel, OSPifRam* buf) {
|
|||
mempakwr.rxsize = 1;
|
||||
mempakwr.poll = 3; // write mempak
|
||||
mempakwr.hi = 0x600 >> 3;
|
||||
mempakwr.lo = (u8)(osMempakAddrCRC(0x600) | (0x600 << 5));
|
||||
mempakwr.lo = (u8)(__osContAddressCrc(0x600) | (0x600 << 5));
|
||||
if (channel != 0) {
|
||||
for (i = 0; i < channel; ++i) {
|
||||
*bufptr++ = 0;
|
||||
|
|
@ -74,14 +74,14 @@ s32 osProbeRumblePak(OSMesgQueue* ctrlrqueue, OSPfs* pfs, u32 channel) {
|
|||
pfs->activebank = 0xFF;
|
||||
pfs->status = 0;
|
||||
|
||||
ret = func_80104C80(pfs, 0xFE);
|
||||
ret = __osPfsSelectBank(pfs, 0xFE);
|
||||
if (ret == 2) {
|
||||
ret = func_80104C80(pfs, MOTOR_ID);
|
||||
ret = __osPfsSelectBank(pfs, MOTOR_ID);
|
||||
}
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
ret = osReadMempak(ctrlrqueue, channel, BANK_ADDR, sp24);
|
||||
ret = __osContRamRead(ctrlrqueue, channel, BANK_ADDR, sp24);
|
||||
ret = ret;
|
||||
if (ret == 2) {
|
||||
ret = 4; // "Controller pack communication error"
|
||||
|
|
@ -92,14 +92,14 @@ s32 osProbeRumblePak(OSMesgQueue* ctrlrqueue, OSPfs* pfs, u32 channel) {
|
|||
if (sp24[BLOCKSIZE - 1] == 0xFE) {
|
||||
return 0xB;
|
||||
}
|
||||
ret = func_80104C80(pfs, MOTOR_ID);
|
||||
ret = __osPfsSelectBank(pfs, MOTOR_ID);
|
||||
if (ret == 2) {
|
||||
ret = 4; // "Controller pack communication error"
|
||||
}
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
ret = osReadMempak(ctrlrqueue, channel, BANK_ADDR, sp24);
|
||||
ret = __osContRamRead(ctrlrqueue, channel, BANK_ADDR, sp24);
|
||||
if (ret == 2) {
|
||||
ret = 4; // "Controller pack communication error"
|
||||
}
|
||||
|
|
|
|||
137
src/libultra_code/pfsallocatefile.c
Normal file
137
src/libultra_code/pfsallocatefile.c
Normal file
|
|
@ -0,0 +1,137 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
#include <ultra64/pfs.h>
|
||||
|
||||
s32 osPfsAllocateFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32 fileSize, s32* fileNo) {
|
||||
s32 startPage, decleared, prevPage;
|
||||
s32 oldPrevPage = 0;
|
||||
s32 ret = 0;
|
||||
s32 fileSizeInPages;
|
||||
__OSInode inode, backup_inode;
|
||||
__OSDir dir;
|
||||
u8 bank;
|
||||
u8 prevBank = 0;
|
||||
s32 firsttime = 0;
|
||||
s32 bytes;
|
||||
__OSInodeUnit fpage;
|
||||
|
||||
if ((companyCode == 0) || (gameCode == 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
|
||||
fileSizeInPages = (fileSize + PFS_PAGE_SIZE - 1) / PFS_PAGE_SIZE;
|
||||
|
||||
if (((ret = osPfsFindFile(pfs, companyCode, gameCode, gameName, extName, fileNo)) != 0) &&
|
||||
(ret != PFS_ERR_INVALID)) {
|
||||
return ret;
|
||||
}
|
||||
if (*fileNo != -1) {
|
||||
return PFS_ERR_EXIST;
|
||||
}
|
||||
|
||||
ret = osPfsFreeBlocks(pfs, &bytes);
|
||||
if (fileSize > bytes) {
|
||||
return PFS_DATA_FULL;
|
||||
}
|
||||
|
||||
if (fileSizeInPages == 0) {
|
||||
return (PFS_ERR_INVALID);
|
||||
}
|
||||
|
||||
if (((ret = osPfsFindFile(pfs, 0, 0, 0, 0, fileNo)) != 0) && (ret != PFS_ERR_INVALID)) {
|
||||
return ret;
|
||||
}
|
||||
if (*fileNo == -1) {
|
||||
return PFS_DIR_FULL;
|
||||
}
|
||||
|
||||
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
|
||||
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
ret = __osPfsDeclearPage(pfs, &inode, fileSizeInPages, &startPage, bank, &decleared, &prevPage);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
if (startPage != -1) { /* There is free space */
|
||||
if (firsttime == 0) {
|
||||
fpage.inode_t.page = (u8)startPage;
|
||||
fpage.inode_t.bank = bank;
|
||||
} else { /* Writing previous bank inode */
|
||||
backup_inode.inodePage[oldPrevPage].inode_t.bank = bank;
|
||||
backup_inode.inodePage[oldPrevPage].inode_t.page = (u8)startPage;
|
||||
if ((ret = __osPfsRWInode(pfs, &backup_inode, PFS_WRITE, prevBank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if (fileSizeInPages > decleared) {
|
||||
bcopy(&inode, &backup_inode, sizeof(__OSInode));
|
||||
oldPrevPage = prevPage;
|
||||
prevBank = bank;
|
||||
fileSizeInPages -= decleared;
|
||||
firsttime++;
|
||||
} else {
|
||||
fileSizeInPages = 0;
|
||||
if ((ret = __osPfsRWInode(pfs, &inode, PFS_WRITE, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((fileSizeInPages > 0) || (startPage == -1)) {
|
||||
return PFS_ERR_INCONSISTENT;
|
||||
}
|
||||
|
||||
dir.start_page = fpage;
|
||||
dir.company_code = companyCode;
|
||||
dir.game_code = gameCode;
|
||||
dir.data_sum = 0;
|
||||
|
||||
bcopy(gameName, dir.game_name, PFS_FILE_NAME_LEN);
|
||||
bcopy(extName, dir.ext_name, PFS_FILE_EXT_LEN);
|
||||
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + *fileNo, &dir, 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
s32 __osPfsDeclearPage(OSPfs* pfs, __OSInode* inode, s32 fileSizeInPages, s32* startPage, u8 bank, s32* decleared,
|
||||
s32* finalPage) {
|
||||
s32 j;
|
||||
s32 spage, prevPage;
|
||||
s32 ret = 0;
|
||||
s32 offset;
|
||||
|
||||
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
|
||||
for (j = offset; j < PFS_INODE_SIZE_PER_PAGE; j++) {
|
||||
if (inode->inodePage[j].ipage == PFS_PAGE_NOT_USED) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (j == PFS_INODE_SIZE_PER_PAGE) {
|
||||
*startPage = -1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
spage = j;
|
||||
*decleared = 1;
|
||||
prevPage = j;
|
||||
j++;
|
||||
while ((fileSizeInPages > *decleared) && (j < PFS_INODE_SIZE_PER_PAGE)) {
|
||||
if (inode->inodePage[j].ipage == PFS_PAGE_NOT_USED) {
|
||||
inode->inodePage[prevPage].inode_t.bank = (u8)bank;
|
||||
inode->inodePage[prevPage].inode_t.page = (u8)j;
|
||||
prevPage = j;
|
||||
(*decleared)++;
|
||||
}
|
||||
j++;
|
||||
}
|
||||
*startPage = spage;
|
||||
if ((j == (PFS_INODE_SIZE_PER_PAGE)) && (fileSizeInPages > *decleared)) {
|
||||
*finalPage = prevPage;
|
||||
} else {
|
||||
inode->inodePage[prevPage].ipage = PFS_EOF;
|
||||
*finalPage = 0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
203
src/libultra_code/pfschecker.c
Normal file
203
src/libultra_code/pfschecker.c
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
#include <ultra64/pfs.h>
|
||||
|
||||
#define CHECK_IPAGE(p) \
|
||||
(((p).ipage >= pfs->inodeStartPage) && ((p).inode_t.bank < pfs->banks) && ((p).inode_t.page >= 0x01) && \
|
||||
((p).inode_t.page < 0x80))
|
||||
|
||||
s32 osPfsChecker(OSPfs* pfs) {
|
||||
s32 j;
|
||||
s32 ret;
|
||||
__OSInodeUnit next;
|
||||
__OSInode checkedInode;
|
||||
__OSInode tempInode;
|
||||
__OSDir tempDir;
|
||||
__OSInodeUnit nextNodeInFile[16];
|
||||
|
||||
__OSInodeCache cache;
|
||||
|
||||
s32 fixed = 0;
|
||||
u8 bank, prevBank = 254;
|
||||
s32 cc, cl;
|
||||
s32 offset;
|
||||
|
||||
ret = __osCheckId(pfs);
|
||||
|
||||
if (ret == PFS_ERR_NEW_PACK) {
|
||||
ret = __osGetId(pfs);
|
||||
}
|
||||
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = func_80105788(pfs, &cache)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (j = 0; j < pfs->dir_size; j++) {
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, &tempDir)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((tempDir.company_code != 0) || (tempDir.game_code != 0)) {
|
||||
if ((tempDir.company_code == 0) || (tempDir.game_code == 0)) {
|
||||
cc = -1;
|
||||
} else {
|
||||
next = tempDir.start_page;
|
||||
|
||||
cl = cc = 0;
|
||||
bank = 255;
|
||||
|
||||
while (CHECK_IPAGE(next)) {
|
||||
if (bank != next.inode_t.bank) {
|
||||
bank = next.inode_t.bank;
|
||||
if (prevBank != bank) {
|
||||
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
|
||||
prevBank = bank;
|
||||
}
|
||||
|
||||
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if ((cc = func_80105A60(pfs, next, &cache) - cl) != 0) {
|
||||
break;
|
||||
}
|
||||
cl = 1;
|
||||
|
||||
next = tempInode.inodePage[next.inode_t.page];
|
||||
}
|
||||
}
|
||||
|
||||
if ((cc != 0) || (next.ipage != PFS_EOF)) {
|
||||
bzero(&tempDir, sizeof(__OSDir));
|
||||
if (pfs->activebank != 0) {
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + j, &tempDir, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
fixed++;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (j = 0; j < pfs->dir_size; j++) {
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, &tempDir)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((tempDir.company_code != 0) && (tempDir.game_code != 0) &&
|
||||
(tempDir.start_page.ipage >= (u16)pfs->inodeStartPage)) { // cast required
|
||||
nextNodeInFile[j].ipage = tempDir.start_page.ipage;
|
||||
} else {
|
||||
nextNodeInFile[j].ipage = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (bank = 0; bank < pfs->banks; bank++) {
|
||||
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
|
||||
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
|
||||
return (ret);
|
||||
}
|
||||
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
|
||||
for (j = 0; j < offset; j++) {
|
||||
checkedInode.inodePage[j].ipage = tempInode.inodePage[j].ipage;
|
||||
}
|
||||
for (; j < PFS_INODE_SIZE_PER_PAGE; j++) {
|
||||
checkedInode.inodePage[j].ipage = PFS_PAGE_NOT_USED;
|
||||
}
|
||||
|
||||
for (j = 0; j < pfs->dir_size; j++) {
|
||||
while (nextNodeInFile[j].inode_t.bank == bank &&
|
||||
nextNodeInFile[j].ipage >= (u16)pfs->inodeStartPage) { // cast required
|
||||
u8 val;
|
||||
val = nextNodeInFile[j].inode_t.page;
|
||||
nextNodeInFile[j] = checkedInode.inodePage[val] = tempInode.inodePage[val];
|
||||
}
|
||||
}
|
||||
if ((ret = __osPfsRWInode(pfs, &checkedInode, PFS_WRITE, bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (fixed != 0) {
|
||||
pfs->status |= PFS_CORRUPTED;
|
||||
} else {
|
||||
pfs->status &= ~PFS_CORRUPTED;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Original name: corrupted_init (probably needs better name)
|
||||
s32 func_80105788(OSPfs* pfs, __OSInodeCache* cache) {
|
||||
s32 i;
|
||||
s32 n;
|
||||
s32 offset;
|
||||
u8 bank;
|
||||
__OSInodeUnit tpage;
|
||||
__OSInode tempInode;
|
||||
s32 ret;
|
||||
|
||||
for (i = 0; i < PFS_INODE_DIST_MAP; i++) {
|
||||
cache->map[i] = 0;
|
||||
}
|
||||
cache->bank = 255;
|
||||
|
||||
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
|
||||
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
|
||||
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
|
||||
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (i = offset; i < PFS_INODE_SIZE_PER_PAGE; i++) {
|
||||
tpage = tempInode.inodePage[i];
|
||||
if ((tpage.ipage >= pfs->inodeStartPage) && (tpage.inode_t.bank != bank)) {
|
||||
n = ((tpage.inode_t.page & 0x7F) / PFS_SECTOR_SIZE) +
|
||||
PFS_SECTOR_PER_BANK * (tpage.inode_t.bank % PFS_BANK_LAPPED_BY);
|
||||
cache->map[n] |= (1 << (bank % PFS_BANK_LAPPED_BY));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// original name: corrupted (probably needs a better name)
|
||||
s32 func_80105A60(OSPfs* pfs, __OSInodeUnit fpage, __OSInodeCache* cache) {
|
||||
s32 j;
|
||||
s32 n;
|
||||
s32 hit = 0;
|
||||
u8 bank;
|
||||
s32 offset;
|
||||
s32 ret = 0;
|
||||
|
||||
n = (fpage.inode_t.page / PFS_SECTOR_SIZE) + PFS_SECTOR_PER_BANK * (fpage.inode_t.bank % PFS_BANK_LAPPED_BY);
|
||||
|
||||
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
|
||||
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
|
||||
if ((bank == fpage.inode_t.bank) || (cache->map[n] & (1 << (bank % PFS_BANK_LAPPED_BY))) != 0) {
|
||||
if (bank != cache->bank) {
|
||||
ret = __osPfsRWInode(pfs, &(cache->inode), PFS_READ, bank);
|
||||
if ((ret) && (ret != PFS_ERR_INCONSISTENT)) {
|
||||
return ret;
|
||||
}
|
||||
cache->bank = bank;
|
||||
}
|
||||
for (j = offset; ((hit < 2) && (j < PFS_INODE_SIZE_PER_PAGE)); j++) {
|
||||
if (cache->inode.inodePage[j].ipage == fpage.ipage) {
|
||||
hit++;
|
||||
}
|
||||
}
|
||||
if (hit >= 2) {
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
return hit;
|
||||
}
|
||||
113
src/libultra_code/pfsinitpak.c
Normal file
113
src/libultra_code/pfsinitpak.c
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
// regalloc with temp registers
|
||||
s32 osPfsInitPak(OSMesgQueue* queue, OSPfs* pfs, s32 channel) {
|
||||
s32 ret = 0;
|
||||
u16 sum;
|
||||
u16 isum;
|
||||
u8 temp[BLOCKSIZE];
|
||||
__OSPackId* id;
|
||||
__OSPackId newid;
|
||||
|
||||
__osSiGetAccess();
|
||||
|
||||
ret = __osPfsGetStatus(queue, channel);
|
||||
|
||||
__osSiRelAccess();
|
||||
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
pfs->queue = queue;
|
||||
pfs->channel = channel;
|
||||
pfs->status = 0;
|
||||
|
||||
if ((ret = __osPfsCheckRamArea(pfs)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
|
||||
return (ret);
|
||||
}
|
||||
__osIdCheckSum((u16*)temp, &sum, &isum);
|
||||
id = (__OSPackId*)temp;
|
||||
if ((id->checksum != sum) || (id->invertedChecksum != isum)) {
|
||||
if ((ret = __osCheckPackId(pfs, id)) != 0) {
|
||||
pfs->status |= PFS_ID_BROKEN;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if ((id->deviceid & 0x01) == 0) {
|
||||
ret = __osRepairPackId(pfs, id, &newid);
|
||||
if (ret) {
|
||||
if (ret == PFS_ERR_ID_FATAL) {
|
||||
pfs->status |= PFS_ID_BROKEN;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
id = &newid;
|
||||
if ((id->deviceid & 0x01) == 0) {
|
||||
return PFS_ERR_DEVICE;
|
||||
}
|
||||
}
|
||||
|
||||
bcopy(id, pfs->id, BLOCKSIZE);
|
||||
|
||||
pfs->version = (s32)id->version;
|
||||
pfs->banks = id->banks;
|
||||
pfs->inodeStartPage = 1 + DEF_DIR_PAGES + (2 * pfs->banks);
|
||||
pfs->dir_size = DEF_DIR_PAGES * PFS_ONE_PAGE;
|
||||
pfs->inode_table = 1 * PFS_ONE_PAGE;
|
||||
pfs->minode_table = (1 + pfs->banks) * PFS_ONE_PAGE;
|
||||
pfs->dir_table = pfs->minode_table + (pfs->banks * PFS_ONE_PAGE);
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_LABEL_AREA, (u8*)pfs->label)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = osPfsChecker(pfs);
|
||||
pfs->status |= PFS_INITIALIZED;
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/pfsinitpak/osPfsInitPak.s")
|
||||
#endif
|
||||
|
||||
s32 __osPfsCheckRamArea(OSPfs* pfs) {
|
||||
s32 i = 0;
|
||||
s32 ret = 0;
|
||||
u8 temp1[BLOCKSIZE];
|
||||
u8 temp2[BLOCKSIZE];
|
||||
u8 saveReg[BLOCKSIZE];
|
||||
|
||||
if ((ret = __osPfsSelectBank(pfs, PFS_ID_BANK_256K)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, saveReg)) != 0) {
|
||||
return (ret);
|
||||
}
|
||||
for (i = 0; i < BLOCKSIZE; i++) {
|
||||
temp1[i] = i;
|
||||
}
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, 0, temp1, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, temp2)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
if (bcmp(temp1, temp2, BLOCKSIZE) != 0) {
|
||||
return PFS_ERR_DEVICE;
|
||||
}
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, 0, saveReg, 0);
|
||||
|
||||
return ret;
|
||||
}
|
||||
140
src/libultra_code/pfsreadwritefile.c
Normal file
140
src/libultra_code/pfsreadwritefile.c
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
#define CHECK_IPAGE(p, pfs) \
|
||||
(((p).ipage >= (pfs).inodeStartPage) && ((p).inode_t.bank < (pfs).banks) && ((p).inode_t.page >= 0x01) && \
|
||||
((p).inode_t.page < 0x80))
|
||||
|
||||
__OSInode __osPfsInodeCache;
|
||||
|
||||
s32 __osPfsGetNextPage(OSPfs* pfs, u8* bank, __OSInode* inode, __OSInodeUnit* page) {
|
||||
s32 ret;
|
||||
|
||||
if (page->inode_t.bank != *bank) {
|
||||
*bank = page->inode_t.bank;
|
||||
if ((ret = __osPfsRWInode(pfs, inode, PFS_READ, *bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
*page = inode->inodePage[page->inode_t.page];
|
||||
|
||||
if (!CHECK_IPAGE(*page, *pfs)) {
|
||||
if (page->ipage == PFS_EOF) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
return PFS_ERR_INCONSISTENT;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 osPfsReadWriteFile(OSPfs* pfs, s32 fileNo, u8 flag, s32 offset, s32 size, u8* data) {
|
||||
s32 ret;
|
||||
__OSDir dir;
|
||||
__OSInode inode;
|
||||
__OSInodeUnit curPage;
|
||||
s32 curBlock;
|
||||
s32 blockSize;
|
||||
u8* buffer;
|
||||
u8 bank;
|
||||
u16 blockno;
|
||||
|
||||
if ((fileNo >= pfs->dir_size) || (fileNo < 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
if ((size <= 0) || ((size % BLOCKSIZE) != 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
if ((offset < 0) || ((offset % BLOCKSIZE) != 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
if (!(pfs->status & PFS_INITIALIZED)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
|
||||
if (__osCheckId(pfs) == PFS_ERR_NEW_PACK) {
|
||||
return PFS_ERR_NEW_PACK;
|
||||
}
|
||||
|
||||
if (pfs->activebank != 0) {
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + fileNo, &dir)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((dir.company_code == 0) || (dir.game_code == 0)) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
|
||||
if (!CHECK_IPAGE(dir.start_page, *pfs)) {
|
||||
if (dir.start_page.ipage == PFS_EOF) {
|
||||
return PFS_ERR_INVALID;
|
||||
}
|
||||
return PFS_ERR_INCONSISTENT;
|
||||
}
|
||||
|
||||
if ((flag == PFS_READ) && ((dir.status & PFS_WRITTEN) == 0)) {
|
||||
return PFS_ERR_BAD_DATA;
|
||||
}
|
||||
|
||||
bank = 255;
|
||||
|
||||
curBlock = offset / BLOCKSIZE;
|
||||
curPage = dir.start_page;
|
||||
|
||||
while (curBlock >= 8) {
|
||||
if ((ret = __osPfsGetNextPage(pfs, &bank, &inode, &curPage)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
curBlock -= 8;
|
||||
}
|
||||
|
||||
blockSize = size / BLOCKSIZE;
|
||||
buffer = data;
|
||||
|
||||
while (blockSize > 0) {
|
||||
if (curBlock == 8) {
|
||||
if ((ret = __osPfsGetNextPage(pfs, &bank, &inode, &curPage)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
curBlock = 0;
|
||||
}
|
||||
|
||||
if (pfs->activebank != curPage.inode_t.bank) {
|
||||
if ((ret = __osPfsSelectBank(pfs, curPage.inode_t.bank)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
blockno = curPage.inode_t.page * PFS_ONE_PAGE + curBlock;
|
||||
if (flag == PFS_READ) {
|
||||
ret = __osContRamRead(pfs->queue, pfs->channel, blockno, buffer);
|
||||
} else {
|
||||
ret = __osContRamWrite(pfs->queue, pfs->channel, blockno, buffer, 0);
|
||||
}
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
buffer += BLOCKSIZE;
|
||||
curBlock++;
|
||||
blockSize--;
|
||||
}
|
||||
|
||||
if (flag == PFS_WRITE && !(dir.status & PFS_WRITTEN)) {
|
||||
dir.status |= PFS_WRITTEN;
|
||||
if (pfs->activebank != 0) {
|
||||
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + fileNo, &dir, 0)) != 0) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
ret = __osPfsGetStatus(pfs->queue, pfs->channel);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1,3 +1,66 @@
|
|||
#include "libultra_internal.h"
|
||||
#include <ultra64.h>
|
||||
#include <global.h>
|
||||
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/sinf/sinf.s")
|
||||
static const du P[] = {
|
||||
{ 0x3FF00000, 0x00000000 }, { 0xBFC55554, 0xBC83656D }, { 0x3F8110ED, 0x3804C2A0 },
|
||||
{ 0xBF29F6FF, 0xEEA56814 }, { 0x3EC5DBDF, 0x0E314BFE },
|
||||
};
|
||||
|
||||
static const du rpi = { 0x3FD45F30, 0x6DC9C883 };
|
||||
|
||||
static const du pihi = { 0x400921FB, 0x50000000 };
|
||||
|
||||
static const du pilo = { 0x3E6110B4, 0x611A6263 };
|
||||
|
||||
static const fu zero = { 0x00000000 };
|
||||
|
||||
f32 sinf(f32 x) {
|
||||
f64 dx;
|
||||
f64 xSq;
|
||||
f64 polyApprox;
|
||||
f64 dn;
|
||||
s32 n;
|
||||
f64 result;
|
||||
s32 ix, xpt;
|
||||
|
||||
ix = *(s32*)&x;
|
||||
xpt = (ix >> 22);
|
||||
xpt &= 0x1FF;
|
||||
|
||||
if (xpt < 0xFF) {
|
||||
dx = x;
|
||||
|
||||
if (xpt >= 0xE6) {
|
||||
xSq = SQ(dx);
|
||||
polyApprox = ((P[4].d * xSq + P[3].d) * xSq + P[2].d) * xSq + P[1].d;
|
||||
result = dx + (dx * xSq) * polyApprox;
|
||||
return (f32)result;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
if (xpt < 0x136) {
|
||||
dx = x;
|
||||
dn = dx * rpi.d;
|
||||
n = ROUND(dn);
|
||||
dn = n;
|
||||
|
||||
dx -= dn * pihi.d;
|
||||
dx -= dn * pilo.d;
|
||||
xSq = SQ(dx);
|
||||
|
||||
polyApprox = ((P[4].d * xSq + P[3].d) * xSq + P[2].d) * xSq + P[1].d;
|
||||
result = dx + (dx * xSq) * polyApprox;
|
||||
|
||||
if (!(n & 1)) {
|
||||
return (f32)result;
|
||||
}
|
||||
|
||||
return -(f32)result;
|
||||
}
|
||||
|
||||
if (x != x) {
|
||||
return __libm_qnan_f;
|
||||
}
|
||||
return zero.f;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,21 @@
|
|||
#include "libultra_internal.h"
|
||||
#include <ultra64.h>
|
||||
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/sins/sins.s")
|
||||
#include "sintable.c"
|
||||
|
||||
s16 sins(u16 x) {
|
||||
s16 value;
|
||||
|
||||
x >>= 4;
|
||||
|
||||
if (x & 0x400) {
|
||||
value = sintable[0x3FF - (x & 0x3FF)];
|
||||
} else {
|
||||
value = sintable[x & 0x3FF];
|
||||
}
|
||||
|
||||
if (x & 0x800) {
|
||||
return -value;
|
||||
} else {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
78
src/libultra_code/sintable.c
Normal file
78
src/libultra_code/sintable.c
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
#include <ultra64/types.h>
|
||||
|
||||
static s16 sintable[0x400] = {
|
||||
0x0000, 0x0032, 0x0064, 0x0096, 0x00C9, 0x00FB, 0x012D, 0x0160, 0x0192, 0x01C4, 0x01F7, 0x0229, 0x025B, 0x028E,
|
||||
0x02C0, 0x02F2, 0x0324, 0x0357, 0x0389, 0x03BB, 0x03EE, 0x0420, 0x0452, 0x0484, 0x04B7, 0x04E9, 0x051B, 0x054E,
|
||||
0x0580, 0x05B2, 0x05E4, 0x0617, 0x0649, 0x067B, 0x06AD, 0x06E0, 0x0712, 0x0744, 0x0776, 0x07A9, 0x07DB, 0x080D,
|
||||
0x083F, 0x0871, 0x08A4, 0x08D6, 0x0908, 0x093A, 0x096C, 0x099F, 0x09D1, 0x0A03, 0x0A35, 0x0A67, 0x0A99, 0x0ACB,
|
||||
0x0AFE, 0x0B30, 0x0B62, 0x0B94, 0x0BC6, 0x0BF8, 0x0C2A, 0x0C5C, 0x0C8E, 0x0CC0, 0x0CF2, 0x0D25, 0x0D57, 0x0D89,
|
||||
0x0DBB, 0x0DED, 0x0E1F, 0x0E51, 0x0E83, 0x0EB5, 0x0EE7, 0x0F19, 0x0F4B, 0x0F7C, 0x0FAE, 0x0FE0, 0x1012, 0x1044,
|
||||
0x1076, 0x10A8, 0x10DA, 0x110C, 0x113E, 0x116F, 0x11A1, 0x11D3, 0x1205, 0x1237, 0x1269, 0x129A, 0x12CC, 0x12FE,
|
||||
0x1330, 0x1361, 0x1393, 0x13C5, 0x13F6, 0x1428, 0x145A, 0x148C, 0x14BD, 0x14EF, 0x1520, 0x1552, 0x1584, 0x15B5,
|
||||
0x15E7, 0x1618, 0x164A, 0x167B, 0x16AD, 0x16DF, 0x1710, 0x1741, 0x1773, 0x17A4, 0x17D6, 0x1807, 0x1839, 0x186A,
|
||||
0x189B, 0x18CD, 0x18FE, 0x1930, 0x1961, 0x1992, 0x19C3, 0x19F5, 0x1A26, 0x1A57, 0x1A88, 0x1ABA, 0x1AEB, 0x1B1C,
|
||||
0x1B4D, 0x1B7E, 0x1BAF, 0x1BE1, 0x1C12, 0x1C43, 0x1C74, 0x1CA5, 0x1CD6, 0x1D07, 0x1D38, 0x1D69, 0x1D9A, 0x1DCB,
|
||||
0x1DFC, 0x1E2D, 0x1E5D, 0x1E8E, 0x1EBF, 0x1EF0, 0x1F21, 0x1F52, 0x1F82, 0x1FB3, 0x1FE4, 0x2015, 0x2045, 0x2076,
|
||||
0x20A7, 0x20D7, 0x2108, 0x2139, 0x2169, 0x219A, 0x21CA, 0x21FB, 0x222B, 0x225C, 0x228C, 0x22BD, 0x22ED, 0x231D,
|
||||
0x234E, 0x237E, 0x23AE, 0x23DF, 0x240F, 0x243F, 0x2470, 0x24A0, 0x24D0, 0x2500, 0x2530, 0x2560, 0x2591, 0x25C1,
|
||||
0x25F1, 0x2621, 0x2651, 0x2681, 0x26B1, 0x26E1, 0x2711, 0x2740, 0x2770, 0x27A0, 0x27D0, 0x2800, 0x2830, 0x285F,
|
||||
0x288F, 0x28BF, 0x28EE, 0x291E, 0x294E, 0x297D, 0x29AD, 0x29DD, 0x2A0C, 0x2A3C, 0x2A6B, 0x2A9B, 0x2ACA, 0x2AF9,
|
||||
0x2B29, 0x2B58, 0x2B87, 0x2BB7, 0x2BE6, 0x2C15, 0x2C44, 0x2C74, 0x2CA3, 0x2CD2, 0x2D01, 0x2D30, 0x2D5F, 0x2D8E,
|
||||
0x2DBD, 0x2DEC, 0x2E1B, 0x2E4A, 0x2E79, 0x2EA8, 0x2ED7, 0x2F06, 0x2F34, 0x2F63, 0x2F92, 0x2FC0, 0x2FEF, 0x301E,
|
||||
0x304C, 0x307B, 0x30A9, 0x30D8, 0x3107, 0x3135, 0x3163, 0x3192, 0x31C0, 0x31EF, 0x321D, 0x324B, 0x3279, 0x32A8,
|
||||
0x32D6, 0x3304, 0x3332, 0x3360, 0x338E, 0x33BC, 0x33EA, 0x3418, 0x3446, 0x3474, 0x34A2, 0x34D0, 0x34FE, 0x352B,
|
||||
0x3559, 0x3587, 0x35B5, 0x35E2, 0x3610, 0x363D, 0x366B, 0x3698, 0x36C6, 0x36F3, 0x3721, 0x374E, 0x377C, 0x37A9,
|
||||
0x37D6, 0x3803, 0x3831, 0x385E, 0x388B, 0x38B8, 0x38E5, 0x3912, 0x393F, 0x396C, 0x3999, 0x39C6, 0x39F3, 0x3A20,
|
||||
0x3A4D, 0x3A79, 0x3AA6, 0x3AD3, 0x3B00, 0x3B2C, 0x3B59, 0x3B85, 0x3BB2, 0x3BDE, 0x3C0B, 0x3C37, 0x3C64, 0x3C90,
|
||||
0x3CBC, 0x3CE9, 0x3D15, 0x3D41, 0x3D6D, 0x3D99, 0x3DC5, 0x3DF1, 0x3E1D, 0x3E49, 0x3E75, 0x3EA1, 0x3ECD, 0x3EF9,
|
||||
0x3F25, 0x3F50, 0x3F7C, 0x3FA8, 0x3FD3, 0x3FFF, 0x402B, 0x4056, 0x4082, 0x40AD, 0x40D8, 0x4104, 0x412F, 0x415A,
|
||||
0x4186, 0x41B1, 0x41DC, 0x4207, 0x4232, 0x425D, 0x4288, 0x42B3, 0x42DE, 0x4309, 0x4334, 0x435F, 0x4389, 0x43B4,
|
||||
0x43DF, 0x4409, 0x4434, 0x445F, 0x4489, 0x44B4, 0x44DE, 0x4508, 0x4533, 0x455D, 0x4587, 0x45B1, 0x45DC, 0x4606,
|
||||
0x4630, 0x465A, 0x4684, 0x46AE, 0x46D8, 0x4702, 0x472C, 0x4755, 0x477F, 0x47A9, 0x47D2, 0x47FC, 0x4826, 0x484F,
|
||||
0x4879, 0x48A2, 0x48CC, 0x48F5, 0x491E, 0x4948, 0x4971, 0x499A, 0x49C3, 0x49EC, 0x4A15, 0x4A3E, 0x4A67, 0x4A90,
|
||||
0x4AB9, 0x4AE2, 0x4B0B, 0x4B33, 0x4B5C, 0x4B85, 0x4BAD, 0x4BD6, 0x4BFE, 0x4C27, 0x4C4F, 0x4C78, 0x4CA0, 0x4CC8,
|
||||
0x4CF0, 0x4D19, 0x4D41, 0x4D69, 0x4D91, 0x4DB9, 0x4DE1, 0x4E09, 0x4E31, 0x4E58, 0x4E80, 0x4EA8, 0x4ED0, 0x4EF7,
|
||||
0x4F1F, 0x4F46, 0x4F6E, 0x4F95, 0x4FBD, 0x4FE4, 0x500B, 0x5032, 0x505A, 0x5081, 0x50A8, 0x50CF, 0x50F6, 0x511D,
|
||||
0x5144, 0x516B, 0x5191, 0x51B8, 0x51DF, 0x5205, 0x522C, 0x5253, 0x5279, 0x52A0, 0x52C6, 0x52EC, 0x5313, 0x5339,
|
||||
0x535F, 0x5385, 0x53AB, 0x53D1, 0x53F7, 0x541D, 0x5443, 0x5469, 0x548F, 0x54B5, 0x54DA, 0x5500, 0x5525, 0x554B,
|
||||
0x5571, 0x5596, 0x55BB, 0x55E1, 0x5606, 0x562B, 0x5650, 0x5675, 0x569B, 0x56C0, 0x56E5, 0x5709, 0x572E, 0x5753,
|
||||
0x5778, 0x579D, 0x57C1, 0x57E6, 0x580A, 0x582F, 0x5853, 0x5878, 0x589C, 0x58C0, 0x58E5, 0x5909, 0x592D, 0x5951,
|
||||
0x5975, 0x5999, 0x59BD, 0x59E1, 0x5A04, 0x5A28, 0x5A4C, 0x5A6F, 0x5A93, 0x5AB7, 0x5ADA, 0x5AFD, 0x5B21, 0x5B44,
|
||||
0x5B67, 0x5B8B, 0x5BAE, 0x5BD1, 0x5BF4, 0x5C17, 0x5C3A, 0x5C5D, 0x5C7F, 0x5CA2, 0x5CC5, 0x5CE7, 0x5D0A, 0x5D2D,
|
||||
0x5D4F, 0x5D71, 0x5D94, 0x5DB6, 0x5DD8, 0x5DFA, 0x5E1D, 0x5E3F, 0x5E61, 0x5E83, 0x5EA5, 0x5EC6, 0x5EE8, 0x5F0A,
|
||||
0x5F2C, 0x5F4D, 0x5F6F, 0x5F90, 0x5FB2, 0x5FD3, 0x5FF4, 0x6016, 0x6037, 0x6058, 0x6079, 0x609A, 0x60BB, 0x60DC,
|
||||
0x60FD, 0x611E, 0x613E, 0x615F, 0x6180, 0x61A0, 0x61C1, 0x61E1, 0x6202, 0x6222, 0x6242, 0x6263, 0x6283, 0x62A3,
|
||||
0x62C3, 0x62E3, 0x6303, 0x6323, 0x6342, 0x6362, 0x6382, 0x63A1, 0x63C1, 0x63E0, 0x6400, 0x641F, 0x643F, 0x645E,
|
||||
0x647D, 0x649C, 0x64BB, 0x64DA, 0x64F9, 0x6518, 0x6537, 0x6556, 0x6574, 0x6593, 0x65B2, 0x65D0, 0x65EF, 0x660D,
|
||||
0x662B, 0x664A, 0x6668, 0x6686, 0x66A4, 0x66C2, 0x66E0, 0x66FE, 0x671C, 0x673A, 0x6757, 0x6775, 0x6792, 0x67B0,
|
||||
0x67CD, 0x67EB, 0x6808, 0x6825, 0x6843, 0x6860, 0x687D, 0x689A, 0x68B7, 0x68D4, 0x68F1, 0x690D, 0x692A, 0x6947,
|
||||
0x6963, 0x6980, 0x699C, 0x69B9, 0x69D5, 0x69F1, 0x6A0E, 0x6A2A, 0x6A46, 0x6A62, 0x6A7E, 0x6A9A, 0x6AB5, 0x6AD1,
|
||||
0x6AED, 0x6B08, 0x6B24, 0x6B40, 0x6B5B, 0x6B76, 0x6B92, 0x6BAD, 0x6BC8, 0x6BE3, 0x6BFE, 0x6C19, 0x6C34, 0x6C4F,
|
||||
0x6C6A, 0x6C84, 0x6C9F, 0x6CBA, 0x6CD4, 0x6CEF, 0x6D09, 0x6D23, 0x6D3E, 0x6D58, 0x6D72, 0x6D8C, 0x6DA6, 0x6DC0,
|
||||
0x6DDA, 0x6DF3, 0x6E0D, 0x6E27, 0x6E40, 0x6E5A, 0x6E73, 0x6E8D, 0x6EA6, 0x6EBF, 0x6ED9, 0x6EF2, 0x6F0B, 0x6F24,
|
||||
0x6F3D, 0x6F55, 0x6F6E, 0x6F87, 0x6FA0, 0x6FB8, 0x6FD1, 0x6FE9, 0x7002, 0x701A, 0x7032, 0x704A, 0x7062, 0x707A,
|
||||
0x7092, 0x70AA, 0x70C2, 0x70DA, 0x70F2, 0x7109, 0x7121, 0x7138, 0x7150, 0x7167, 0x717E, 0x7196, 0x71AD, 0x71C4,
|
||||
0x71DB, 0x71F2, 0x7209, 0x7220, 0x7236, 0x724D, 0x7264, 0x727A, 0x7291, 0x72A7, 0x72BD, 0x72D4, 0x72EA, 0x7300,
|
||||
0x7316, 0x732C, 0x7342, 0x7358, 0x736E, 0x7383, 0x7399, 0x73AE, 0x73C4, 0x73D9, 0x73EF, 0x7404, 0x7419, 0x742E,
|
||||
0x7443, 0x7458, 0x746D, 0x7482, 0x7497, 0x74AC, 0x74C0, 0x74D5, 0x74EA, 0x74FE, 0x7512, 0x7527, 0x753B, 0x754F,
|
||||
0x7563, 0x7577, 0x758B, 0x759F, 0x75B3, 0x75C7, 0x75DA, 0x75EE, 0x7601, 0x7615, 0x7628, 0x763B, 0x764F, 0x7662,
|
||||
0x7675, 0x7688, 0x769B, 0x76AE, 0x76C1, 0x76D3, 0x76E6, 0x76F9, 0x770B, 0x771E, 0x7730, 0x7742, 0x7754, 0x7767,
|
||||
0x7779, 0x778B, 0x779D, 0x77AF, 0x77C0, 0x77D2, 0x77E4, 0x77F5, 0x7807, 0x7818, 0x782A, 0x783B, 0x784C, 0x785D,
|
||||
0x786E, 0x787F, 0x7890, 0x78A1, 0x78B2, 0x78C3, 0x78D3, 0x78E4, 0x78F4, 0x7905, 0x7915, 0x7925, 0x7936, 0x7946,
|
||||
0x7956, 0x7966, 0x7976, 0x7985, 0x7995, 0x79A5, 0x79B5, 0x79C4, 0x79D4, 0x79E3, 0x79F2, 0x7A02, 0x7A11, 0x7A20,
|
||||
0x7A2F, 0x7A3E, 0x7A4D, 0x7A5B, 0x7A6A, 0x7A79, 0x7A87, 0x7A96, 0x7AA4, 0x7AB3, 0x7AC1, 0x7ACF, 0x7ADD, 0x7AEB,
|
||||
0x7AF9, 0x7B07, 0x7B15, 0x7B23, 0x7B31, 0x7B3E, 0x7B4C, 0x7B59, 0x7B67, 0x7B74, 0x7B81, 0x7B8E, 0x7B9B, 0x7BA8,
|
||||
0x7BB5, 0x7BC2, 0x7BCF, 0x7BDC, 0x7BE8, 0x7BF5, 0x7C02, 0x7C0E, 0x7C1A, 0x7C27, 0x7C33, 0x7C3F, 0x7C4B, 0x7C57,
|
||||
0x7C63, 0x7C6F, 0x7C7A, 0x7C86, 0x7C92, 0x7C9D, 0x7CA9, 0x7CB4, 0x7CBF, 0x7CCB, 0x7CD6, 0x7CE1, 0x7CEC, 0x7CF7,
|
||||
0x7D02, 0x7D0C, 0x7D17, 0x7D22, 0x7D2C, 0x7D37, 0x7D41, 0x7D4B, 0x7D56, 0x7D60, 0x7D6A, 0x7D74, 0x7D7E, 0x7D88,
|
||||
0x7D91, 0x7D9B, 0x7DA5, 0x7DAE, 0x7DB8, 0x7DC1, 0x7DCB, 0x7DD4, 0x7DDD, 0x7DE6, 0x7DEF, 0x7DF8, 0x7E01, 0x7E0A,
|
||||
0x7E13, 0x7E1B, 0x7E24, 0x7E2C, 0x7E35, 0x7E3D, 0x7E45, 0x7E4D, 0x7E56, 0x7E5E, 0x7E66, 0x7E6D, 0x7E75, 0x7E7D,
|
||||
0x7E85, 0x7E8C, 0x7E94, 0x7E9B, 0x7EA3, 0x7EAA, 0x7EB1, 0x7EB8, 0x7EBF, 0x7EC6, 0x7ECD, 0x7ED4, 0x7EDB, 0x7EE1,
|
||||
0x7EE8, 0x7EEE, 0x7EF5, 0x7EFB, 0x7F01, 0x7F08, 0x7F0E, 0x7F14, 0x7F1A, 0x7F20, 0x7F25, 0x7F2B, 0x7F31, 0x7F36,
|
||||
0x7F3C, 0x7F41, 0x7F47, 0x7F4C, 0x7F51, 0x7F56, 0x7F5B, 0x7F60, 0x7F65, 0x7F6A, 0x7F6F, 0x7F74, 0x7F78, 0x7F7D,
|
||||
0x7F81, 0x7F85, 0x7F8A, 0x7F8E, 0x7F92, 0x7F96, 0x7F9A, 0x7F9E, 0x7FA2, 0x7FA6, 0x7FA9, 0x7FAD, 0x7FB0, 0x7FB4,
|
||||
0x7FB7, 0x7FBA, 0x7FBE, 0x7FC1, 0x7FC4, 0x7FC7, 0x7FCA, 0x7FCC, 0x7FCF, 0x7FD2, 0x7FD4, 0x7FD7, 0x7FD9, 0x7FDC,
|
||||
0x7FDE, 0x7FE0, 0x7FE2, 0x7FE4, 0x7FE6, 0x7FE8, 0x7FEA, 0x7FEC, 0x7FED, 0x7FEF, 0x7FF1, 0x7FF2, 0x7FF3, 0x7FF5,
|
||||
0x7FF6, 0x7FF7, 0x7FF8, 0x7FF9, 0x7FFA, 0x7FFB, 0x7FFB, 0x7FFC, 0x7FFD, 0x7FFD, 0x7FFE, 0x7FFE, 0x7FFE, 0x7FFE,
|
||||
0x7FFE, 0x7FFF,
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue