encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/CompilerTools.c

1231 lines
29 KiB
C
Raw Blame History

#include "CompilerTools.h"
static short lheaplockcount;
static void (*heaperror)();
static Allocator bheap;
static Allocator oheap;
static Allocator aheap;
static Allocator lheap;
static Allocator gheap;
long hash_name_id;
StringNode **name_hash_nodes;
void (*GListErrorProc)();
void CompilerGetPString(short index, unsigned char *str) {
COS_GetPString(str, 10100, index);
}
void CompilerGetCString(short index, char *str) {
COS_GetString(str, 10100, index);
}
unsigned char *CTool_CtoPstr(char *input) {
char *work = input;
int length = 0;
int i;
while (*work) {
++length;
++work;
}
for (i = length; i > 0; i--) {
work[0] = work[-1];
--work;
}
input[0] = length;
return (unsigned char *) input;
}
static void GListError() {
if (GListErrorProc)
GListErrorProc();
}
int InitGList(GList *list, long capacity) {
if ((list->data = COS_NewOSHandle(capacity)) == 0)
if ((list->data = COS_NewHandle(capacity)) == 0)
return -1;
list->size = 0;
list->expansion = capacity >> 1;
list->capacity = capacity;
return 0;
}
void FreeGList(GList *list) {
if (list->data != 0) {
COS_FreeHandle(list->data);
list->data = 0;
}
list->capacity = 0;
list->size = 0;
}
void LockGList(GList *list) {
COS_LockHandleHi(list->data);
}
void UnlockGList(GList *list) {
COS_UnlockHandle(list->data);
}
void ShrinkGList(GList *list) {
COS_ResizeHandle(list->data, list->capacity = list->size);
}
void AppendGListData(GList *list, const void *data, long size) {
if ((list->size + size) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
GListError();
}
memcpy(*list->data + list->size, data, size);
list->size += size;
}
void AppendGListNoData(GList *list, long size) {
if ((list->size + size) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
GListError();
}
list->size += size;
}
void AppendGListByte(GList *list, char v) {
if ((list->size + 1) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += 1 + list->expansion))
GListError();
}
(*list->data)[list->size++] = v;
}
void AppendGListWord(GList *list, short v) {
char *p;
if ((list->size + 2) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += 2 + list->expansion))
GListError();
}
p = *list->data + list->size;
list->size += 2;
*(p++) = ((unsigned char *) &v)[0];
*(p++) = ((unsigned char *) &v)[1];
}
void AppendGListTargetEndianWord(GList *list, short v) {
char *p;
if ((list->size + 2) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += 2 + list->expansion))
GListError();
}
p = *list->data + list->size;
list->size += 2;
*(p++) = ((unsigned char *) &v)[0];
*(p++) = ((unsigned char *) &v)[1];
}
void AppendGListLong(GList *list, long v) {
char *p;
if ((list->size + 4) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += 4 + list->expansion))
GListError();
}
p = *list->data + list->size;
list->size += 4;
*(p++) = ((unsigned char *) &v)[0];
*(p++) = ((unsigned char *) &v)[1];
*(p++) = ((unsigned char *) &v)[2];
*(p++) = ((unsigned char *) &v)[3];
}
void AppendGListTargetEndianLong(GList *list, long v) {
char *p;
if ((list->size + 4) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += 4 + list->expansion))
GListError();
}
p = *list->data + list->size;
list->size += 4;
*(p++) = ((unsigned char *) &v)[0];
*(p++) = ((unsigned char *) &v)[1];
*(p++) = ((unsigned char *) &v)[2];
*(p++) = ((unsigned char *) &v)[3];
}
void AppendGListID(GList *list, const char *str) {
unsigned long size = strlen(str) + 1;
if ((list->size + size) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
GListError();
}
memcpy(*list->data + list->size, str, size);
list->size += size;
}
void AppendGListName(GList *list, const char *str) {
unsigned long size = strlen(str);
if ((list->size + size) > list->capacity) {
if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
GListError();
}
memcpy(*list->data + list->size, str, size);
list->size += size;
}
void RemoveGListData(GList *list, long size) {
list->size -= size;
if (list->capacity > (list->size + list->expansion * 2))
COS_ResizeHandle(list->data, list->capacity = list->size + list->expansion);
}
char GetGListByte(GList *list) {
unsigned char *p;
p = (unsigned char *) (*list->data + list->size);
list->size++;
return p[0];
}
short GetGListWord(GList *list) {
unsigned char *p;
union { unsigned char bytes[2]; short s; } data;
p = (unsigned char *) (*list->data + list->size);
list->size += 2;
data.bytes[0] = p[0];
data.bytes[1] = p[1];
return data.s;
}
long GetGListLong(GList *list) {
unsigned char *p;
union { unsigned char bytes[4]; long l; } data;
p = (unsigned char *) (*list->data + list->size);
list->size += 4;
data.bytes[0] = p[0];
data.bytes[1] = p[1];
data.bytes[2] = p[2];
data.bytes[3] = p[3];
return data.l;
}
short GetGListID(GList *list, char *buf) {
short len;
char *p;
len = 1;
p = *list->data + list->size;
while (*p) {
*(buf++) = *(p++);
len++;
}
*buf = *p;
list->size += len;
return len;
}
void GetGListData(GList *list, char *buf, long size) {
memcpy(buf, *list->data + list->size, size);
list->size += size;
}
static long hashpjw(const char *str) {
unsigned long work = 0;
unsigned long tmp;
while (*str) {
work = (work << 4) + *str;
tmp = work & 0xF0000000;
if (tmp) {
work ^= (tmp >> 24);
work ^= tmp;
}
str++;
}
return work % 0xFFFFFD;
}
static short PHash(const unsigned char *str) {
short result;
short counter;
unsigned char work;
const unsigned char *p;
result = str[0];
result &= 0xFF;
p = &str[1];
if (str[0]) {
counter = result;
work = 0;
while (counter > 0) {
work = (work >> 3) | (work << 5);
work += *p;
--counter;
++p;
}
result = (result << 8) | work;
}
return result & 0x7FF;
}
short CHash(const char *str) {
/* not matching :( */
short result; // orig r4
unsigned char work; // orig r5
short counter; // orig r3
// i am: r4 = result, r5 = counter, r3 = work
if (result = strlen(str) & 0xFF) {
counter = result;
work = 0;
while (counter > 0) {
work = (work >> 3) | (work << 5);
work = work + *(str++);
counter--;
}
result = (result << 8) | work;
}
return result & 0x7FF;
}
StringNode *GetHashNameNode(const char *str) {
StringNode *node;
short hash;
hash = CHash(str);
node = name_hash_nodes[hash];
if (node == 0) {
node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
name_hash_nodes[hash] = node;
node->next = 0;
node->index = hash_name_id++;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
for (;;) {
if (strcmp(str, node->data) == 0) {
if (node->index < 0)
node->index = hash_name_id++;
return node;
}
if (node->next == 0) {
node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
node = node->next;
node->next = 0;
node->index = hash_name_id++;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
node = node->next;
}
}
}
}
StringNode *GetHashNameNodeHash(const char *str, short hash) {
StringNode *node;
node = name_hash_nodes[hash];
if (node == 0) {
node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
name_hash_nodes[hash] = node;
node->next = 0;
node->index = hash_name_id++;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
for (;;) {
if (strcmp(str, node->data) == 0)
return node;
if (node->next == 0) {
node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
node = node->next;
node->next = 0;
node->index = hash_name_id++;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
node = node->next;
}
}
}
}
StringNode *GetHashNameNodeHash2(const char *str, short hash) {
StringNode *node;
node = name_hash_nodes[hash];
if (node == 0) {
node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
name_hash_nodes[hash] = node;
node->next = 0;
node->index = -1;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
for (;;) {
if (strcmp(str, node->data) == 0)
return node;
if (node->next == 0) {
node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
node = node->next;
node->next = 0;
node->index = -1;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
node = node->next;
}
}
}
}
StringNode *GetHashNameNodeExport(const char *str) {
// not matching
StringNode *node;
short hash;
hash = CHash(str);
if ((node = name_hash_nodes[hash]) == 0) {
node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
name_hash_nodes[hash] = node;
node->next = 0;
node->index = -1;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
for (;;) {
if (strcmp(str, node->data) == 0)
return node;
if (node->next == 0) {
node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
node = node->next;
node->next = 0;
node->index = -1;
node->hash = hash;
strcpy(node->data, str);
return node;
} else {
node = node->next;
}
}
}
}
long GetHashNameNodeExportID(StringNode *node) {
if (node->index < 0)
node->index = hash_name_id++;
return node->index;
}
StringNode *GetHashNameNodeByID(long id) {
StringNode *node;
short i;
for (i = 0; i < 2048; i++) {
for (node = name_hash_nodes[i]; node; node = node->next) {
if (id == node->index)
return node;
}
}
return 0;
}
void NameHashExportReset() {
short i;
StringNode *node;
for (i = 0; i < 0x800; i++) {
node = name_hash_nodes[i];
while (node) {
node->index = -1;
node = node->next;
}
}
hash_name_id = 1;
}
void NameHashWriteNameTable(GList *list) {
StringNode *node;
StringNode **nodes;
short grp;
int i;
nodes = (StringNode **) galloc(sizeof(StringNode *) * hash_name_id);
for (grp = 0; grp < 0x800; grp++) {
node = name_hash_nodes[grp];
while (node) {
if (node->index > 0)
nodes[node->index] = node;
node = node->next;
}
}
for (i = 1; i < hash_name_id; i++) {
node = nodes[i];
AppendGListWord(list, node->hash);
AppendGListID(list, node->data);
}
if (list->size & 1)
AppendGListByte(list, 0);
}
void NameHashWriteTargetEndianNameTable(GList *list) {
StringNode *node;
StringNode **nodes;
short grp;
int i;
nodes = (StringNode **) galloc(sizeof(StringNode *) * hash_name_id);
memclrw(nodes, sizeof(StringNode *) * hash_name_id);
for (grp = 0; grp < 0x800; grp++) {
node = name_hash_nodes[grp];
while (node) {
if (node->index > 0)
nodes[node->index] = node;
node = node->next;
}
}
for (i = 1; i < hash_name_id; i++) {
node = nodes[i];
if (node == 0) {
AppendGListTargetEndianWord(list, 0);
AppendGListID(list, "");
} else {
AppendGListTargetEndianWord(list, node->hash);
AppendGListID(list, node->data);
}
}
if (list->size & 1)
AppendGListByte(list, 0);
}
void InitNameHash() {
name_hash_nodes = (StringNode **) galloc(0x800 * sizeof(StringNode *));
memclrw(name_hash_nodes, 0x800 * sizeof(StringNode *));
hash_name_id = 1;
}
long CTool_TotalHeapSize() {
long total = 0;
AllocatorBlock *block;
for (block = gheap.blockList; block; block = block->nextBlock) {
total += block->size;
}
for (block = lheap.blockList; block; block = block->nextBlock) {
total += block->size;
}
for (block = aheap.blockList; block; block = block->nextBlock) {
total += block->size;
}
for (block = oheap.blockList; block; block = block->nextBlock) {
total += block->size;
}
for (block = bheap.blockList; block; block = block->nextBlock) {
total += block->size;
}
return total;
}
static void getheapinfo(HeapInfo *result, Allocator *heap) {
AllocatorBlock *block;
result->_4 = heap->paddingSize;
for (block = heap->blockList; block; block = block->nextBlock) {
result->_8 += block->size - sizeof(AllocatorBlock);
result->xx_C += block->remaining;
result->_0++;
if (block->remaining > result->_18)
result->_18 = block->remaining;
}
result->_10 = result->_8 / result->_0;
result->_14 = result->xx_C / result->_0;
}
void CTool_GetHeapInfo(HeapInfo *result, unsigned char heapID) {
memclrw(result, sizeof(HeapInfo));
switch (heapID) {
case 0:
getheapinfo(result, &gheap);
break;
case 1:
getheapinfo(result, &lheap);
break;
case 2:
getheapinfo(result, &aheap);
break;
case 3:
getheapinfo(result, &oheap);
break;
case 4:
getheapinfo(result, &bheap);
break;
case 5:
getheapinfo(result, &gheap);
getheapinfo(result, &lheap);
getheapinfo(result, &aheap);
getheapinfo(result, &oheap);
getheapinfo(result, &bheap);
break;
}
}
static void MoreHeapSpace(Allocator *alloc, long size) {
Handle blockHandle;
long blockSize;
AllocatorBlock *block;
block = alloc->blockList;
if (block) {
alloc->lastBlockUsed->remaining = alloc->remaining;
while (block) {
if (block->remaining >= size)
goto gotBlock;
block = block->nextBlock;
}
}
/* create new block */
blockSize = size + alloc->paddingSize;
if (systemHandles) {
blockHandle = COS_NewOSHandle(blockSize << 1);
if (blockHandle != 0)
goto createdTempDoubleBlock;
blockHandle = COS_NewOSHandle(blockSize);
if (blockHandle != 0)
goto createdBlock;
}
blockHandle = COS_NewHandle(blockSize);
if (blockHandle != 0)
goto createdBlock;
if (heaperror)
heaperror();
return;
createdTempDoubleBlock:
blockSize <<= 1;
goto createdBlock;
createdBlock:
COS_LockHandleHi(blockHandle);
block = (AllocatorBlock *) *blockHandle;
block->nextBlock = alloc->blockList;
alloc->blockList = block;
block->handle = blockHandle;
block->size = blockSize;
block->remaining = blockSize - sizeof(AllocatorBlock);
gotBlock:
alloc->lastBlockUsed = block;
alloc->remaining = block->remaining;
alloc->ptrToFreeArea = ((char *) block) + block->size - block->remaining;
}
int initheaps(heaperror_t failureCallback) {
heaperror = 0;
lheaplockcount = 0;
memclrw(&gheap, sizeof(Allocator));
memclrw(&lheap, sizeof(Allocator));
memclrw(&aheap, sizeof(Allocator));
memclrw(&oheap, sizeof(Allocator));
memclrw(&bheap, sizeof(Allocator));
gheap.paddingSize = 0x38000;
lheap.paddingSize = 0x10000;
aheap.paddingSize = 0x4000;
oheap.paddingSize = 0x40000;
bheap.paddingSize = 0x4000;
MoreHeapSpace(&gheap, 0);
MoreHeapSpace(&lheap, 0);
MoreHeapSpace(&aheap, 0);
MoreHeapSpace(&oheap, 0);
MoreHeapSpace(&bheap, 0);
gheap.paddingSize = 0x8000;
lheap.paddingSize = 0x8000;
heaperror = failureCallback;
if (!gheap.lastBlockUsed || !lheap.lastBlockUsed || !aheap.lastBlockUsed || !oheap.lastBlockUsed || !bheap.lastBlockUsed)
return -1;
else
return 0;
}
int initgheap(heaperror_t failureCallback) {
heaperror = 0;
lheaplockcount = 0;
memclrw(&gheap, sizeof(Allocator));
memclrw(&lheap, sizeof(Allocator));
memclrw(&aheap, sizeof(Allocator));
memclrw(&oheap, sizeof(Allocator));
memclrw(&bheap, sizeof(Allocator));
gheap.paddingSize = 0x38000;
MoreHeapSpace(&gheap, 0);
gheap.paddingSize = 0x8000;
heaperror = failureCallback;
if (!gheap.lastBlockUsed)
return -1;
else
return 0;
}
heaperror_t getheaperror() {
return heaperror;
}
void setheaperror(heaperror_t failureCallback) {
heaperror = failureCallback;
}
static void relheap(Allocator *alloc) {
AllocatorBlock *block;
Handle handle;
block = alloc->blockList;
while (block) {
handle = block->handle;
block = block->nextBlock;
COS_FreeHandle(handle);
}
memclrw(alloc, sizeof(Allocator));
}
void releaseheaps() {
relheap(&gheap);
relheap(&lheap);
relheap(&aheap);
relheap(&oheap);
relheap(&bheap);
}
void releasegheap() {
relheap(&gheap);
}
void releaseoheap() {
relheap(&gheap);
oheap.paddingSize = 0x40000;
MoreHeapSpace(&oheap, 0);
}
char *galloc(long size) {
long alignedSize;
char *ptr;
alignedSize = (size & ~7) + 8;
if (gheap.remaining < alignedSize)
MoreHeapSpace(&gheap, alignedSize);
gheap.remaining -= alignedSize;
ptr = (char *) gheap.ptrToFreeArea;
gheap.ptrToFreeArea = ptr + alignedSize;
return ptr;
}
char *lalloc(long size) {
long alignedSize;
char *ptr;
alignedSize = (size & ~7) + 8;
if (lheap.remaining < alignedSize)
MoreHeapSpace(&lheap, alignedSize);
lheap.remaining -= alignedSize;
ptr = (char *) lheap.ptrToFreeArea;
lheap.ptrToFreeArea = ptr + alignedSize;
return ptr;
}
char *aalloc(long size) {
long alignedSize;
char *ptr;
alignedSize = (size & ~7) + 8;
if (aheap.remaining < alignedSize)
MoreHeapSpace(&aheap, alignedSize);
aheap.remaining -= alignedSize;
ptr = (char *) aheap.ptrToFreeArea;
aheap.ptrToFreeArea = ptr + alignedSize;
return ptr;
}
char *oalloc(long size) {
long alignedSize;
char *ptr;
alignedSize = (size & ~7) + 8;
if (oheap.remaining < alignedSize)
MoreHeapSpace(&oheap, alignedSize);
oheap.remaining -= alignedSize;
ptr = (char *) oheap.ptrToFreeArea;
oheap.ptrToFreeArea = ptr + alignedSize;
return ptr;
}
char *balloc(long size) {
long alignedSize;
char *ptr;
alignedSize = (size & ~7) + 8;
if (bheap.remaining < alignedSize)
MoreHeapSpace(&bheap, alignedSize);
bheap.remaining -= alignedSize;
ptr = (char *) bheap.ptrToFreeArea;
bheap.ptrToFreeArea = ptr + alignedSize;
return ptr;
}
void locklheap() {
lheaplockcount++;
}
void unlocklheap() {
if (lheaplockcount > 0)
--lheaplockcount;
}
void freelheap() {
AllocatorBlock *block;
if (lheaplockcount == 0) {
block = lheap.blockList;
lheap.lastBlockUsed = block;
lheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
lheap.remaining = block->size - sizeof(AllocatorBlock);
while (block) {
block->remaining = block->size - sizeof(AllocatorBlock);
block = block->nextBlock;
}
}
}
void freeaheap() {
AllocatorBlock *block;
block = aheap.blockList;
aheap.lastBlockUsed = block;
aheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
aheap.remaining = block->size - sizeof(AllocatorBlock);
while (block) {
block->remaining = block->size - sizeof(AllocatorBlock);
block = block->nextBlock;
}
}
void freeoheap() {
AllocatorBlock *block;
block = oheap.blockList;
oheap.lastBlockUsed = block;
oheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
oheap.remaining = block->size - sizeof(AllocatorBlock);
while (block) {
block->remaining = block->size - sizeof(AllocatorBlock);
block = block->nextBlock;
}
}
void freebheap() {
AllocatorBlock *block;
block = bheap.blockList;
bheap.lastBlockUsed = block;
bheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
bheap.remaining = block->size - sizeof(AllocatorBlock);
while (block) {
block->remaining = block->size - sizeof(AllocatorBlock);
block = block->nextBlock;
}
}
char *ScanHex(char *str, long *output, Boolean *overflow) {
long work;
int ch;
work = 0;
*overflow = 0;
for (;;) {
ch = *str;
if (ch >= '0' && ch <= '9') {
ch = ch - '0';
} else if (ch >= 'A' && ch <= 'F') {
ch = ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'f') {
ch = ch - 'a' + 10;
} else {
break;
}
if (work & 0xF0000000)
*overflow = 1;
work = (work << 4) | (short) ch;
++str;
}
*output = work;
return str;
}
char *ScanOct(char *str, long *output, Boolean *overflow) {
short digit;
long work;
work = 0;
*overflow = 0;
for (;;) {
digit = *str - '0';
if (digit >= 0 && digit <= 9) {
if (digit >= 8) {
*overflow = 1;
++str;
break;
}
} else {
break;
}
if (work & 0xE0000000)
*overflow = 1;
work = (work << 3) | digit;
++str;
}
*output = work;
return str;
}
char *ScanDec(char *str, long *output, Boolean *overflow) {
short digit;
unsigned long work;
work = 0;
*overflow = 0;
for (;;) {
digit = *str - '0';
if (digit >= 0 && digit <= 9) {
if (work >= 0x19999999 && (work > 0x19999999 || digit > 5))
*overflow = 1;
} else {
break;
}
work = (work << 3) + (work << 1) + digit;
++str;
}
*output = work;
return str;
}
static char *UnmangleClassname(char *work, char **pNameStart, short *pNameLength, char **a4, short *a5, Boolean a6) {
char ch;
short len;
char *p2;
short len2;
short i;
short wtf;
*pNameLength = 0;
if (*(work++) != '_')
return work;
if (*(work++) != '_') {
return work;
} else {
len = 0;
while (work[0] >= '0' && work[0] <= '9') {
len = (len * 10) + work[0] - '0';
++work;
}
if (len > 0) {
*pNameStart = work;
*pNameLength = len;
if (a6) {
p2 = *a4;
len2 = *a5;
i = 0;
wtf = len;
while (i < wtf && len2 < 255) {
*(p2++) = work[i];
++i;
++len2;
}
if (len2 < 255) {
*(p2++) = ':';
len2++;
}
if (len2 < 255) {
*(p2++) = ':';
len2++;
}
*a4 = p2;
*a5 = len2;
}
}
return work + len;
}
}
static char *UnmangleAppend(char *src, char srcLen, char **pOutput, short *pOutputLen) {
char *output;
short i;
short outputLen;
output = *pOutput;
outputLen = *pOutputLen;
for (i = 0; i < srcLen && outputLen < 255; i++, outputLen++) {
*(output++) = src[i];
}
*pOutput = output;
*pOutputLen = outputLen;
}
void OldUnmangle(char *input, char *output, Boolean flag) {
short var26;
char *nameStart;
short nameLength;
char *saved;
int i;
if (*input == '.')
++input;
var26 = 0;
saved = input;
if (input[0] == '_' && input[1] == '_') {
if (input[2] == 'c' && input[3] == 't') {
saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
if (nameLength == 0)
goto invalid;
UnmangleAppend(nameStart, nameLength, &output, &var26);
} else if (input[2] == 'd' && input[3] == 't') {
saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
if (nameLength == 0)
goto invalid;
if (var26 <= 255) {
*(output++) = '~';
var26++;
}
UnmangleAppend(nameStart, nameLength, &output, &var26);
} else if (input[2] == 'n' && input[3] == 'w') {
saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
UnmangleAppend("operator new", 15, &output, &var26);
} else if (input[2] == 'd' && input[3] == 'l') {
saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
UnmangleAppend("operator delete", 15, &output, &var26);
} else {
invalid:
strncpy(output, input, 256);
return;
}
} else {
i = 0;
while (*saved) {
++saved;
++i;
if (saved[0] == '_' && saved[1] == '_') {
saved = UnmangleClassname(saved, &nameStart, &nameLength, &output, &var26, flag);
break;
}
}
UnmangleAppend(input, i, &output, &var26);
}
if (flag && saved[0] == 'F') {
if (saved[1] == 'v') {
UnmangleAppend("(void)", 6, &output, &var26);
} else {
UnmangleAppend("(...)", 5, &output, &var26);
}
}
*output = 0;
}
short hash(char *str) {
char hash = 0;
while (*str) {
hash = hash << 1;
hash ^= *(str++);
}
return hash & 0x7F;
}
void memclr(void *buffer, long size) {
memset(buffer, 0, size);
}
void memclrw(void *buffer, long size) {
memset(buffer, 0, size);
}
void CToLowercase(char *src, char *dst) {
char ch;
do {
ch = tolower(*(src++));
*(dst++) = ch;
} while (ch);
}
int getbit(long v) {
switch (v) {
case 0: return -1;
case 1: return 0;
case 2: return 1;
case 4: return 2;
case 8: return 3;
case 0x10: return 4;
case 0x20: return 5;
case 0x40: return 6;
case 0x80: return 7;
case 0x100: return 8;
case 0x200: return 9;
case 0x400: return 10;
case 0x800: return 11;
case 0x1000: return 12;
case 0x2000: return 13;
case 0x4000: return 14;
case 0x8000: return 15;
case 0x10000: return 16;
case 0x20000: return 17;
case 0x40000: return 18;
case 0x80000: return 19;
case 0x100000: return 20;
case 0x200000: return 21;
case 0x400000: return 22;
case 0x800000: return 23;
case 0x1000000: return 24;
case 0x2000000: return 25;
case 0x4000000: return 26;
case 0x8000000: return 27;
case 0x10000000: return 28;
case 0x20000000: return 29;
case 0x40000000: return 30;
case 0x80000000: return 31;
default: return -2;
}
}
void CTool_EndianConvertWord64(WtfWord64 value, unsigned long long *p) {
union { unsigned char bytes[8]; WtfWord64 w; } data;
data.w.a = value.a;
data.w.b = value.b;
memcpy(p, data.bytes, 8);
}
unsigned short CTool_EndianConvertInPlaceWord16Ptr(unsigned short *p) {
unsigned short v;
v = *p;
// this probably has a conversion on non-ppc
*p = v;
return v;
}
unsigned long CTool_EndianConvertInPlaceWord32Ptr(unsigned long *p) {
unsigned long v;
v = *p;
// this probably has a conversion on non-ppc
*p = v;
return v;
}
void CTool_EndianConvertVector128() {
// not correct but idc
}
StringNode *CTool_GetPathName(const FSSpec *spec, long *mdDat) {
char buffer[256];
COS_FileGetPathName(buffer, spec, mdDat);
return GetHashNameNodeExport(buffer);
}
Boolean strcat_safe(char *dst, const char *src, int maxLen) {
int len;
char ch;
len = strlen(dst);
dst += len;
maxLen -= len;
if (maxLen < 0)
return 1;
while (maxLen != 0) {
ch = *(dst++) = *(src++);
if (ch == 0)
break;
--maxLen;
}
if (maxLen == 0 && dst[-1]) {
dst[-1] = 0;
return 1;
} else {
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink