mirror of
https://git.wuffs.org/MWCC
synced 2025-07-02 14:33:26 +00:00
first very unfinished commit lol
This commit is contained in:
Ash Wolf
commit
97f6a2438d
604
Arguments.c
Normal file
604
Arguments.c
Normal file
@ -0,0 +1,604 @@
|
||||
#include "mwcc_decomp.h"
|
||||
|
||||
char compat;
|
||||
char *MAINOPTCHAR;
|
||||
char *FIRSTARGCHAR;
|
||||
char *SEPOPTSTR;
|
||||
char SEPOPTCHAR;
|
||||
char SEP1;
|
||||
char SEP2;
|
||||
char SEP3;
|
||||
char RESPFILECHAR;
|
||||
char *RESPFILESTR;
|
||||
static ArgToken *argtoks;
|
||||
static int numargtoks;
|
||||
static int maxargtoks;
|
||||
unsigned char parserDebug;
|
||||
static unsigned char in_response_file;
|
||||
static int margc;
|
||||
static int margind;
|
||||
static char **margv;
|
||||
static OSFileHandle respfilehandle;
|
||||
static char *respfile;
|
||||
static char *respfilestart;
|
||||
static unsigned long respfilesize;
|
||||
static int scantok;
|
||||
anon0_50 linkargs;
|
||||
anon0_50 prelinkargs;
|
||||
anon0_50 postlinkargs;
|
||||
|
||||
// TODO move me
|
||||
/*extern int OS_MakeFileSpec(const char *name, struct OSSpec *spec);
|
||||
extern int OS_NewFileHandle(struct OSSpec *spec, int a, int b, OSFileHandle *fh);
|
||||
extern int OS_AppendHandle(struct OSHandle *h, const void *, long);
|
||||
extern int OS_LockFileHandle(OSFileHandle *fh, char **h, unsigned long *size);
|
||||
extern void OS_FreeFileHandle(OSFileHandle *fh);
|
||||
extern void CLPOSAlert(short code, short code2, ...);
|
||||
extern void CLPReportError(short code, ...);
|
||||
extern void CLPReportWarning(short code, ...);
|
||||
extern void CLPFatalError(const char *format, ...);
|
||||
extern int ustrncmp(const char *a, const char *b, int len);*/
|
||||
// TODO move me
|
||||
|
||||
static void Arg_AddToken(short val, char *text);
|
||||
static void Arg_Setup(int argc, char **argv);
|
||||
static void Arg_SkipRespFileWS();
|
||||
static unsigned char Arg_OpenRespFile(const char *name);
|
||||
static void Arg_CloseRespFile();
|
||||
static char *Arg_GetRespFileToken();
|
||||
static char *Arg_GetNext(unsigned char allow_resp);
|
||||
static unsigned char Arg_GotMore();
|
||||
static void Arg_Parse();
|
||||
static void Arg_GrowArgs(anon0_50 *ta);
|
||||
static void Arg_GrowArg(anon0_50 *ta, char *txt);
|
||||
|
||||
static void Arg_AddToken(short val, char *text) {
|
||||
ArgToken *cur;
|
||||
ArgToken *prev;
|
||||
ArgToken *pprev;
|
||||
ArgToken *ppprev;
|
||||
ArgToken *pppprev;
|
||||
|
||||
if (numargtoks > 0)
|
||||
prev = &argtoks[numargtoks - 1];
|
||||
else
|
||||
prev = 0;
|
||||
|
||||
if (prev && prev->val == ATK_2 && prev->text[0] == 0) {
|
||||
pppprev = ppprev = pprev = 0;
|
||||
if (numargtoks > 3)
|
||||
pppprev = &argtoks[numargtoks - 4];
|
||||
if (numargtoks > 2)
|
||||
ppprev = &argtoks[numargtoks - 3];
|
||||
if (numargtoks > 1)
|
||||
pprev = &argtoks[numargtoks - 2];
|
||||
|
||||
if (pprev) {
|
||||
if ((int) val == ATK_1 && (pprev->val == ATK_5 || pprev->val == ATK_4) && (ppprev->val != ATK_2 || pppprev->val != ATK_3)) {
|
||||
if (parserDebug)
|
||||
printf("Coalescing args with '%s'\n", Arg_GetTokenName(pprev));
|
||||
val = pprev->val;
|
||||
numargtoks -= 2;
|
||||
} else if (pprev->val == ATK_1 && ((int) val == ATK_5 || (int) val == ATK_4)) {
|
||||
if (parserDebug)
|
||||
printf("Coalescing args, removing '%s'\n", Arg_GetTokenName(pprev));
|
||||
numargtoks -= 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (numargtoks >= maxargtoks) {
|
||||
argtoks = (ArgToken *) xrealloc("argument list", argtoks, sizeof(ArgToken) * (maxargtoks + 16));
|
||||
maxargtoks += 16;
|
||||
}
|
||||
|
||||
cur = &argtoks[numargtoks];
|
||||
cur->val = val;
|
||||
if (text)
|
||||
cur->text = xstrdup(text);
|
||||
else
|
||||
cur->text = 0;
|
||||
numargtoks++;
|
||||
}
|
||||
|
||||
static void Arg_Setup(int argc, char **argv) {
|
||||
in_response_file = 0;
|
||||
respfile = 0;
|
||||
margc = argc;
|
||||
margv = argv;
|
||||
margind = 1;
|
||||
}
|
||||
|
||||
static void Arg_SkipRespFileWS() {
|
||||
restart:
|
||||
while (respfile[0] && isspace(respfile[0]))
|
||||
++respfile;
|
||||
|
||||
if (respfile[0] == '\\' && respfile[1] == '#') {
|
||||
++respfile;
|
||||
return;
|
||||
}
|
||||
|
||||
if (respfile[0] == '#') {
|
||||
if ((respfile > respfilestart) ? (respfile[-1] != '\\') : 1) {
|
||||
while (respfile[0] && respfile[0] != 10 && respfile[0] != 13)
|
||||
++respfile;
|
||||
|
||||
while (respfile[0] == 13 || respfile[0] == 10)
|
||||
++respfile;
|
||||
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned char Arg_OpenRespFile(const char *name) {
|
||||
struct OSSpec spec;
|
||||
int err;
|
||||
|
||||
if (
|
||||
(err = OS_MakeFileSpec(name, &spec))
|
||||
|| (err = OS_NewFileHandle(&spec, 0, 0, &respfilehandle))
|
||||
|| (err = OS_AppendHandle(&respfilehandle.hand, "", 1))
|
||||
|| (err = OS_LockFileHandle(&respfilehandle, &respfile, &respfilesize))
|
||||
) {
|
||||
CLPOSAlert(74, (short) err, "response ", name);
|
||||
return 0;
|
||||
} else {
|
||||
respfilestart = respfile;
|
||||
Arg_SkipRespFileWS();
|
||||
in_response_file = 1;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void Arg_CloseRespFile() {
|
||||
in_response_file = 0;
|
||||
OS_FreeFileHandle(&respfilehandle);
|
||||
}
|
||||
|
||||
static char *Arg_GetRespFileToken() {
|
||||
char *start;
|
||||
char *ptr;
|
||||
int quoting;
|
||||
|
||||
quoting = 0;
|
||||
if (respfile[0] == 0)
|
||||
return 0;
|
||||
|
||||
start = ptr = respfile;
|
||||
while (respfile[0]) {
|
||||
if (!quoting && isspace(respfile[0]))
|
||||
break;
|
||||
|
||||
if (respfile[0] == '"') {
|
||||
quoting = !quoting;
|
||||
respfile++;
|
||||
} else if (respfile[0] == '\\' && respfile[1] == '"') {
|
||||
*ptr = '"';
|
||||
respfile += 2;
|
||||
ptr++;
|
||||
} else {
|
||||
*(ptr++) = *(respfile++);
|
||||
}
|
||||
}
|
||||
|
||||
if (respfile[0])
|
||||
Arg_SkipRespFileWS();
|
||||
*ptr = 0;
|
||||
return start;
|
||||
}
|
||||
|
||||
static char *Arg_GetNext(unsigned char allow_resp) {
|
||||
char *ret;
|
||||
int rfclen;
|
||||
char *rfcequ;
|
||||
|
||||
restart:
|
||||
if (!in_response_file) {
|
||||
rfclen = 1;
|
||||
ret = margv[margind++];
|
||||
if (ret[0] == '\\' && ret[1] == RESPFILECHAR) {
|
||||
ret++;
|
||||
} else if (allow_resp) {
|
||||
if (ret[0] == RESPFILECHAR || (RESPFILESTR[0] && !ustrncmp(ret, RESPFILESTR, rfclen = strlen(RESPFILESTR))) && ret[rfclen]) {
|
||||
rfcequ = strchr(ret + rfclen, '=');
|
||||
if (rfcequ)
|
||||
rfclen = (rfcequ + 1) - ret;
|
||||
if (Arg_OpenRespFile(ret + rfclen))
|
||||
goto restart;
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ret = Arg_GetRespFileToken();
|
||||
if (!ret) {
|
||||
Arg_CloseRespFile();
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
|
||||
if (parserDebug)
|
||||
fprintf(stderr, "Got arg = '%s'\n", ret ? ret : "<NULL>");
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static unsigned char Arg_GotMore() {
|
||||
if (!in_response_file)
|
||||
return margind < margc;
|
||||
else if (respfile[0])
|
||||
return 1;
|
||||
else
|
||||
return margind < margc;
|
||||
}
|
||||
|
||||
static void Arg_Parse() {
|
||||
unsigned char isOpt;
|
||||
unsigned char isList;
|
||||
char *arg;
|
||||
char *argstart;
|
||||
char buffer[4096];
|
||||
char *bufptr;
|
||||
char ch;
|
||||
|
||||
isOpt = 0;
|
||||
isList = 0;
|
||||
while (Arg_GotMore()) {
|
||||
argstart = arg = Arg_GetNext(1);
|
||||
if (!arg)
|
||||
break;
|
||||
|
||||
bufptr = buffer;
|
||||
buffer[0] = 0;
|
||||
isList = 0;
|
||||
|
||||
if (arg[0] && arg[1] && strchr(MAINOPTCHAR, arg[0])) {
|
||||
if (isOpt)
|
||||
Arg_AddToken(ATK_1, 0);
|
||||
buffer[0] = arg[1];
|
||||
buffer[1] = 0;
|
||||
isOpt = 1;
|
||||
isList = 0;
|
||||
bufptr++;
|
||||
arg += 2;
|
||||
} else {
|
||||
isOpt = 0;
|
||||
}
|
||||
|
||||
while (arg && arg[0]) {
|
||||
ch = arg[0];
|
||||
if (arg[0] == '\\' && (arg[1] == SEP1 || arg[1] == SEP2 || arg[1] == SEP3)) {
|
||||
ch = 0x80 | *(++arg);
|
||||
} else if (compat == 1 && arg[0] == ':' && arg[1] == '\\') {
|
||||
ch |= 0x80;
|
||||
}
|
||||
|
||||
if (ch != SEP1 && ch != SEP2 && ch != SEP3) {
|
||||
if ((ch & 0x7F) == SEP1 || (ch & 0x7F) == SEP2 || (ch & 0x7F) == SEP3)
|
||||
ch &= 0x7F;
|
||||
*(bufptr++) = ch;
|
||||
if (bufptr >= &buffer[sizeof(buffer)]) {
|
||||
CLPReportError(2, argstart, argstart + strlen(argstart) - 15, sizeof(buffer));
|
||||
}
|
||||
*bufptr = 0;
|
||||
} else {
|
||||
if (isOpt) {
|
||||
Arg_AddToken(ATK_3, buffer);
|
||||
Arg_AddToken(ATK_2, buffer);
|
||||
} else {
|
||||
Arg_AddToken(ATK_2, buffer);
|
||||
}
|
||||
|
||||
Arg_AddToken(
|
||||
(unsigned char) ((ch == ',') ? ATK_5 : (((ch == '=') || (ch == SEP3)) ? ATK_4 : ATK_0)),
|
||||
0
|
||||
);
|
||||
|
||||
bufptr = buffer;
|
||||
buffer[0] = 0;
|
||||
|
||||
if (ch == SEP1 || ch == SEP2 || ch == SEP3)
|
||||
isOpt = 0;
|
||||
isList = 1;
|
||||
}
|
||||
|
||||
arg++;
|
||||
}
|
||||
|
||||
// 1799C8
|
||||
if (isOpt && bufptr > &buffer[0]) {
|
||||
Arg_AddToken(ATK_3, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])));
|
||||
Arg_AddToken(ATK_2, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])) + 1);
|
||||
} else {
|
||||
Arg_AddToken(ATK_2, buffer);
|
||||
Arg_AddToken(ATK_1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (isOpt || isList)
|
||||
Arg_AddToken(ATK_1, 0);
|
||||
Arg_AddToken(ATK_0, 0);
|
||||
}
|
||||
|
||||
enum {
|
||||
COMPAT_0,
|
||||
COMPAT_1,
|
||||
COMPAT_2
|
||||
};
|
||||
|
||||
void Arg_Init(int theargc, char **theargv) {
|
||||
int p;
|
||||
int x;
|
||||
|
||||
maxargtoks = 0;
|
||||
numargtoks = 0;
|
||||
parserDebug = 0;
|
||||
if (theargc > 1 && !strcmp(theargv[1], "--parser-debug")) {
|
||||
parserDebug = 1;
|
||||
memmove(&theargv[1], &theargv[2], sizeof(char *) * (theargc - 1));
|
||||
theargc--;
|
||||
}
|
||||
|
||||
if ((int) compat == COMPAT_0) {
|
||||
MAINOPTCHAR = "-";
|
||||
FIRSTARGCHAR = "=";
|
||||
SEPOPTSTR = " ";
|
||||
SEP1 = ',';
|
||||
SEP2 = '=';
|
||||
SEP3 = '=';
|
||||
RESPFILECHAR = '@';
|
||||
RESPFILESTR = "";
|
||||
} else if ((int) compat == COMPAT_1) {
|
||||
MAINOPTCHAR = "/-";
|
||||
FIRSTARGCHAR = ":";
|
||||
SEPOPTSTR = ":";
|
||||
SEP1 = ',';
|
||||
SEP2 = '=';
|
||||
SEP3 = ':';
|
||||
RESPFILECHAR = '@';
|
||||
RESPFILESTR = "";
|
||||
} else if ((int) compat == COMPAT_2) {
|
||||
if (!MAINOPTCHAR)
|
||||
MAINOPTCHAR = "-";
|
||||
if (!FIRSTARGCHAR)
|
||||
FIRSTARGCHAR = "=";
|
||||
if (!SEPOPTSTR)
|
||||
SEPOPTSTR = " ";
|
||||
if (!SEP1)
|
||||
SEP1 = ',';
|
||||
if (!SEP2)
|
||||
SEP2 = '=';
|
||||
if (!SEP3)
|
||||
SEP3 = '=';
|
||||
if (!RESPFILECHAR)
|
||||
RESPFILECHAR = '@';
|
||||
if (!RESPFILESTR)
|
||||
RESPFILESTR = "";
|
||||
} else {
|
||||
CLPFatalError("Unknown parser compatibility type (%d)\n", (int) compat);
|
||||
}
|
||||
|
||||
if (parserDebug) {
|
||||
printf("Incoming arguments: \n");
|
||||
for (p = 0; p < theargc; p++) {
|
||||
printf("[%s] ", theargv[p]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
Arg_Setup(theargc, theargv);
|
||||
Arg_Parse();
|
||||
Arg_Reset();
|
||||
|
||||
if (parserDebug) {
|
||||
for (x = 0; x < numargtoks; x++) {
|
||||
printf("TOKEN: '%s'\n", Arg_GetTokenName(&argtoks[x]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Arg_Terminate() {
|
||||
ArgToken *cur;
|
||||
|
||||
while (numargtoks > 0) {
|
||||
cur = &argtoks[--numargtoks];
|
||||
if (cur->text)
|
||||
free(cur->text);
|
||||
}
|
||||
|
||||
if (maxargtoks)
|
||||
free(argtoks);
|
||||
maxargtoks = 0;
|
||||
}
|
||||
|
||||
void Arg_Reset() {
|
||||
scantok = 0;
|
||||
}
|
||||
|
||||
void Arg_Stop(ArgToken *where) {
|
||||
ArgToken *cur;
|
||||
|
||||
while (&argtoks[numargtoks] > where) {
|
||||
cur = &argtoks[--numargtoks];
|
||||
if (cur->text)
|
||||
free(cur->text);
|
||||
cur->val = ATK_0;
|
||||
cur->text = 0;
|
||||
}
|
||||
|
||||
argtoks[numargtoks++].val = ATK_1;
|
||||
argtoks[numargtoks++].val = ATK_0;
|
||||
scantok = numargtoks - 2;
|
||||
}
|
||||
|
||||
ArgToken *Arg_PeekToken() {
|
||||
if (scantok >= numargtoks)
|
||||
return 0;
|
||||
else
|
||||
return &argtoks[scantok];
|
||||
}
|
||||
|
||||
ArgToken *Arg_UsedToken() {
|
||||
if (scantok < numargtoks)
|
||||
scantok++;
|
||||
return Arg_PeekToken();
|
||||
}
|
||||
|
||||
int Arg_IsEmpty() {
|
||||
ArgToken *tok;
|
||||
|
||||
tok = Arg_PeekToken();
|
||||
return (tok == 0 || tok->val == ATK_0);
|
||||
}
|
||||
|
||||
ArgToken *Arg_GetToken() {
|
||||
ArgToken *ret;
|
||||
|
||||
ret = Arg_PeekToken();
|
||||
if (ret)
|
||||
scantok++;
|
||||
return ret;
|
||||
}
|
||||
|
||||
ArgToken *Arg_UndoToken() {
|
||||
if (scantok > 0) {
|
||||
scantok--;
|
||||
return Arg_PeekToken();
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
const char *Arg_GetTokenName(ArgToken *tok) {
|
||||
if ((int) tok->val == ATK_2)
|
||||
return tok->text;
|
||||
|
||||
return
|
||||
((int) tok->val == ATK_3) ? "option" :
|
||||
((int) tok->val == ATK_5) ? "comma" :
|
||||
(((int) compat == COMPAT_1 && (int) tok->val == ATK_4)) ? "colon or equals" :
|
||||
(((int) compat != COMPAT_1 && (int) tok->val == ATK_4)) ? "equals" :
|
||||
((int) tok->val == ATK_1) ? "end of argument" :
|
||||
((int) tok->val == ATK_0) ? "end of command line" :
|
||||
"<error>";
|
||||
}
|
||||
|
||||
const char *Arg_GetTokenText(ArgToken *tok, char *buffer, int maxlen, unsigned char warn) {
|
||||
const char *ptr;
|
||||
char *bptr;
|
||||
int curlen;
|
||||
|
||||
bptr = buffer;
|
||||
curlen = 0;
|
||||
if (tok->val == ATK_2 || tok->val == ATK_3)
|
||||
ptr = tok->text;
|
||||
else
|
||||
ptr = Arg_GetTokenName(tok);
|
||||
|
||||
while (*ptr && curlen++ < maxlen) {
|
||||
*(bptr++) = *(ptr++);
|
||||
}
|
||||
|
||||
if (curlen < maxlen) {
|
||||
bptr[0] = 0;
|
||||
} else {
|
||||
bptr[-1] = 0;
|
||||
if (warn)
|
||||
CLPReportWarning(56, buffer, ptr + strlen(ptr) - ((maxlen <= 32) ? maxlen : 32), maxlen);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static void Arg_GrowArgs(anon0_50 *ta) {
|
||||
int len;
|
||||
|
||||
if (!ta->argv || (ta->argc + 1) >= ta->nargv) {
|
||||
len = ta->nargv;
|
||||
ta->nargv = len + 16;
|
||||
ta->argv = xrealloc("argument list", ta->argv, sizeof(char *) * (ta->nargv + 1));
|
||||
while (len <= ta->nargv) {
|
||||
ta->argv[len++] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
ta->argc++;
|
||||
}
|
||||
|
||||
static void Arg_GrowArg(anon0_50 *ta, char *txt) {
|
||||
char **ptr;
|
||||
int ptrlen;
|
||||
|
||||
ptr = &ta->argv[ta->argc];
|
||||
|
||||
if (*ptr == 0) {
|
||||
*ptr = xstrdup(txt);
|
||||
} else {
|
||||
ptrlen = strlen(*ptr);
|
||||
*ptr = xrealloc("command line", *ptr, ptrlen + strlen(txt) + 1);
|
||||
strcpy(*ptr + ptrlen, txt);
|
||||
}
|
||||
}
|
||||
|
||||
void Arg_InitToolArgs(anon0_50 *ta) {
|
||||
ta->argc = 0;
|
||||
ta->nargv = 0;
|
||||
ta->argv = 0;
|
||||
Arg_GrowArgs(ta);
|
||||
}
|
||||
|
||||
void Arg_AddToToolArgs(anon0_50 *ta, short tokval, char *toktxt) {
|
||||
switch (tokval) {
|
||||
case ATK_0:
|
||||
Arg_FinishToolArgs(ta);
|
||||
break;
|
||||
case ATK_1:
|
||||
if (ta->argv && ta->argv[ta->argc])
|
||||
Arg_GrowArgs(ta);
|
||||
break;
|
||||
case ATK_2:
|
||||
Arg_GrowArg(ta, toktxt);
|
||||
break;
|
||||
case ATK_3:
|
||||
Arg_GrowArg(ta, "-");
|
||||
break;
|
||||
case ATK_4:
|
||||
Arg_GrowArg(ta, "=");
|
||||
break;
|
||||
case ATK_5:
|
||||
Arg_GrowArg(ta, ",");
|
||||
break;
|
||||
default:
|
||||
#line 787
|
||||
CLPFatalError(__FILE__, __LINE__, "Unknown token (%d)", tokval);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Arg_FinishToolArgs(anon0_50 *ta) {
|
||||
Arg_GrowArgs(ta);
|
||||
ta->argv[ta->argc] = 0;
|
||||
}
|
||||
|
||||
void Arg_ToolArgsForPlugin(anon0_50 *ta, struct CWCommandLineArgs *args) {
|
||||
args->argc = 1;
|
||||
args->argv = ta->argv;
|
||||
|
||||
while (args->argv[args->argc])
|
||||
args->argc++;
|
||||
|
||||
args->envp = 0;
|
||||
}
|
||||
|
||||
void Arg_FreeToolArgs(anon0_50 *ta) {
|
||||
int x;
|
||||
|
||||
if (ta->argv) {
|
||||
for (x = 1; x < ta->argc; x++) {
|
||||
if (ta->argv[x])
|
||||
free(ta->argv[x]);
|
||||
}
|
||||
free(ta->argv);
|
||||
}
|
||||
}
|
||||
319
CError.c
Normal file
319
CError.c
Normal file
@ -0,0 +1,319 @@
|
||||
#include "CError.h"
|
||||
#include "CompilerTools.h"
|
||||
|
||||
// TODO MOVE ME
|
||||
extern char *CMangler_GetOperator(StringNode *str);
|
||||
extern jmp_buf errorreturn;
|
||||
extern unsigned char cprep_nomem_exit;
|
||||
extern unsigned char anyerrors;
|
||||
extern unsigned char fatalerrors;
|
||||
extern char string[256];
|
||||
// TODO MOVE ME
|
||||
|
||||
Token *cerror_locktoken;
|
||||
static Token *cerror_token;
|
||||
static short cerror_errorcount;
|
||||
static int cerror_lasterrorline;
|
||||
// cerror_synchdata
|
||||
// cerror_synchoffset
|
||||
int CError_BreakPointcount;
|
||||
|
||||
void CError_Init() {
|
||||
cerror_errorcount = 0;
|
||||
cerror_lasterrorline = -1;
|
||||
cerror_token = 0;
|
||||
cerror_locktoken = 0;
|
||||
}
|
||||
|
||||
void CError_SetErrorToken(Token *token) {
|
||||
if (token && token->x4)
|
||||
cerror_token = token;
|
||||
}
|
||||
|
||||
void CError_SetNullErrorToken() {
|
||||
cerror_token = (Token *) -1;
|
||||
}
|
||||
|
||||
void CError_LockErrorPos(Token *token, Token **saved) {
|
||||
*saved = cerror_locktoken;
|
||||
if (token && token->x4)
|
||||
cerror_locktoken = token;
|
||||
}
|
||||
|
||||
void CError_UnlockErrorPos(Token **saved) {
|
||||
cerror_locktoken = *saved;
|
||||
}
|
||||
|
||||
void CError_ResetErrorSkip() {
|
||||
cerror_lasterrorline = -1;
|
||||
}
|
||||
|
||||
void CError_GetErrorString(char *buf, short code) {
|
||||
// This feels dirty, surely this can't have been the solution...
|
||||
int code_ = code;
|
||||
#line 142
|
||||
CError_ASSERT(code_ >= 100 && code_ < 393);
|
||||
COS_GetString(buf, 10000, (short) (code_ - 99));
|
||||
}
|
||||
|
||||
void CError_BufferInit(CErrorBuffer *eb, char *buf, long bufSize) {
|
||||
eb->start = eb->end = buf;
|
||||
eb->size = eb->remaining = bufSize - 1;
|
||||
}
|
||||
|
||||
void CError_BufferGrow(CErrorBuffer *eb, long amount) {
|
||||
char *newBuf;
|
||||
|
||||
newBuf = lalloc(eb->size + amount);
|
||||
memcpy(newBuf, eb->start, eb->size);
|
||||
eb->start = newBuf;
|
||||
eb->end = newBuf + eb->size - eb->remaining;
|
||||
eb->size += amount;
|
||||
eb->remaining += amount;
|
||||
}
|
||||
|
||||
void CError_BufferAppendChar(CErrorBuffer *eb, char ch) {
|
||||
if (eb) {
|
||||
if (!eb->remaining)
|
||||
CError_BufferGrow(eb, 256);
|
||||
*(eb->end++) = ch;
|
||||
eb->remaining--;
|
||||
}
|
||||
}
|
||||
|
||||
void CError_BufferAppendString(CErrorBuffer *eb, const char *str) {
|
||||
size_t len;
|
||||
|
||||
if (eb) {
|
||||
len = strlen(str);
|
||||
if (eb->remaining < len)
|
||||
CError_BufferGrow(eb, len);
|
||||
memcpy(eb->end, str, len);
|
||||
eb->end += len;
|
||||
eb->remaining -= len;
|
||||
}
|
||||
}
|
||||
|
||||
void CError_BufferTerminate(CErrorBuffer *eb) {
|
||||
if (eb->remaining == 0)
|
||||
CError_BufferGrow(eb, 1);
|
||||
*eb->end = 0;
|
||||
eb->remaining = 0;
|
||||
}
|
||||
|
||||
void CError_BufferAppendQualifier(CErrorBuffer *eb, int quals) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendTemplArgExpr(CErrorBuffer *eb, void *targExpr) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendTemplArg(CErrorBuffer *eb, void *targ) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendTemplArgs(CErrorBuffer *eb, void *targs) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendNameSpace(CErrorBuffer *eb, void *ns) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendPType(CErrorBuffer *eb, void *ty) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendTemplDepType(CErrorBuffer *eb, void *ty) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendFuncArgs(CErrorBuffer *eb, void *args, unsigned char flag) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendType(CErrorBuffer *eb, void *ty, int quals) {
|
||||
|
||||
}
|
||||
|
||||
char *CError_GetTypeName(void *ty, int quals, unsigned char useGlobalHeap) {
|
||||
CErrorBuffer eb;
|
||||
char buf[256];
|
||||
char *ptr;
|
||||
|
||||
CError_BufferInit(&eb, buf, sizeof(buf));
|
||||
CError_BufferAppendType(&eb, ty, quals);
|
||||
CError_BufferTerminate(&eb);
|
||||
|
||||
if (useGlobalHeap)
|
||||
ptr = galloc(eb.size + 1);
|
||||
else
|
||||
ptr = lalloc(eb.size + 1);
|
||||
|
||||
return strcpy(ptr, eb.start);
|
||||
}
|
||||
|
||||
void CError_AppendUnqualFunctionName(CErrorBuffer *eb, void *unk1, void *unk2, void *unk3) {
|
||||
|
||||
}
|
||||
|
||||
void CError_AppendFunctionName(CErrorBuffer *eb, void *unk1, void *unk2, void *unk3, void *unk4) {
|
||||
|
||||
}
|
||||
|
||||
void CError_AppendObjectName(CErrorBuffer *eb, void *obj) {
|
||||
|
||||
}
|
||||
|
||||
void CError_AppendMethodName(CErrorBuffer *eb, void *obj) {
|
||||
|
||||
}
|
||||
|
||||
char *CError_GetQualifiedName(void *ns, StringNode *name) {
|
||||
CErrorBuffer eb;
|
||||
char buf[256];
|
||||
char *ptr;
|
||||
|
||||
CError_BufferInit(&eb, buf, sizeof(buf));
|
||||
CError_BufferAppendNameSpace(&eb, ns);
|
||||
CError_BufferAppendString(&eb, name->data);
|
||||
CError_BufferTerminate(&eb);
|
||||
|
||||
ptr = lalloc(eb.size + 1);
|
||||
return strcpy(ptr, eb.start);
|
||||
}
|
||||
|
||||
char *CError_GetFunctionName(void *a, void *b, void *c) {
|
||||
CErrorBuffer eb;
|
||||
char buf[256];
|
||||
char *ptr;
|
||||
|
||||
CError_BufferInit(&eb, buf, sizeof(buf));
|
||||
CError_AppendFunctionName(&eb, a, b, 0, c);
|
||||
CError_BufferTerminate(&eb);
|
||||
|
||||
ptr = lalloc(eb.size + 1);
|
||||
return strcpy(ptr, eb.start);
|
||||
}
|
||||
|
||||
char *CError_GetObjectName(void *obj) {
|
||||
CErrorBuffer eb;
|
||||
char buf[256];
|
||||
char *ptr;
|
||||
|
||||
CError_BufferInit(&eb, buf, sizeof(buf));
|
||||
CError_AppendObjectName(&eb, obj);
|
||||
CError_BufferTerminate(&eb);
|
||||
|
||||
ptr = lalloc(eb.size + 1);
|
||||
return strcpy(ptr, eb.start);
|
||||
}
|
||||
|
||||
char *CError_GetNameString(void *obj, StringNode *operatorName) {
|
||||
CErrorBuffer eb;
|
||||
char buf[256];
|
||||
char *ptr;
|
||||
char *opStr;
|
||||
|
||||
CError_ASSERT(operatorName);
|
||||
|
||||
// TODO lolol
|
||||
CError_BufferInit(&eb, buf, sizeof(buf));
|
||||
CError_AppendObjectName(&eb, obj);
|
||||
CError_BufferTerminate(&eb);
|
||||
|
||||
ptr = lalloc(eb.size + 1);
|
||||
return strcpy(ptr, eb.start);
|
||||
}
|
||||
|
||||
void CError_ErrorMessage(int errTable, char *buf, unsigned char flag1, unsigned char flag2) {
|
||||
|
||||
}
|
||||
|
||||
void CError_BufferAppendTemplateStack(CErrorBuffer *eb) {
|
||||
|
||||
}
|
||||
|
||||
void CError_ErrorMessageVA(short code, char *buf, va_list list, unsigned char flag1, unsigned char flag2) {
|
||||
|
||||
}
|
||||
|
||||
void CError_VAErrorMessage(short code, va_list list, unsigned char flag1, unsigned char flag2) {
|
||||
char buf[256];
|
||||
|
||||
CError_GetErrorString(buf, code);
|
||||
CError_ErrorMessageVA(code + 10000, buf, list, flag1, flag2);
|
||||
}
|
||||
|
||||
void CError_Error(short code, ...) {
|
||||
|
||||
}
|
||||
|
||||
void CError_ErrorTerm(short code) {
|
||||
CError_GetErrorString(string, code);
|
||||
CError_ErrorMessage(code + 10000, string, 0, 0);
|
||||
longjmp(errorreturn, 1);
|
||||
}
|
||||
|
||||
void CError_ErrorSkip(short code, ...) {
|
||||
// TODO trychain, tk
|
||||
}
|
||||
|
||||
void CError_ErrorFuncCall(short code, void *aa, void *bb) {
|
||||
|
||||
}
|
||||
|
||||
void CError_OverloadedFunctionError2(void *aa, void *bb, void *cc) {
|
||||
|
||||
}
|
||||
|
||||
void CError_OverloadedFunctionError(void *aa, void *bb) {
|
||||
|
||||
}
|
||||
|
||||
void CError_AbstractClassError() {
|
||||
// TODO CClass
|
||||
}
|
||||
|
||||
void CError_Warning(short code, ...) {
|
||||
// TODO lol
|
||||
}
|
||||
|
||||
void CError_BreakPoint(const char *a, const char *b) {
|
||||
if (!a || !strcmp(a, b))
|
||||
CError_BreakPointcount++;
|
||||
}
|
||||
|
||||
void CError_Internal(char *filename, int line) {
|
||||
char tmp[128];
|
||||
CompilerGetCString(5, tmp);
|
||||
sprintf(string, tmp, filename, line);
|
||||
CError_ErrorMessage(10001, string, 1, 0);
|
||||
longjmp(errorreturn, 1);
|
||||
CError_BreakPoint(0, 0);
|
||||
}
|
||||
|
||||
void CError_ExpressionTooComplex() {
|
||||
CompilerGetCString(6, string);
|
||||
CError_ErrorMessage(10002, string, 1, 0);
|
||||
longjmp(errorreturn, 1);
|
||||
}
|
||||
|
||||
void CError_NoMem() {
|
||||
cprep_nomem_exit = 1;
|
||||
longjmp(errorreturn, 1);
|
||||
}
|
||||
|
||||
void CError_UserBreak() {
|
||||
CompilerGetCString(8, string);
|
||||
longjmp(errorreturn, 1);
|
||||
}
|
||||
|
||||
void CError_CannotOpen() {
|
||||
// TODO
|
||||
}
|
||||
|
||||
void CError_QualifierCheck(int quals) {
|
||||
|
||||
}
|
||||
893
CInt64.c
Normal file
893
CInt64.c
Normal file
@ -0,0 +1,893 @@
|
||||
#include <MacHeadersMach-O>
|
||||
#include "CInt64.h"
|
||||
|
||||
const CInt64 cint64_negone = {0xFFFFFFFF, 0xFFFFFFFF};
|
||||
const CInt64 cint64_zero = {0, 0};
|
||||
const CInt64 cint64_one = {0, 1};
|
||||
const CInt64 cint64_max = {0x7FFFFFFF, 0xFFFFFFFF};
|
||||
const CInt64 cint64_min = {0x80000000, 0};
|
||||
|
||||
#define SHIFT_LEFT_ONE(a, b) do { a <<= 1; if (b & 0x80000000) { a |= 1; } b <<= 1; } while(0)
|
||||
|
||||
void CInt64_Init() {
|
||||
}
|
||||
|
||||
CInt64 CInt64_Not(CInt64 input) {
|
||||
CInt64 output;
|
||||
unsigned char c;
|
||||
|
||||
c = (input.a == 0 && input.b == 0);
|
||||
CInt64_SetLong(&output, c);
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Inv(CInt64 input) {
|
||||
CInt64 output;
|
||||
output.a = ~input.a;
|
||||
output.b = ~input.b;
|
||||
return output;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Add(CInt64 lhs, CInt64 rhs) {
|
||||
if (lhs.b & 0x80000000) {
|
||||
if (rhs.b & 0x80000000) {
|
||||
lhs.b += rhs.b;
|
||||
lhs.a += 1;
|
||||
} else {
|
||||
lhs.b += rhs.b;
|
||||
if (!(lhs.b & 0x80000000))
|
||||
lhs.a += 1;
|
||||
}
|
||||
} else {
|
||||
if (rhs.b & 0x80000000) {
|
||||
lhs.b += rhs.b;
|
||||
if (!(lhs.b & 0x80000000))
|
||||
lhs.a += 1;
|
||||
} else {
|
||||
lhs.b += rhs.b;
|
||||
}
|
||||
}
|
||||
lhs.a += rhs.a;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Neg(CInt64 input) {
|
||||
CInt64 result;
|
||||
result = CInt64_Add(CInt64_Inv(input), cint64_one);
|
||||
return result;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Sub(CInt64 lhs, CInt64 rhs) {
|
||||
lhs = CInt64_Add(lhs, CInt64_Neg(rhs));
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_MulU(CInt64 lhs, CInt64 rhs) {
|
||||
CInt64 result;
|
||||
CInt64 work1;
|
||||
unsigned long aaaa;
|
||||
unsigned long bbbb;
|
||||
unsigned long cccc;
|
||||
unsigned long dddd;
|
||||
unsigned long eeee;
|
||||
|
||||
aaaa = rhs.b;
|
||||
result.a = result.b = 0;
|
||||
bbbb = lhs.b;
|
||||
cccc = rhs.a;
|
||||
dddd = rhs.b;
|
||||
|
||||
while (bbbb != 0) {
|
||||
if (bbbb & 1) {
|
||||
work1.a = cccc;
|
||||
work1.b = dddd;
|
||||
result = CInt64_Add(result, work1);
|
||||
}
|
||||
cccc <<= 1;
|
||||
if (dddd & 0x80000000)
|
||||
cccc |= 1;
|
||||
dddd <<= 1;
|
||||
bbbb >>= 1;
|
||||
}
|
||||
|
||||
eeee = lhs.a;
|
||||
while (eeee != 0 && aaaa != 0) {
|
||||
if (eeee & 1)
|
||||
result.a += aaaa;
|
||||
aaaa <<= 1;
|
||||
eeee >>= 1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Mul(CInt64 lhs, CInt64 rhs) {
|
||||
if (CInt64_IsNegative(&rhs)) {
|
||||
if (CInt64_IsNegative(&lhs)) {
|
||||
return CInt64_MulU(CInt64_Neg(lhs), CInt64_Neg(rhs));
|
||||
}
|
||||
return CInt64_Neg(CInt64_MulU(lhs, CInt64_Neg(rhs)));
|
||||
}
|
||||
if (CInt64_IsNegative(&lhs)) {
|
||||
return CInt64_Neg(CInt64_MulU(CInt64_Neg(lhs), rhs));
|
||||
}
|
||||
return CInt64_MulU(lhs, rhs);
|
||||
}
|
||||
|
||||
void CInt64_DivMod(const CInt64 *lhs, const CInt64 *rhs, CInt64 *pDiv, CInt64 *pMod) {
|
||||
unsigned char bad;
|
||||
unsigned long workA;
|
||||
unsigned long workB;
|
||||
unsigned long leftA;
|
||||
unsigned long leftB;
|
||||
unsigned long rightA;
|
||||
unsigned long rightB;
|
||||
unsigned long outA;
|
||||
unsigned long outB;
|
||||
CInt64 work;
|
||||
int counter;
|
||||
|
||||
bad = (rhs->a == 0) && (rhs->b == 0);
|
||||
if (!bad) {
|
||||
workA = 0;
|
||||
workB = 0;
|
||||
leftA = lhs->a;
|
||||
leftB = lhs->b;
|
||||
rightA = rhs->a;
|
||||
rightB = rhs->b;
|
||||
outA = 0;
|
||||
outB = 0;
|
||||
counter = 0;
|
||||
|
||||
do {
|
||||
workA <<= 1;
|
||||
if (workB & 0x80000000)
|
||||
workA |= 1;
|
||||
workB <<= 1;
|
||||
if (leftA & 0x80000000)
|
||||
workB |= 1;
|
||||
leftA <<= 1;
|
||||
if (leftB & 0x80000000)
|
||||
leftA |= 1;
|
||||
leftB <<= 1;
|
||||
|
||||
outA <<= 1;
|
||||
if (outB & 0x80000000)
|
||||
outA |= 1;
|
||||
outB <<= 1;
|
||||
|
||||
if (workA <= rightA) {
|
||||
if (workA != rightA)
|
||||
continue;
|
||||
if (workB < rightB)
|
||||
continue;
|
||||
}
|
||||
|
||||
outB |= 1;
|
||||
|
||||
work.a = workA;
|
||||
work.b = workB;
|
||||
work = CInt64_Sub(work, *rhs);
|
||||
workA = work.a;
|
||||
workB = work.b;
|
||||
} while (++counter < 64);
|
||||
|
||||
if (pDiv) {
|
||||
pDiv->a = outA;
|
||||
pDiv->b = outB;
|
||||
}
|
||||
if (pMod) {
|
||||
pMod->a = workA;
|
||||
pMod->b = workB;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CInt64 CInt64_Div(CInt64 lhs, CInt64 rhs) {
|
||||
CInt64 result;
|
||||
if (CInt64_IsNegative(&rhs)) {
|
||||
rhs = CInt64_Neg(rhs);
|
||||
if (CInt64_IsNegative(&lhs)) {
|
||||
lhs = CInt64_Neg(lhs);
|
||||
CInt64_DivMod(&lhs, &rhs, &result, 0);
|
||||
return result;
|
||||
} else {
|
||||
CInt64_DivMod(&lhs, &rhs, &result, 0);
|
||||
return CInt64_Neg(result);
|
||||
}
|
||||
} else {
|
||||
if (CInt64_IsNegative(&lhs)) {
|
||||
lhs = CInt64_Neg(lhs);
|
||||
CInt64_DivMod(&lhs, &rhs, &result, 0);
|
||||
return CInt64_Neg(result);
|
||||
} else {
|
||||
CInt64_DivMod(&lhs, &rhs, &result, 0);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CInt64 CInt64_DivU(CInt64 lhs, CInt64 rhs) {
|
||||
CInt64 result;
|
||||
CInt64_DivMod(&lhs, &rhs, &result, 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Mod(CInt64 lhs, CInt64 rhs) {
|
||||
CInt64 result;
|
||||
if (CInt64_IsNegative(&lhs)) {
|
||||
lhs = CInt64_Neg(lhs);
|
||||
if (CInt64_IsNegative(&rhs))
|
||||
rhs = CInt64_Neg(rhs);
|
||||
CInt64_DivMod(&lhs, &rhs, 0, &result);
|
||||
return CInt64_Neg(result);
|
||||
} else {
|
||||
if (CInt64_IsNegative(&rhs))
|
||||
rhs = CInt64_Neg(rhs);
|
||||
CInt64_DivMod(&lhs, &rhs, 0, &result);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
CInt64 CInt64_ModU(CInt64 lhs, CInt64 rhs) {
|
||||
CInt64 result;
|
||||
CInt64_DivMod(&lhs, &rhs, 0, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Shl(CInt64 lhs, CInt64 rhs) {
|
||||
int counter;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
if (rhs.a == 0 && rhs.b < 64) {
|
||||
a = lhs.a;
|
||||
b = lhs.b;
|
||||
for (counter = rhs.b; counter != 0; --counter) {
|
||||
a <<= 1;
|
||||
if (b & 0x80000000)
|
||||
a |= 1;
|
||||
b <<= 1;
|
||||
}
|
||||
lhs.a = a;
|
||||
lhs.b = b;
|
||||
} else {
|
||||
lhs.a = 0;
|
||||
lhs.b = 0;
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Shr(CInt64 lhs, CInt64 rhs) {
|
||||
int counter;
|
||||
long a;
|
||||
unsigned long b;
|
||||
|
||||
if (rhs.a == 0 && rhs.b < 64) {
|
||||
a = lhs.a;
|
||||
b = lhs.b;
|
||||
for (counter = rhs.b; counter != 0; --counter) {
|
||||
b >>= 1;
|
||||
if (a & 1)
|
||||
b |= 0x80000000;
|
||||
a >>= 1;
|
||||
}
|
||||
lhs.a = a;
|
||||
lhs.b = b;
|
||||
} else {
|
||||
if (lhs.a & 0x80000000) {
|
||||
lhs.a = 0xFFFFFFFF;
|
||||
lhs.b = 0xFFFFFFFF;
|
||||
} else {
|
||||
lhs.a = 0;
|
||||
lhs.b = 0;
|
||||
}
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_ShrU(CInt64 lhs, CInt64 rhs) {
|
||||
int counter;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
if (rhs.a == 0 && rhs.b < 64) {
|
||||
a = lhs.a;
|
||||
b = lhs.b;
|
||||
for (counter = rhs.b; counter != 0; --counter) {
|
||||
b >>= 1;
|
||||
if (a & 1)
|
||||
b |= 0x80000000;
|
||||
a >>= 1;
|
||||
}
|
||||
lhs.a = a;
|
||||
lhs.b = b;
|
||||
} else {
|
||||
lhs.a = 0;
|
||||
lhs.b = 0;
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
|
||||
int CInt64_UnsignedCompare(const CInt64 *lhs, const CInt64 *rhs) {
|
||||
if (lhs->a == rhs->a) {
|
||||
if (lhs->b < rhs->b)
|
||||
return -1;
|
||||
else
|
||||
return lhs->b > rhs->b;
|
||||
} else {
|
||||
return ((unsigned long) lhs->a < rhs->a) ? -1 : 1;
|
||||
}
|
||||
}
|
||||
|
||||
int CInt64_SignedCompare(const CInt64 *lhs, const CInt64 *rhs) {
|
||||
CInt64 lhs_;
|
||||
CInt64 rhs_;
|
||||
|
||||
lhs_ = CInt64_Xor(*lhs, cint64_min);
|
||||
rhs_ = CInt64_Xor(*rhs, cint64_min);
|
||||
return CInt64_UnsignedCompare(&lhs_, &rhs_);
|
||||
}
|
||||
|
||||
unsigned char CInt64_Less(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_SignedCompare(&lhs, &rhs) < 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_LessU(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_UnsignedCompare(&lhs, &rhs) < 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_Greater(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_SignedCompare(&lhs, &rhs) > 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_GreaterU(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_UnsignedCompare(&lhs, &rhs) > 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_LessEqual(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_SignedCompare(&lhs, &rhs) <= 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_LessEqualU(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_UnsignedCompare(&lhs, &rhs) <= 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_GreaterEqual(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_SignedCompare(&lhs, &rhs) >= 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_GreaterEqualU(CInt64 lhs, CInt64 rhs) {
|
||||
return CInt64_UnsignedCompare(&lhs, &rhs) >= 0;
|
||||
}
|
||||
|
||||
unsigned char CInt64_Equal(CInt64 lhs, CInt64 rhs) {
|
||||
return lhs.a == rhs.a && lhs.b == rhs.b;
|
||||
}
|
||||
|
||||
unsigned char CInt64_NotEqual(CInt64 lhs, CInt64 rhs) {
|
||||
return lhs.a != rhs.a || lhs.b != rhs.b;
|
||||
}
|
||||
|
||||
unsigned char CInt64_IsInRange(CInt64 value, short len) {
|
||||
CInt64 bound;
|
||||
|
||||
if (value.a & 0x80000000) {
|
||||
switch (len) {
|
||||
case 1:
|
||||
bound.b = 0xFFFFFF80;
|
||||
bound.a = 0xFFFFFFFF;
|
||||
break;
|
||||
case 2:
|
||||
bound.b = 0xFFFF8000;
|
||||
bound.a = 0xFFFFFFFF;
|
||||
break;
|
||||
case 4:
|
||||
bound.b = 0x80000000;
|
||||
bound.a = 0xFFFFFFFF;
|
||||
break;
|
||||
case 8:
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return CInt64_GreaterEqual(value, bound);
|
||||
} else {
|
||||
switch (len) {
|
||||
case 1:
|
||||
bound.b = 0x7F;
|
||||
bound.a = 0;
|
||||
break;
|
||||
case 2:
|
||||
bound.b = 0x7FFF;
|
||||
bound.a = 0;
|
||||
break;
|
||||
case 4:
|
||||
bound.b = 0x7FFFFFFF;
|
||||
bound.a = 0;
|
||||
break;
|
||||
case 8:
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return CInt64_LessEqual(value, bound);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char CInt64_IsInURange(CInt64 value, short len) {
|
||||
switch (len) {
|
||||
case 1:
|
||||
return value.a == 0 && (value.b & 0xFFFFFF00) == 0;
|
||||
case 2:
|
||||
return value.a == 0 && (value.b & 0xFFFF0000) == 0;
|
||||
case 4:
|
||||
return value.a == 0;
|
||||
case 8:
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
CInt64 CInt64_And(CInt64 lhs, CInt64 rhs) {
|
||||
lhs.a &= rhs.a;
|
||||
lhs.b &= rhs.b;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Xor(CInt64 lhs, CInt64 rhs) {
|
||||
lhs.a ^= rhs.a;
|
||||
lhs.b ^= rhs.b;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
CInt64 CInt64_Or(CInt64 lhs, CInt64 rhs) {
|
||||
lhs.a |= rhs.a;
|
||||
lhs.b |= rhs.b;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
void CInt64_ConvertInt32(CInt64 *i) {
|
||||
CInt64_Extend32(i);
|
||||
}
|
||||
|
||||
void CInt64_ConvertUInt32(CInt64 *i) {
|
||||
CInt64_SetULong(i, (unsigned long) i->b);
|
||||
}
|
||||
|
||||
void CInt64_ConvertInt16(CInt64 *i) {
|
||||
i->b = (short) i->b;
|
||||
CInt64_Extend32(i);
|
||||
}
|
||||
|
||||
void CInt64_ConvertUInt16(CInt64 *i) {
|
||||
CInt64_SetULong(i, (unsigned short) i->b);
|
||||
}
|
||||
|
||||
void CInt64_ConvertInt8(CInt64 *i) {
|
||||
i->b = (char) i->b;
|
||||
CInt64_Extend32(i);
|
||||
}
|
||||
|
||||
void CInt64_ConvertUInt8(CInt64 *i) {
|
||||
CInt64_SetULong(i, (unsigned char) i->b);
|
||||
}
|
||||
|
||||
void CInt64_ConvertUFromLongDouble(CInt64 *pResult, double value) {
|
||||
union { float f; unsigned long l; } cvt;
|
||||
unsigned long a, b;
|
||||
float threshold;
|
||||
int bits;
|
||||
|
||||
if (value <= 0.0) {
|
||||
pResult->a = 0;
|
||||
pResult->b = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
cvt.l = 0x5F800000;
|
||||
if (value >= cvt.f) {
|
||||
pResult->a = 0xFFFFFFFF;
|
||||
pResult->b = 0xFFFFFFFF;
|
||||
return;
|
||||
}
|
||||
|
||||
a = b = 0;
|
||||
for (bits = 63; bits >= 0; bits--) {
|
||||
a <<= 1;
|
||||
if (b & 0x80000000)
|
||||
a |= 1;
|
||||
b <<= 1;
|
||||
|
||||
if ((short) bits == 0) {
|
||||
threshold = 1.0f;
|
||||
} else {
|
||||
cvt.l = (((short) bits + 127) & 255) << 23;
|
||||
threshold = cvt.f;
|
||||
}
|
||||
|
||||
if (threshold <= value) {
|
||||
b |= 1;
|
||||
value -= threshold;
|
||||
}
|
||||
}
|
||||
|
||||
pResult->a = a;
|
||||
pResult->b = b;
|
||||
}
|
||||
|
||||
void CInt64_ConvertFromLongDouble(CInt64 *pResult, double value) {
|
||||
if (value < 0.0) {
|
||||
CInt64_ConvertUFromLongDouble(pResult, -value);
|
||||
*pResult = CInt64_Neg(*pResult);
|
||||
} else {
|
||||
CInt64_ConvertUFromLongDouble(pResult, value);
|
||||
}
|
||||
}
|
||||
|
||||
double CInt64_ConvertUToLongDouble(const CInt64 *value) {
|
||||
unsigned char bad;
|
||||
unsigned long work;
|
||||
int counter;
|
||||
double result;
|
||||
|
||||
bad = (value->a == 0) && (value->b == 0);
|
||||
if (bad) {
|
||||
return 0.0;
|
||||
} else {
|
||||
result = 0.0;
|
||||
|
||||
work = value->a;
|
||||
if (work != 0) {
|
||||
for (counter = 0; counter < 32; counter++) {
|
||||
result += result;
|
||||
if (work & 0x80000000)
|
||||
result += 1.0;
|
||||
work <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
counter = 0;
|
||||
work = value->b;
|
||||
for (; counter < 32; counter++) {
|
||||
result += result;
|
||||
if (work & 0x80000000)
|
||||
result += 1.0;
|
||||
work <<= 1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
double CInt64_ConvertToLongDouble(const CInt64 *value) {
|
||||
CInt64 tmp;
|
||||
if (value->a & 0x80000000) {
|
||||
tmp = CInt64_Neg(*value);
|
||||
return -CInt64_ConvertUToLongDouble(&tmp);
|
||||
} else {
|
||||
return CInt64_ConvertUToLongDouble(value);
|
||||
}
|
||||
}
|
||||
|
||||
char *CInt64_ScanOctString(CInt64 *pResult, char *str, unsigned char *pFail) {
|
||||
int ch;
|
||||
CInt64 tmp;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
*pFail = 0;
|
||||
pResult->a = pResult->b = 0;
|
||||
|
||||
while ((ch = *str) >= '0' && *str <= '7') {
|
||||
a = pResult->a;
|
||||
b = pResult->b;
|
||||
if (a & 0xE0000000)
|
||||
*pFail = 1;
|
||||
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
|
||||
pResult->a = a;
|
||||
pResult->b = b;
|
||||
|
||||
CInt64_SetLong(&tmp, ch - '0');
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
++str;
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
char *CInt64_ScanDecString(CInt64 *pResult, char *str, unsigned char *pFail) {
|
||||
int ch;
|
||||
CInt64 tmp;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
*pFail = 0;
|
||||
pResult->a = pResult->b = 0;
|
||||
|
||||
while ((ch = *str) >= '0' && *str <= '9') {
|
||||
a = pResult->a;
|
||||
b = pResult->b;
|
||||
if (a & 0xE0000000)
|
||||
*pFail = 1;
|
||||
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
tmp.a = a;
|
||||
tmp.b = b;
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
pResult->a = a;
|
||||
pResult->b = b;
|
||||
|
||||
if (CInt64_IsNegative(pResult)) {
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
if (!CInt64_IsNegative(pResult))
|
||||
*pFail = 1;
|
||||
} else {
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
}
|
||||
|
||||
CInt64_SetLong(&tmp, ch - '0');
|
||||
if (CInt64_IsNegative(pResult)) {
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
if (!CInt64_IsNegative(pResult))
|
||||
*pFail = 1;
|
||||
} else {
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
}
|
||||
|
||||
++str;
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
char *CInt64_ScanHexString(CInt64 *pResult, char *str, unsigned char *pFail) {
|
||||
/* NOT MATCHING */
|
||||
int digit;
|
||||
CInt64 tmp;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
*pFail = 0;
|
||||
pResult->a = pResult->b = 0;
|
||||
|
||||
for (;;) {
|
||||
if ((digit = str[0]) >= '0' && digit <= '9')
|
||||
digit = digit - '0';
|
||||
else if (digit >= 'A' && digit <= 'F')
|
||||
digit = digit - 'A' + 10;
|
||||
else if (digit >= 'a' && digit <= 'f')
|
||||
digit = digit - 'a' + 10;
|
||||
else
|
||||
break;
|
||||
|
||||
a = pResult->a;
|
||||
b = pResult->b;
|
||||
++str;
|
||||
|
||||
if (a & 0xF0000000)
|
||||
*pFail = 1;
|
||||
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
|
||||
pResult->a = a;
|
||||
pResult->b = b;
|
||||
|
||||
CInt64_SetLong(&tmp, (char) digit);
|
||||
*pResult = CInt64_Add(*pResult, tmp);
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
char *CInt64_ScanBinString(CInt64 *pResult, char *str, unsigned char *pFail) {
|
||||
char digit;
|
||||
unsigned long a;
|
||||
unsigned long b;
|
||||
|
||||
*pFail = 0;
|
||||
pResult->a = pResult->b = 0;
|
||||
|
||||
for (;;) {
|
||||
if (*str == '0')
|
||||
digit = 0;
|
||||
else if (*str == '1')
|
||||
digit = 1;
|
||||
else
|
||||
break;
|
||||
|
||||
a = pResult->a;
|
||||
b = pResult->b;
|
||||
++str;
|
||||
|
||||
if (a & 0x80000000)
|
||||
*pFail = 1;
|
||||
|
||||
SHIFT_LEFT_ONE(a, b);
|
||||
|
||||
pResult->a = a;
|
||||
pResult->b = b;
|
||||
|
||||
if (digit == 1)
|
||||
*pResult = CInt64_Add(*pResult, cint64_one);
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
char *CInt64_ScanAsmNumber(CInt64 *pResult, char *str, unsigned char *pFail) {
|
||||
unsigned char isMaybeBin;
|
||||
unsigned char isOct;
|
||||
unsigned char isMaybeDec;
|
||||
unsigned char isBin;
|
||||
char *p;
|
||||
|
||||
isMaybeBin = 1;
|
||||
isOct = *str == '0';
|
||||
isMaybeDec = 1;
|
||||
isBin = 0;
|
||||
p = str;
|
||||
|
||||
for (;;) {
|
||||
if (*p == 0)
|
||||
break;
|
||||
|
||||
if (strchr("01", p[0])) {
|
||||
if (isBin)
|
||||
isMaybeBin = 0;
|
||||
} else if (strchr("bB", p[0])) {
|
||||
isBin = 1;
|
||||
isMaybeDec = 0;
|
||||
isOct = 0;
|
||||
} else if (strchr("234567", p[0])) {
|
||||
isMaybeBin = 0;
|
||||
} else if (strchr("89", p[0])) {
|
||||
isOct = 0;
|
||||
isMaybeBin = 0;
|
||||
} else if (strchr("acdefACEDF", p[0])) {
|
||||
isMaybeDec = 0;
|
||||
isMaybeBin = 0;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
|
||||
++p;
|
||||
}
|
||||
|
||||
if (isMaybeBin && isBin) {
|
||||
return CInt64_ScanBinString(pResult, str, pFail) + 1;
|
||||
} else if (p[0] == 'h' || p[0] == 'H') {
|
||||
return CInt64_ScanHexString(pResult, str, pFail) + 1;
|
||||
} else if (isOct) {
|
||||
return CInt64_ScanOctString(pResult, str, pFail);
|
||||
} else if (isMaybeDec) {
|
||||
return CInt64_ScanDecString(pResult, str, pFail);
|
||||
} else {
|
||||
*pFail = 1;
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
int CInt64_PrintDec(char *output, CInt64 value) {
|
||||
int length;
|
||||
CInt64 rem;
|
||||
CInt64 divisor;
|
||||
char buf[40];
|
||||
char *bufp;
|
||||
|
||||
length = 0;
|
||||
if (CInt64_IsNegative(&value)) {
|
||||
value = CInt64_Neg(value);
|
||||
*output = '-';
|
||||
length++;
|
||||
output++;
|
||||
}
|
||||
|
||||
if (!CInt64_IsZero(&value)) {
|
||||
divisor.b = 10;
|
||||
divisor.a = 0;
|
||||
|
||||
bufp = buf;
|
||||
for (;;) {
|
||||
rem = CInt64_ModU(value, divisor);
|
||||
*(bufp++) = rem.b + '0';
|
||||
value = CInt64_DivU(value, divisor);
|
||||
if (CInt64_IsZero(&value) != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
while (--bufp >= buf) {
|
||||
*(output++) = *bufp;
|
||||
length++;
|
||||
}
|
||||
} else {
|
||||
*(output++) = '0';
|
||||
length++;
|
||||
}
|
||||
|
||||
*output = 0;
|
||||
return length;
|
||||
}
|
||||
|
||||
int CInt64_PrintHex(char *output, CInt64 value) {
|
||||
int length;
|
||||
CInt64 rem;
|
||||
CInt64 shift;
|
||||
CInt64 mask;
|
||||
char buf[32];
|
||||
char *bufp;
|
||||
|
||||
length = 0;
|
||||
if (!CInt64_IsZero(&value)) {
|
||||
shift.b = 4;
|
||||
shift.a = 0;
|
||||
mask.b = 0xF;
|
||||
mask.a = 0;
|
||||
|
||||
bufp = buf;
|
||||
for (;;) {
|
||||
rem = CInt64_And(value, mask);
|
||||
if ((long) rem.b >= 10)
|
||||
*(bufp++) = rem.b + 'A';
|
||||
else
|
||||
*(bufp++) = rem.b + '0';
|
||||
value = CInt64_ShrU(value, shift);
|
||||
if (CInt64_IsZero(&value) != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
while (--bufp >= buf) {
|
||||
*(output++) = *bufp;
|
||||
length++;
|
||||
}
|
||||
} else {
|
||||
*(output++) = '0';
|
||||
length++;
|
||||
}
|
||||
|
||||
*output = 0;
|
||||
return length;
|
||||
}
|
||||
|
||||
int CInt64_PrintBin(char *output, CInt64 value) {
|
||||
int length;
|
||||
CInt64 rem;
|
||||
char buf[64];
|
||||
char *bufp;
|
||||
|
||||
length = 0;
|
||||
if (!CInt64_IsZero(&value)) {
|
||||
bufp = buf;
|
||||
for (;;) {
|
||||
rem = CInt64_And(value, cint64_one);
|
||||
if (CInt64_Equal(rem, cint64_one))
|
||||
*(bufp++) = '1';
|
||||
else
|
||||
*(bufp++) = '0';
|
||||
value = CInt64_ShrU(value, cint64_one);
|
||||
if (CInt64_IsZero(&value) != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
while (--bufp >= buf) {
|
||||
*(output++) = *bufp;
|
||||
length++;
|
||||
}
|
||||
} else {
|
||||
*(output++) = '0';
|
||||
length++;
|
||||
}
|
||||
|
||||
*output = 0;
|
||||
return length;
|
||||
}
|
||||
85
CInt64.h
Normal file
85
CInt64.h
Normal file
@ -0,0 +1,85 @@
|
||||
#pragma once
|
||||
|
||||
typedef struct _CInt64 {
|
||||
long a;
|
||||
unsigned long b;
|
||||
} CInt64;
|
||||
|
||||
// make sure this is in the right place
|
||||
extern const CInt64 cint64_negone;
|
||||
extern const CInt64 cint64_zero;
|
||||
extern const CInt64 cint64_one;
|
||||
extern const CInt64 cint64_max;
|
||||
extern const CInt64 cint64_min;
|
||||
|
||||
inline int CInt64_IsNegative(const CInt64 *n) {
|
||||
return (n->a & 0x80000000) != 0;
|
||||
}
|
||||
inline void CInt64_SetLong(CInt64 *pN, long n) {
|
||||
pN->b = n;
|
||||
pN->a = (n < 0) ? 0xFFFFFFFF : 0;
|
||||
}
|
||||
inline void CInt64_SetULong(CInt64 *pN, unsigned long n) {
|
||||
pN->b = n;
|
||||
pN->a = 0;
|
||||
}
|
||||
|
||||
// i don't think this one is real lol
|
||||
inline int CInt64_IsZero(CInt64 *n) {
|
||||
return n->a == 0 && n->b == 0;
|
||||
}
|
||||
inline void CInt64_Extend32(CInt64 *n) { // assumed name
|
||||
n->a = (n->b >> 31) ? 0xFFFFFFFF : 0;
|
||||
}
|
||||
|
||||
extern void CInt64_Init();
|
||||
extern CInt64 CInt64_Not(CInt64 input);
|
||||
extern CInt64 CInt64_Inv(CInt64 input);
|
||||
extern CInt64 CInt64_Add(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Neg(CInt64 input);
|
||||
extern CInt64 CInt64_Sub(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_MulU(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Mul(CInt64 lhs, CInt64 rhs);
|
||||
extern void CInt64_DivMod(const CInt64 *lhs, const CInt64 *rhs, CInt64 *pDiv, CInt64 *pMod);
|
||||
extern CInt64 CInt64_Div(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_DivU(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Mod(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_ModU(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Shl(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Shr(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_ShrU(CInt64 lhs, CInt64 rhs);
|
||||
extern int CInt64_UnsignedCompare(const CInt64 *lhs, const CInt64 *rhs);
|
||||
extern int CInt64_SignedCompare(const CInt64 *lhs, const CInt64 *rhs);
|
||||
extern unsigned char CInt64_Less(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_LessU(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_Greater(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_GreaterU(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_LessEqual(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_LessEqualU(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_GreaterEqual(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_GreaterEqualU(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_Equal(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_NotEqual(CInt64 lhs, CInt64 rhs);
|
||||
extern unsigned char CInt64_IsInRange(CInt64 value, short len);
|
||||
extern unsigned char CInt64_IsInURange(CInt64 value, short len);
|
||||
extern CInt64 CInt64_And(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Xor(CInt64 lhs, CInt64 rhs);
|
||||
extern CInt64 CInt64_Or(CInt64 lhs, CInt64 rhs);
|
||||
extern void CInt64_ConvertInt32(CInt64 *i);
|
||||
extern void CInt64_ConvertUInt32(CInt64 *i);
|
||||
extern void CInt64_ConvertInt16(CInt64 *i);
|
||||
extern void CInt64_ConvertUInt16(CInt64 *i);
|
||||
extern void CInt64_ConvertInt8(CInt64 *i);
|
||||
extern void CInt64_ConvertUInt8(CInt64 *i);
|
||||
extern void CInt64_ConvertUFromLongDouble(CInt64 *pResult, double value);
|
||||
extern void CInt64_ConvertFromLongDouble(CInt64 *pResult, double value);
|
||||
extern double CInt64_ConvertUToLongDouble(const CInt64 *value);
|
||||
extern double CInt64_ConvertToLongDouble(const CInt64 *value);
|
||||
extern char *CInt64_ScanOctString(CInt64 *pResult, char *str, unsigned char *pFail);
|
||||
extern char *CInt64_ScanDecString(CInt64 *pResult, char *str, unsigned char *pFail);
|
||||
extern char *CInt64_ScanHexString(CInt64 *pResult, char *str, unsigned char *pFail);
|
||||
extern char *CInt64_ScanBinString(CInt64 *pResult, char *str, unsigned char *pFail);
|
||||
extern char *CInt64_ScanAsmNumber(CInt64 *pResult, char *str, unsigned char *pFail);
|
||||
extern int CInt64_PrintDec(char *output, CInt64 value);
|
||||
extern int CInt64_PrintHex(char *output, CInt64 value);
|
||||
extern int CInt64_PrintBin(char *output, CInt64 value);
|
||||
1230
CompilerTools.c
Normal file
1230
CompilerTools.c
Normal file
File diff suppressed because it is too large
Load Diff
134
CompilerTools.h
Normal file
134
CompilerTools.h
Normal file
@ -0,0 +1,134 @@
|
||||
#include "mwcc_decomp.h"
|
||||
#pragma once
|
||||
|
||||
extern void CompilerGetPString(short index, unsigned char *str);
|
||||
extern void CompilerGetCString(short index, char *str);
|
||||
extern unsigned char *CTool_CtoPstr(char *input);
|
||||
|
||||
typedef struct _AllocatorBlock {
|
||||
struct _AllocatorBlock *nextBlock;
|
||||
char **handle;
|
||||
long size;
|
||||
long remaining;
|
||||
} AllocatorBlock;
|
||||
|
||||
typedef struct _Allocator {
|
||||
AllocatorBlock *blockList;
|
||||
long paddingSize;
|
||||
AllocatorBlock *lastBlockUsed;
|
||||
void *ptrToFreeArea;
|
||||
long remaining;
|
||||
} Allocator;
|
||||
|
||||
typedef struct _HeapInfo {
|
||||
long _0;
|
||||
long _4;
|
||||
long _8;
|
||||
long xx_C;
|
||||
long _10;
|
||||
long _14;
|
||||
long _18;
|
||||
} HeapInfo;
|
||||
|
||||
typedef struct _StringNode {
|
||||
struct _StringNode *next;
|
||||
long index;
|
||||
short hash;
|
||||
char data[1];
|
||||
} StringNode;
|
||||
|
||||
typedef struct _GList {
|
||||
char **data;
|
||||
long size;
|
||||
long capacity;
|
||||
long expansion;
|
||||
} GList;
|
||||
|
||||
extern long hash_name_id;
|
||||
extern StringNode **name_hash_nodes;
|
||||
extern void (*GListErrorProc)();
|
||||
|
||||
// extern void GListError();
|
||||
extern int InitGList(GList *list, long capacity);
|
||||
extern void FreeGList(GList *list);
|
||||
extern void LockGList(GList *list);
|
||||
extern void UnlockGList(GList *list);
|
||||
extern void ShrinkGList(GList *list);
|
||||
extern void AppendGListData(GList *list, const void *data, long size);
|
||||
extern void AppendGListNoData(GList *list, long size);
|
||||
extern void AppendGListByte(GList *list, char v);
|
||||
extern void AppendGListWord(GList *list, short v);
|
||||
extern void AppendGListTargetEndianWord(GList *list, short v);
|
||||
extern void AppendGListLong(GList *list, long v);
|
||||
extern void AppendGListTargetEndianLong(GList *list, long v);
|
||||
extern void AppendGListID(GList *list, const char *str);
|
||||
extern void AppendGListName(GList *list, const char *str);
|
||||
extern void RemoveGListData(GList *list, long size);
|
||||
extern char GetGListByte(GList *list);
|
||||
extern short GetGListWord(GList *list);
|
||||
extern long GetGListLong(GList *list);
|
||||
extern short GetGListID(GList *list, char *buf);
|
||||
extern void GetGListData(GList *list, char *buf, long size);
|
||||
// extern long hashpjw(const char *str);
|
||||
// extern short PHash(const unsigned char *str);
|
||||
extern short CHash(const char *str);
|
||||
extern StringNode *GetHashNameNode(const char *str);
|
||||
extern StringNode *GetHashNameNodeHash(const char *str, short hash);
|
||||
extern StringNode *GetHashNameNodeHash2(const char *str, short hash);
|
||||
extern StringNode *GetHashNameNodeExport(const char *str);
|
||||
extern long GetHashNameNodeExportID(StringNode *node);
|
||||
extern StringNode *GetHashNameNodeByID(long id);
|
||||
extern void NameHashExportReset();
|
||||
extern void NameHashWriteNameTable(GList *list);
|
||||
extern void NameHashWriteTargetEndianNameTable(GList *list);
|
||||
extern void InitNameHash();
|
||||
|
||||
typedef void (*heaperror_t)();
|
||||
|
||||
extern long CTool_TotalHeapSize();
|
||||
// extern void getheapinfo(HeapInfo *result, Allocator *heap);
|
||||
extern void CTool_GetHeapInfo(HeapInfo *result, unsigned char heapID);
|
||||
// extern void MoreHeapSpace(Allocator *alloc, long size);
|
||||
extern int initheaps(heaperror_t failureCallback);
|
||||
extern int initgheap(heaperror_t failureCallback);
|
||||
extern heaperror_t getheaperror();
|
||||
extern void setheaperror(heaperror_t failureCallback);
|
||||
// extern void relheap(Allocator *alloc);
|
||||
extern void releaseheaps();
|
||||
extern void releasegheap();
|
||||
extern void releaseoheap();
|
||||
extern char *galloc(long size);
|
||||
extern char *lalloc(long size);
|
||||
extern char *aalloc(long size);
|
||||
extern char *oalloc(long size);
|
||||
extern char *balloc(long size);
|
||||
|
||||
extern void locklheap();
|
||||
extern void unlocklheap();
|
||||
extern void freelheap();
|
||||
extern void freeaheap();
|
||||
extern void freeoheap();
|
||||
extern void freebheap();
|
||||
|
||||
extern char *ScanHex(char *str, long *output, Boolean *overflow);
|
||||
extern char *ScanOct(char *str, long *output, Boolean *overflow);
|
||||
extern char *ScanDec(char *str, long *output, Boolean *overflow);
|
||||
|
||||
// extern char *UnmangleClassname(char *work, char **pNameStart, short *pNameLength, char **a4, short *a5, Boolean a6);
|
||||
// extern char *UnmangleAppend(char *src, char srcLen, char **pOutput, short *pOutputLen);
|
||||
extern void OldUnmangle(char *input, char *output, Boolean flag);
|
||||
|
||||
extern short hash(char *str);
|
||||
extern void memclr(void *buffer, long size);
|
||||
extern void memclrw(void *buffer, long size);
|
||||
extern void CToLowercase(char *src, char *dst);
|
||||
extern int getbit(long v);
|
||||
typedef struct {
|
||||
unsigned long a, b;
|
||||
} WtfWord64; // this has to make sense, somehow... but how?
|
||||
extern void CTool_EndianConvertWord64(WtfWord64 value, unsigned long long *p);
|
||||
extern unsigned short CTool_EndianConvertInPlaceWord16Ptr(unsigned short *p);
|
||||
extern unsigned long CTool_EndianConvertInPlaceWord32Ptr(unsigned long *p);
|
||||
extern void CTool_EndianConvertVector128(); // not correct but idc
|
||||
extern StringNode *CTool_GetPathName(const FSSpec *spec, long *mdDat);
|
||||
extern Boolean strcat_safe(char *dst, const char *src, int maxLen);
|
||||
564
Help.c
Normal file
564
Help.c
Normal file
@ -0,0 +1,564 @@
|
||||
#include "mwcc_decomp.h"
|
||||
typedef struct _Side {
|
||||
short offset;
|
||||
short width;
|
||||
char buffer[1024];
|
||||
short bptr;
|
||||
short blen;
|
||||
short indent;
|
||||
short vrow;
|
||||
short vcol;
|
||||
unsigned char atEOL;
|
||||
unsigned char impInd;
|
||||
} Side;
|
||||
|
||||
short helpExtras;
|
||||
unsigned char showedHelp;
|
||||
Side left;
|
||||
Side right;
|
||||
Side all;
|
||||
char **helptext;
|
||||
static char outLine[256];
|
||||
|
||||
static void Help_Output(Side *left, Side *right);
|
||||
static void Help_OutputSingle(Side *all);
|
||||
static void Help_Flush();
|
||||
|
||||
static void Side_Init(Side *s, short offset, short width) {
|
||||
memset(s, 0, sizeof(Side));
|
||||
s->offset = offset;
|
||||
s->width = width;
|
||||
}
|
||||
|
||||
static void Side_Print(Side *s, const char *format, ...) {
|
||||
char c;
|
||||
char *text;
|
||||
char buffer[1024];
|
||||
va_list args;
|
||||
|
||||
va_start(args, format);
|
||||
vsprintf(buffer, format, args);
|
||||
va_end(args);
|
||||
|
||||
text = buffer;
|
||||
while (*text) {
|
||||
if (s->blen < 1024) {
|
||||
c = *(text++);
|
||||
if (c == '~' && *text == '~') {
|
||||
c = *MAINOPTCHAR;
|
||||
text++;
|
||||
}
|
||||
|
||||
s->buffer[(s->bptr + s->blen) & 1023] = c;
|
||||
s->blen++;
|
||||
} else {
|
||||
if (s == &left)
|
||||
Help_Output(&left, &right);
|
||||
else
|
||||
Help_OutputSingle(&all);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void Side_NewLine(Side *s) {
|
||||
Side_Print(s, "\n");
|
||||
}
|
||||
|
||||
static void Side_Indent(Side *s, short how) {
|
||||
if ((s->width - s->indent - how) > (parseopts.ioCols / 8))
|
||||
s->indent += how;
|
||||
else if ((s->width - s->indent - 1) > (parseopts.ioCols / 10))
|
||||
s->indent++;
|
||||
}
|
||||
|
||||
static void Side_Outdent(Side *s, short how) {
|
||||
if ((s->width - s->indent) < (parseopts.ioCols / 8))
|
||||
s->indent++;
|
||||
else if (s->indent >= how)
|
||||
s->indent -= how;
|
||||
}
|
||||
|
||||
static unsigned char isBreaker(char c) {
|
||||
return (c == 10) || (c == 13) || (c == 32) || (c == 9) || (c == 8) || (c == '|');
|
||||
}
|
||||
|
||||
static void Side_DumpLine(Side *s) {
|
||||
short col;
|
||||
short len;
|
||||
short afterspace;
|
||||
short eol;
|
||||
short ind;
|
||||
char c;
|
||||
|
||||
eol = 0;
|
||||
ind = 0;
|
||||
col = s->offset + s->indent;
|
||||
s->vcol = s->indent;
|
||||
len = 0;
|
||||
afterspace = s->width - s->indent;
|
||||
|
||||
while (s->blen > 0 && s->vcol < s->width && !eol && !ind) {
|
||||
c = s->buffer[s->bptr];
|
||||
outLine[col + len] = c;
|
||||
s->vcol++;
|
||||
len++;
|
||||
|
||||
if (isBreaker(c)) {
|
||||
afterspace = len;
|
||||
eol = (c == '\n') || (c == '\r');
|
||||
eol += (c == '\r');
|
||||
ind = (c == '\b') || (c == '\t');
|
||||
ind += (c == '\b');
|
||||
}
|
||||
|
||||
s->bptr = (s->bptr + 1) & 1023;
|
||||
s->blen--;
|
||||
}
|
||||
|
||||
if (s->blen || eol || ind) {
|
||||
s->blen += len - afterspace;
|
||||
s->bptr = (s->bptr - (len - afterspace)) & 1023;
|
||||
if (eol || ind) {
|
||||
len++;
|
||||
afterspace--;
|
||||
}
|
||||
|
||||
while (len > afterspace) {
|
||||
outLine[col + --len] = ' ';
|
||||
}
|
||||
}
|
||||
|
||||
s->vcol = 0;
|
||||
s->vrow++;
|
||||
s->atEOL = (eol == 1) || ind || !s->blen;
|
||||
if ((s->atEOL || ind) && s->impInd) {
|
||||
Side_Outdent(s, parseopts.ioCols / 40);
|
||||
s->impInd = 0;
|
||||
}
|
||||
if (ind) {
|
||||
if (ind == 1)
|
||||
Side_Indent(s, parseopts.ioCols / 25);
|
||||
else
|
||||
Side_Outdent(s, parseopts.ioCols / 25);
|
||||
} else if (!s->atEOL && s != &all && !s->impInd) {
|
||||
Side_Indent(s, parseopts.ioCols / 40);
|
||||
s->impInd = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void Help_PrintLine() {
|
||||
HPrintF(helptext, "%.*s\n", parseopts.ioCols - 1, outLine);
|
||||
}
|
||||
|
||||
static void Help_Output(Side *left, Side *right) {
|
||||
while (left->blen || right->blen) {
|
||||
memset(outLine, ' ', parseopts.ioCols);
|
||||
outLine[left->offset + left->width + 1] = '#';
|
||||
if (left->atEOL && right->atEOL)
|
||||
left->atEOL = right->atEOL = 0;
|
||||
if (!left->atEOL)
|
||||
Side_DumpLine(left);
|
||||
if (!right->atEOL)
|
||||
Side_DumpLine(right);
|
||||
Help_PrintLine();
|
||||
}
|
||||
}
|
||||
|
||||
static void Help_OutputSingle(Side *all) {
|
||||
while (all->blen) {
|
||||
memset(outLine, ' ', parseopts.ioCols);
|
||||
if (all->atEOL)
|
||||
all->atEOL = 0;
|
||||
if (!all->atEOL)
|
||||
Side_DumpLine(all);
|
||||
Help_PrintLine();
|
||||
}
|
||||
}
|
||||
|
||||
static void Help_Flush() {
|
||||
Help_Output(&left, &right);
|
||||
}
|
||||
|
||||
static void Help_NewLine() {
|
||||
Side_NewLine(&left);
|
||||
Side_NewLine(&right);
|
||||
}
|
||||
|
||||
int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const char *keyword) {
|
||||
char pfbuf[512];
|
||||
char slflags;
|
||||
int listFlags;
|
||||
Boolean allNoArgs;
|
||||
PARAM_T *lastparam;
|
||||
Boolean print;
|
||||
Boolean printMe;
|
||||
|
||||
if (!opt->names[0] && !(lst->flags & LISTFLAGS_4))
|
||||
return 0;
|
||||
|
||||
if (keyword && keyword[0] && !strstr(opt->names, keyword) && (!opt->help || !strstr(opt->help, keyword)))
|
||||
return 0;
|
||||
|
||||
if ((opt->avail & OTF_SECRET) && !(parseopts.helpFlags & HELPFLAGS_SECRET))
|
||||
return 0;
|
||||
|
||||
if ((opt->avail & OTF_OBSOLETE) && !(parseopts.helpFlags & HELPFLAGS_OBSOLETE))
|
||||
return 0;
|
||||
|
||||
if ((opt->avail & OTF_DEPRECATED) && !(parseopts.helpFlags & HELPFLAGS_DEPRECATED))
|
||||
return 0;
|
||||
|
||||
if ((opt->avail & OTF_IGNORED) && !(parseopts.helpFlags & HELPFLAGS_IGNORED))
|
||||
return 0;
|
||||
|
||||
if ((opt->avail & OTF_MEANINGLESS) && !(parseopts.helpFlags & HELPFLAGS_MEANINGLESS))
|
||||
return 0;
|
||||
|
||||
if (!(parseopts.helpFlags & HELPFLAGS_NORMAL) && !(opt->avail & OTF_ALL_HIDDEN_BY_DEFAULT))
|
||||
return 0;
|
||||
|
||||
if (opt->help || (opt->avail & OTF8000)) {
|
||||
allNoArgs = 1;
|
||||
lastparam = 0;
|
||||
if (parseopts.helpFlags & HELPFLAGS_SPACES)
|
||||
Help_NewLine();
|
||||
if ((opt->avail & OTF_GLOBAL) && !subprint)
|
||||
Side_Print(&right, "global; ");
|
||||
if (compat != 1 && (opt->avail & OTF_CASED))
|
||||
Side_Print(&right, "cased; ");
|
||||
|
||||
slflags = (subprint == 0) ? SLFLAGS_1 : SLFLAGS_2;
|
||||
switch (opt->avail & OTF_SLFLAGS_MASK) {
|
||||
case OTF_SLFLAGS_8:
|
||||
slflags = slflags | SLFLAGS_8;
|
||||
break;
|
||||
case OTF_SLFLAGS_10:
|
||||
slflags = slflags | SLFLAGS_10;
|
||||
break;
|
||||
case OTF_SLFLAGS_20:
|
||||
slflags = slflags | SLFLAGS_20;
|
||||
break;
|
||||
}
|
||||
if (opt->avail & OTF2)
|
||||
slflags = slflags | SLFLAGS_40;
|
||||
|
||||
Utils_SpellList(opt->names[0] ? opt->names : "...", pfbuf, slflags);
|
||||
Side_Print(&left, pfbuf);
|
||||
|
||||
if (opt->avail & OTF_OBSOLETE)
|
||||
Side_Print(&right, "obsolete;\r");
|
||||
if (opt->avail & OTF_COMPATIBILITY)
|
||||
Side_Print(&right, "compatibility;\r");
|
||||
if (opt->avail & OTF_IGNORED)
|
||||
Side_Print(&right, "ignored;\r");
|
||||
|
||||
listFlags = ((lst->flags & LISTFLAGS_COMPILER) ? OTF_TOOL_COMPILER : 0) | ((lst->flags & LISTFLAGS_LINKER) ? OTF_TOOL_LINKER : 0) | ((lst->flags & LISTFLAGS_DISASSEMBLER) ? OTF_TOOL_DISASSEMBLER : 0);
|
||||
if (!Option_ForThisTool(opt) || Option_AlsoPassedFromThisTool(opt) || listFlags != Option_ThisTool()) {
|
||||
print = 0;
|
||||
printMe = 1;
|
||||
if ((opt->avail & OTF_TOOL_MASK) != (unsigned int) listFlags)
|
||||
print = 1;
|
||||
if (Option_ForThisTool(opt) && Option_AlsoPassedFromThisTool(opt))
|
||||
printMe = 0;
|
||||
|
||||
if (print) {
|
||||
char opttool[64] = ""; // stack 0x44
|
||||
if ((opt->avail & OTF_TOOL_MASK) == (unsigned int) OTF_TOOL_MASK) {
|
||||
strcat(opttool, "all tools");
|
||||
} else {
|
||||
if (Option_ForTool(opt, OTF_TOOL_COMPILER) && ((Option_ThisTool() != (unsigned int) OTF_TOOL_COMPILER) || printMe)) {
|
||||
strcat(opttool, "this tool");
|
||||
}
|
||||
if (Option_ForTool(opt, OTF_TOOL_LINKER) && ((Option_ThisTool() != (unsigned int) OTF_TOOL_LINKER) || printMe)) {
|
||||
if (opttool[0])
|
||||
strcat(opttool, ", ");
|
||||
strcat(opttool, "linker");
|
||||
}
|
||||
if (Option_ForTool(opt, OTF_TOOL_DISASSEMBLER) && ((Option_ThisTool() != (unsigned int) OTF_TOOL_DISASSEMBLER) || printMe)) {
|
||||
if (opttool[0])
|
||||
strcat(opttool, ", ");
|
||||
strcat(opttool, "disassembler");
|
||||
}
|
||||
if (!Option_ForTool(opt, OTF_TOOL_MASK))
|
||||
strcat(opttool, "another tool");
|
||||
}
|
||||
|
||||
if (printMe || !Option_ForThisTool(opt)) {
|
||||
Side_Print(&right, "for %s;\r", opttool);
|
||||
} else if (parseopts.passingArgs) {
|
||||
Side_Print(&right, "passed to %s;\r", opttool);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (opt->avail & OTF_WARNING)
|
||||
Side_Print(&right, "warning:\r");
|
||||
|
||||
if (opt->avail & OTF_DEPRECATED)
|
||||
Side_Print(&right, "deprecated;\rinstead use ");
|
||||
else if (opt->avail & OTF_SUBSTITUTED)
|
||||
Side_Print(&right, "substituted with ");
|
||||
|
||||
if (opt->help)
|
||||
Side_Print(&right, "%s", opt->help);
|
||||
|
||||
if (opt->param && !(opt->avail & OTF_IGNORED)) {
|
||||
PARAM_T *scan = opt->param;
|
||||
PARAM_T *firstparam = 0;
|
||||
const char *desc;
|
||||
const char *help;
|
||||
const char *defaul;
|
||||
while (scan) {
|
||||
if ((scan->flags & PARAMFLAGS_3) != PARAMFLAGS_1) {
|
||||
if (!firstparam)
|
||||
firstparam = scan;
|
||||
|
||||
allNoArgs = 0;
|
||||
Param_DescHelp(scan, &desc, &help, &defaul);
|
||||
if (desc) {
|
||||
if (((scan->flags & PARAMFLAGS_3) == PARAMFLAGS_2) && scan->which != PARAMWHICH_Setting && scan->which != PARAMWHICH_IfArg) {
|
||||
if (SEPOPTSTR[0] == ' ') {
|
||||
Side_Print(&left, (scan != firstparam) ? "[," : subprint ? "[=" : " [");
|
||||
} else {
|
||||
Side_Print(&left, "[%s", (scan != firstparam) ? "," : subprint ? "=" : SEPOPTSTR);
|
||||
}
|
||||
} else {
|
||||
Side_Print(&left, (scan != firstparam) ? "," : subprint ? "=" : ((opt->avail & OTF2) && !strchr(opt->names, '|')) ? "" : SEPOPTSTR);
|
||||
}
|
||||
Side_Print(&left, "%s", desc);
|
||||
if (((scan->flags & PARAMFLAGS_3) == PARAMFLAGS_2) && scan->which != PARAMWHICH_Setting && scan->which != PARAMWHICH_IfArg) {
|
||||
Side_Print(&left, "]");
|
||||
}
|
||||
if (help) {
|
||||
if ((scan->flags & PARAMFLAGS_3) != PARAMFLAGS_2)
|
||||
Side_Print(&right, "; for '%s', %s", desc, help);
|
||||
else
|
||||
Side_Print(&right, "; if parameter specified, %s", help);
|
||||
}
|
||||
if (defaul && !(opt->avail & OTF2000)) {
|
||||
if (firstparam == scan)
|
||||
Side_Print(&right, "; default is %s", defaul);
|
||||
else
|
||||
Side_Print(&right, ",%s", defaul);
|
||||
}
|
||||
}
|
||||
}
|
||||
lastparam = scan;
|
||||
scan = scan->next;
|
||||
}
|
||||
|
||||
if (allNoArgs && !(opt->avail & OTF2000)) {
|
||||
PARAM_T *scan = opt->param;
|
||||
Boolean isdefault = scan ? 1 : 0;
|
||||
while (scan && isdefault) {
|
||||
isdefault &= Param_Compare(scan);
|
||||
scan = scan->next;
|
||||
}
|
||||
|
||||
if (isdefault)
|
||||
Side_Print(&right, "; default");
|
||||
}
|
||||
}
|
||||
|
||||
if (opt->avail & OTF_MEANINGLESS)
|
||||
Side_Print(&right, "; meaningless for this target");
|
||||
|
||||
if ((opt->avail & OTF8000) && opt->sub) {
|
||||
if (!allNoArgs) {
|
||||
Side_Print(
|
||||
&left,
|
||||
"%s",
|
||||
(opt->avail & OTF10000) ? ((lastparam->flags & PARAMFLAGS_8) ? "[=" : "[,") : ((lastparam->flags & PARAMFLAGS_8) ? "," : "=")
|
||||
);
|
||||
} else if (!(opt->avail & OTF2)) {
|
||||
if (opt->avail & OTF10000) {
|
||||
if (SEPOPTSTR[0] == ' ')
|
||||
Side_Print(&left, subprint ? "[=" : " [");
|
||||
else
|
||||
Side_Print(&left, "[%s", subprint ? "=" : SEPOPTSTR);
|
||||
} else {
|
||||
Side_Print(&left, "%c", subprint ? '=' : SEPOPTSTR[0]);
|
||||
}
|
||||
} else {
|
||||
if (opt->avail & OTF10000) {
|
||||
Side_Print(&left, subprint ? "[" : (SEPOPTSTR[0] == ' ') ? " [" : "[");
|
||||
}
|
||||
}
|
||||
|
||||
Side_Print(
|
||||
&left,
|
||||
"%s%s%s",
|
||||
opt->sub->help ? opt->sub->help : "keyword",
|
||||
(opt->sub->flags & PARAMFLAGS_1) ? "" : "[,...]",
|
||||
(opt->avail & OTF10000) ? "]" : ""
|
||||
);
|
||||
|
||||
Side_Print(&left, "\t");
|
||||
Side_Print(&right, "\t");
|
||||
Help_Options(opt->sub, 1, "");
|
||||
Side_Print(&left, "\b");
|
||||
Side_Print(&right, "\b");
|
||||
} else {
|
||||
Side_Print(&left, "\n");
|
||||
Side_Print(&right, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
Help_Flush();
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int IsCompiler() {
|
||||
return (Option_ThisTool() == (unsigned int) OTF_TOOL_COMPILER) ? LISTFLAGS_COMPILER : LISTFLAGS_LINKER;
|
||||
}
|
||||
|
||||
void Help_Options(struct OptionList *lst, int subprint, const char *keyword) {
|
||||
Option **opts;
|
||||
int toolflags;
|
||||
Boolean show;
|
||||
|
||||
opts = lst->list;
|
||||
toolflags = 0;
|
||||
if (Option_ThisTool() == (unsigned int) OTF_TOOL_COMPILER) {
|
||||
toolflags |= LISTFLAGS_COMPILER;
|
||||
} else {
|
||||
toolflags |= LISTFLAGS_LINKER;
|
||||
}
|
||||
|
||||
// review me maybe?
|
||||
if (!subprint && (parseopts.helpFlags & HELPFLAGS_TOOL)) {
|
||||
if ((parseopts.helpFlags & HELPFLAGS_TOOL_BOTH) == HELPFLAGS_TOOL_THIS && (lst->flags & LISTFLAGS_TOOL_MASK) && !(lst->flags & toolflags))
|
||||
return;
|
||||
if ((parseopts.helpFlags & HELPFLAGS_TOOL_BOTH) == HELPFLAGS_TOOL_OTHER && (((lst->flags & LISTFLAGS_TOOL_MASK) == (unsigned int) toolflags) || ((lst->flags & LISTFLAGS_TOOL_MASK) == (unsigned int) LISTFLAGS_NONE)))
|
||||
return;
|
||||
}
|
||||
|
||||
if (lst->help && !subprint && opts[0]) {
|
||||
Help_Line('-');
|
||||
Side_Print(&all, "%s", lst->help);
|
||||
Help_OutputSingle(&all);
|
||||
Help_Line('-');
|
||||
}
|
||||
|
||||
while (*opts) {
|
||||
show = 0;
|
||||
if (!(parseopts.helpFlags & HELPFLAGS_TOOL)) {
|
||||
if (((parseopts.helpFlags & HELPFLAGS_TOOL_BOTH) == HELPFLAGS_TOOL_BOTH) && (parseopts.passingArgs ? (Option_ForTool(*opts, OTF_TOOL_LINKER) || Option_ForTool(*opts, OTF_TOOL_DISASSEMBLER)) : 1) && Option_ForThisTool(*opts))
|
||||
show = 1;
|
||||
} else if ((parseopts.helpFlags & HELPFLAGS_TOOL_BOTH) == HELPFLAGS_TOOL_BOTH) {
|
||||
show = 1;
|
||||
} else if ((parseopts.helpFlags & HELPFLAGS_TOOL_THIS) && Option_ForThisTool(*opts)) {
|
||||
show = 1;
|
||||
} else if ((parseopts.helpFlags & HELPFLAGS_TOOL_OTHER) && !Option_ForThisTool(*opts)) {
|
||||
show = 1;
|
||||
} else if ((parseopts.helpFlags & HELPFLAGS_TOOL_OTHER) && Option_ForTool(*opts, ~Option_ThisTool() & OTF_TOOL_MASK)) {
|
||||
show = 1;
|
||||
}
|
||||
|
||||
if (show)
|
||||
Help_Option(lst, *opts, subprint, keyword);
|
||||
|
||||
++opts;
|
||||
}
|
||||
|
||||
if (subprint && (parseopts.helpFlags & HELPFLAGS_SPACES))
|
||||
Help_NewLine();
|
||||
Help_Flush();
|
||||
if (!subprint)
|
||||
HPrintF(helptext, "\n");
|
||||
}
|
||||
|
||||
void Help_Usage() {
|
||||
Side_Print(
|
||||
&all,
|
||||
"\tGuide to help:\b"
|
||||
"\tWhen an option is specified as '~~xxx | yy[y] | zzz', then either '~~xxx', '~~yy', '~~yyy', or '~~zzz' matches the option.\b"
|
||||
"\tAn option given as '~~[no]xxx' may be given as '~~xxx' or '~~noxxx'; '~~noxxx' reverses the meaning of the option.\b"
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
|
||||
Side_Print(
|
||||
&all,
|
||||
"\tFor most options, the option and the parameters are separated by a %sspace. When the option's name is '~~xxx+', however, the parameter must directly follow the option, without the '+' (as in '~~xxx45').\b",
|
||||
(compat != 1) ? "" : "colon or "
|
||||
);
|
||||
Side_Print(
|
||||
&all,
|
||||
"\tA parameter included in brackets '[]' is optional. An ellipsis '...' indicates that the previous type of parameter may be repeated as a list.\b"
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
|
||||
Side_Print(
|
||||
&all,
|
||||
"\t%s-- \"compatability\" indicates that the option is borrowed from another vendor's tool and may only approximate its counterpart.\r"
|
||||
"-- \"global\" indicates that the option has an effect over the entire command line and is parsed before any other options. When several global options are specified, they are interpreted in order.\r"
|
||||
"-- \"deprecated\" indicates that the option will be eliminated in the future and should not be used any longer. An alternative form is supplied.\r",
|
||||
(compat != 1) ? "-- \"cased\" indicates that the option is case-sensitive. By default, no options are case-sensitive.\r" : "");
|
||||
Help_OutputSingle(&all);
|
||||
|
||||
Side_Print(
|
||||
&all,
|
||||
"-- \"ignored\" means the option will be accepted but has no effect on the tool.\r"
|
||||
"-- \"meaningless\" means the option is accepted but probably has no meaning for the target OS.\r"
|
||||
"-- \"obsolete\" means the option was once deprecated and is now gone.\r"
|
||||
"-- \"substituted\" means the option has the same effect as another. This points out a preferred form and prevents confusion when similar options appear in the help.\r"
|
||||
"-- \"default\" in the help text indicates that the given value or variation of an option will be used unless otherwise overridden. \b"
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
|
||||
Side_Print(
|
||||
&all,
|
||||
"\tThe symbols ',' %s separate options and parameters unconditionally; to include one of these symbols in a parameter or filename, escape it (e.g., as '\\,' in mwcc file.c\\,v).\b\n",
|
||||
(compat != 1) ? "and '='" : ", ':', and '='"
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
|
||||
if (parseopts.passingArgs && pTool->TYPE == CWDROPINCOMPILERTYPE)
|
||||
Side_Print(
|
||||
&all,
|
||||
"\tThis tool calls the linker (unless a compiler option such as ~~c prevents it) and understands linker options -- use '~~help tool=other' to see them. Options marked \"passed to linker\" are used by the compiler and the linker; options marked \"for linker\" are used only by the linker. When using the compiler and linker separately, you must pass the common options to both.\b\n"
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
}
|
||||
|
||||
void Help_Null() {
|
||||
Side_Print(&all,
|
||||
"%s [options, filenames...]\n\nExecute '%s %shelp' for more information.",
|
||||
OS_GetFileNamePtr(parseopts.args->argv[0]),
|
||||
OS_GetFileNamePtr(parseopts.args->argv[0]),
|
||||
MAINOPTCHAR
|
||||
);
|
||||
Help_OutputSingle(&all);
|
||||
}
|
||||
|
||||
void Help_Init() {
|
||||
short lb;
|
||||
short le;
|
||||
short rb;
|
||||
short re;
|
||||
|
||||
if (!(helptext = NewHandle(0))) {
|
||||
fprintf(stderr, "\n*** Out of memory\n");
|
||||
exit(-23);
|
||||
}
|
||||
|
||||
lb = parseopts.ioCols / 40;
|
||||
le = (parseopts.ioCols / 3) + lb;
|
||||
rb = le + 3 + ((parseopts.ioCols / 60) & ~1);
|
||||
re = parseopts.ioCols - 1;
|
||||
Side_Init(&left, lb, le - lb);
|
||||
Side_Init(&right, rb, re - rb);
|
||||
Side_Init(&all, 0, re);
|
||||
}
|
||||
|
||||
void Help_Line(char ch) {
|
||||
char line[256];
|
||||
memset(line, ch, 255);
|
||||
line[255] = 0;
|
||||
HPrintF(helptext, "%.*s\n", parseopts.ioCols - 1, line);
|
||||
}
|
||||
|
||||
void Help_Term() {
|
||||
ShowTextHandle(0, helptext);
|
||||
DisposeHandle(helptext);
|
||||
}
|
||||
630
Option.c
Normal file
630
Option.c
Normal file
@ -0,0 +1,630 @@
|
||||
#include "mwcc_decomp.h"
|
||||
|
||||
#define OPTION_ASSERT(cond) do { if (!(cond)) { printf("%s:%u: failed assertion\n", __FILE__, __LINE__); abort(); } } while(0)
|
||||
|
||||
#define MAXSTACK 8
|
||||
|
||||
int oStackPtr;
|
||||
Opt48 oStack[8];
|
||||
char curopt[1024];
|
||||
int maxlegalset;
|
||||
int numlegalset;
|
||||
int numinternalset;
|
||||
static OptionList legalset;
|
||||
static OptionList internalset;
|
||||
int numoptionlists;
|
||||
static OptionList *optionlists[32];
|
||||
|
||||
enum {
|
||||
ARGFLAG_1 = 1,
|
||||
ARGFLAG_2 = 2,
|
||||
ARGFLAG_4 = 4,
|
||||
ARGFLAG_8 = 8,
|
||||
ARGFLAG_10 = 0x10,
|
||||
ARGFLAG_20 = 0x20,
|
||||
ARGFLAG_40 = 0x40,
|
||||
ARGFLAG_80 = 0x80
|
||||
};
|
||||
|
||||
enum {
|
||||
ARGSPELLFLAG_1 = 1,
|
||||
ARGSPELLFLAG_2 = 2,
|
||||
ARGSPELLFLAG_4 = 4,
|
||||
ARGSPELLFLAG_8 = 8,
|
||||
ARGSPELLFLAG_10 = 0x10,
|
||||
ARGSPELLFLAG_20 = 0x20,
|
||||
ARGSPELLFLAG_40 = 0x40,
|
||||
ARGSPELLFLAG_80 = 0x80
|
||||
};
|
||||
|
||||
enum {
|
||||
OPTSPELLFLAG_1 = 1,
|
||||
OPTSPELLFLAG_2 = 2,
|
||||
OPTSPELLFLAG_4 = 4,
|
||||
OPTSPELLFLAG_8 = 8,
|
||||
OPTSPELLFLAG_10 = 0x10,
|
||||
OPTSPELLFLAG_20 = 0x20,
|
||||
OPTSPELLFLAG_40 = 0x40,
|
||||
OPTSPELLFLAG_80 = 0x80
|
||||
};
|
||||
|
||||
static void Option_PushList(OptionList *lst) {
|
||||
Args_Push(1, lst, 0);
|
||||
}
|
||||
|
||||
static void Option_PushOpt(Option *opt, const char *optname) {
|
||||
char *cpy;
|
||||
short flags = ARGFLAG_2;
|
||||
if (opt && (opt->avail & OTF2)) {
|
||||
if (Utils_CompareOptionString(opt->names, optname, opt->avail & OTF_CASED, OTF2)) {
|
||||
flags |= ARGFLAG_80;
|
||||
}
|
||||
}
|
||||
cpy = xstrdup(optname);
|
||||
Args_Push(flags, opt, cpy);
|
||||
}
|
||||
|
||||
static void Option_PopOpt(char *optname) {
|
||||
Opt48 *os = Args_Pop(ARGFLAG_2);
|
||||
if (optname)
|
||||
strcpy(optname, os->e.o.curopt);
|
||||
free(os->e.o.curopt);
|
||||
}
|
||||
|
||||
static void Option_PopList() {
|
||||
Args_Pop(ARGFLAG_1);
|
||||
}
|
||||
|
||||
void Args_InitStack() {
|
||||
oStackPtr = 0;
|
||||
}
|
||||
int Args_StackSize() {
|
||||
return oStackPtr;
|
||||
}
|
||||
|
||||
void Args_Push(short flags, void *first, void *second) {
|
||||
#line 104
|
||||
OPTION_ASSERT(oStackPtr<MAXSTACK);
|
||||
if (oStackPtr > 0)
|
||||
{
|
||||
short prev =
|
||||
(flags & ARGFLAG_1) ? ARGFLAG_2 :
|
||||
(flags & ARGFLAG_2) ? ARGFLAG_1 :
|
||||
(flags & ARGFLAG_4) ? ARGFLAG_2 : -1;
|
||||
OPTION_ASSERT(oStack[oStackPtr-1].flags & prev);
|
||||
}
|
||||
|
||||
oStack[oStackPtr].e.v.first = first;
|
||||
oStack[oStackPtr].e.v.second = second;
|
||||
oStack[oStackPtr].flags = flags;
|
||||
oStackPtr++;
|
||||
}
|
||||
|
||||
Opt48 *Args_Pop(short flags)
|
||||
{
|
||||
OPTION_ASSERT(oStackPtr>0);
|
||||
--oStackPtr;
|
||||
OPTION_ASSERT(oStack[oStackPtr].flags & flags);
|
||||
return &oStack[oStackPtr];
|
||||
}
|
||||
|
||||
void Args_SpellStack(char *buffer, short flags) {
|
||||
char *bptr;
|
||||
Opt48 *os;
|
||||
int sp;
|
||||
int level;
|
||||
|
||||
bptr = buffer;
|
||||
sp = 0;
|
||||
level = 0;
|
||||
os = &oStack[sp];
|
||||
|
||||
while (sp < oStackPtr) {
|
||||
if (!flags || !(os->flags & ARGFLAG_20)) {
|
||||
if (os->flags & ARGFLAG_4) {
|
||||
Opt48 *po = os - 1;
|
||||
if (!(os[-1].flags & ARGFLAG_40)) {
|
||||
if ((level == 1 || level == 2) && !(po->flags & ARGFLAG_80))
|
||||
*(bptr++) = (flags & ARGSPELLFLAG_20) ? '\n' : ' ';
|
||||
os[-1].flags |= ARGFLAG_40;
|
||||
} else if (level == 2) {
|
||||
*(bptr++) = ',';
|
||||
} else if (level == 3) {
|
||||
*(bptr++) = '=';
|
||||
}
|
||||
strcpy(bptr, os->e.param);
|
||||
bptr += strlen(bptr);
|
||||
} else if (os->flags & ARGFLAG_2) {
|
||||
if (level == 1) {
|
||||
*(bptr++) = MAINOPTCHAR[0];
|
||||
} else if (level == 2) {
|
||||
Opt48 *po = os - 2;
|
||||
if (!(os[-1].flags & ARGFLAG_40) && !(po->flags & ARGFLAG_80))
|
||||
*(bptr++) = (flags & ARGSPELLFLAG_20) ? '\n' : ' ';
|
||||
}
|
||||
|
||||
if (os[-1].flags & ARGFLAG_40) {
|
||||
if (level == 2) {
|
||||
if (flags & ARGSPELLFLAG_20)
|
||||
*(bptr++) = ',';
|
||||
else
|
||||
*(bptr++) = ' ';
|
||||
}
|
||||
} else {
|
||||
if (level == 3) {
|
||||
*(bptr++) = '=';
|
||||
}
|
||||
}
|
||||
|
||||
os[-1].flags |= ARGFLAG_40;
|
||||
strcpy(bptr, os->e.o.curopt);
|
||||
bptr += strlen(bptr);
|
||||
}
|
||||
|
||||
if (flags & ARGSPELLFLAG_20)
|
||||
os->flags |= ARGFLAG_20;
|
||||
}
|
||||
|
||||
if (os->flags & ARGFLAG_1)
|
||||
level++;
|
||||
|
||||
++sp;
|
||||
++os;
|
||||
}
|
||||
}
|
||||
|
||||
void Args_AddToToolArgs(anon0_50 *ta) {
|
||||
char buffer[4096];
|
||||
char *nptr;
|
||||
|
||||
Args_SpellStack(buffer, ARGSPELLFLAG_20);
|
||||
nptr = strchr(buffer, '\n');
|
||||
if (nptr) {
|
||||
*(nptr++) = 0;
|
||||
Arg_AddToToolArgs(ta, 2, buffer);
|
||||
Arg_AddToToolArgs(ta, 1, 0);
|
||||
} else {
|
||||
nptr = buffer;
|
||||
}
|
||||
Arg_AddToToolArgs(ta, 2, nptr);
|
||||
}
|
||||
|
||||
void Options_Init() {
|
||||
numoptionlists = 0;
|
||||
maxlegalset = 0;
|
||||
numlegalset = 0;
|
||||
numinternalset = 0;
|
||||
|
||||
if (legalset.list)
|
||||
free(legalset.list);
|
||||
if (internalset.list)
|
||||
free(internalset.list);
|
||||
|
||||
legalset.list = 0;
|
||||
legalset.flags =
|
||||
((Option_ThisTool() & OTF_TOOL_COMPILER) ? LISTFLAGS_COMPILER : 0) |
|
||||
((Option_ThisTool() & OTF_TOOL_LINKER) ? LISTFLAGS_LINKER : 0) |
|
||||
((Option_ThisTool() & OTF_TOOL_DISASSEMBLER) ? LISTFLAGS_DISASSEMBLER : 0);
|
||||
internalset.list = 0;
|
||||
internalset.flags =
|
||||
((Option_ThisTool() & OTF_TOOL_COMPILER) ? LISTFLAGS_COMPILER : 0) |
|
||||
((Option_ThisTool() & OTF_TOOL_LINKER) ? LISTFLAGS_LINKER : 0) |
|
||||
((Option_ThisTool() & OTF_TOOL_DISASSEMBLER) ? LISTFLAGS_DISASSEMBLER : 0);
|
||||
|
||||
Args_InitStack();
|
||||
}
|
||||
|
||||
OptionList *Options_GetOptions() {
|
||||
return &legalset;
|
||||
}
|
||||
|
||||
void Options_SortOptions() {
|
||||
int r;
|
||||
|
||||
if (numinternalset > 0) {
|
||||
legalset.list = (Option **) xrealloc("options", legalset.list, sizeof(Option *) * (numinternalset + 1));
|
||||
for (r = 0; r < numinternalset; r++) {
|
||||
if (internalset.list[r]->avail & (OTF2 | OTF_CASED))
|
||||
legalset.list[numlegalset++] = internalset.list[r];
|
||||
}
|
||||
for (r = 0; r < numinternalset; r++) {
|
||||
if (!(internalset.list[r]->avail & (OTF2 | OTF_CASED)))
|
||||
legalset.list[numlegalset++] = internalset.list[r];
|
||||
}
|
||||
legalset.list[numlegalset] = 0;
|
||||
|
||||
if (internalset.list)
|
||||
free(internalset.list);
|
||||
internalset.list = 0;
|
||||
numinternalset = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void Options_AddOption(Option *opt) {
|
||||
if (numinternalset >= maxlegalset) {
|
||||
maxlegalset += 32;
|
||||
internalset.list = (Option **) xrealloc("options", internalset.list, sizeof(Option *) * (maxlegalset + 1));
|
||||
}
|
||||
|
||||
internalset.list[numinternalset++] = opt;
|
||||
internalset.list[numinternalset] = 0;
|
||||
}
|
||||
|
||||
int Options_AddList(OptionList *optlst) {
|
||||
Option **ptr;
|
||||
|
||||
if (numoptionlists >= 32)
|
||||
CLPFatalError("Too many option lists defined!");
|
||||
|
||||
optionlists[numoptionlists++] = optlst;
|
||||
for (ptr = optlst->list; *ptr; ptr++)
|
||||
Options_AddOption(*ptr);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int Options_AddLists(OptionList **optlst) {
|
||||
int ret = 1;
|
||||
OptionList **ptr;
|
||||
|
||||
for (ptr = optlst; *ptr; ptr++) {
|
||||
ret = Options_AddList(*ptr);
|
||||
if (!ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void Options_Reset(OptionList *optlst) {
|
||||
Option **os;
|
||||
|
||||
os = optlst->list;
|
||||
if (os) {
|
||||
for (; *os; os++) {
|
||||
(*os)->avail &= ~(OTF80000000 | OTF40000000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void Option_SpellList(char *buffer, OptionList *conflicts, int flags) {
|
||||
// r25: buffer
|
||||
// r0: conflicts
|
||||
// r26: flags
|
||||
|
||||
Option **scan; // r30
|
||||
Boolean first; // r29
|
||||
int total; // r28
|
||||
char tmp[256]; // stack 0x58
|
||||
Option **next; // r27
|
||||
int slflags; // r6
|
||||
|
||||
scan = conflicts->list;
|
||||
first = 1;
|
||||
total = 0;
|
||||
while (*scan) {
|
||||
next = scan + 1;
|
||||
if (!((*scan)->avail & (((parseopts.helpFlags & HELPFLAGS_SECRET) ? 0 : OTF_SECRET) | ((parseopts.helpFlags & HELPFLAGS_DEPRECATED) ? 0 : OTF_DEPRECATED) | OTF_SUBSTITUTED)) && (*scan)->names[0]) {
|
||||
// 17C1BC
|
||||
if (!first)
|
||||
buffer += sprintf(buffer, ", ");
|
||||
if (first)
|
||||
first = 0;
|
||||
|
||||
if (total > 1) {
|
||||
while (*next && (((*next)->avail & (((parseopts.helpFlags & HELPFLAGS_SECRET) ? 0 : OTF_SECRET) | ((parseopts.helpFlags & HELPFLAGS_DEPRECATED) ? 0 : OTF_DEPRECATED) | OTF_SUBSTITUTED)) || !(*next)->names[0])) {
|
||||
++next;
|
||||
}
|
||||
|
||||
if (!*next)
|
||||
buffer += sprintf(buffer, "or ");
|
||||
}
|
||||
|
||||
slflags = (flags & OPTSPELLFLAG_2) ? SLFLAGS_2 : SLFLAGS_1;
|
||||
switch ((*scan)->avail & OTF_SLFLAGS_MASK) {
|
||||
case OTF_SLFLAGS_8:
|
||||
slflags |= SLFLAGS_8;
|
||||
break;
|
||||
case OTF_SLFLAGS_20:
|
||||
slflags |= SLFLAGS_20;
|
||||
break;
|
||||
case OTF_SLFLAGS_10:
|
||||
slflags |= SLFLAGS_10;
|
||||
break;
|
||||
}
|
||||
|
||||
Utils_SpellList((*scan)->names, tmp, slflags);
|
||||
total++;
|
||||
buffer += sprintf(buffer, "%s", tmp);
|
||||
|
||||
if ((*scan)->avail & OTF8000)
|
||||
buffer += sprintf(buffer, " ...");
|
||||
}
|
||||
scan++;
|
||||
}
|
||||
}
|
||||
|
||||
int Option_ForTool(Option *opt, int which) {
|
||||
return !which || (opt->avail & which);
|
||||
}
|
||||
|
||||
int Option_ThisTool() {
|
||||
return (pTool->TYPE == CWDROPINCOMPILERTYPE) ? OTF_TOOL_COMPILER : OTF_TOOL_LINKER;
|
||||
}
|
||||
|
||||
int Option_ForThisTool(Option *opt) {
|
||||
return !Option_ForTool(opt, OTF_TOOL_MASK) || Option_ForTool(opt, Option_ThisTool());
|
||||
}
|
||||
|
||||
int Option_AlsoPassedToTool(Option *opt, int which) {
|
||||
return Option_ForThisTool(opt) && Option_ForTool(opt, which);
|
||||
}
|
||||
|
||||
int Option_AlsoPassedFromThisTool(Option *opt) {
|
||||
return Option_ForThisTool(opt) && Option_ForTool(opt, ~Option_ThisTool() & OTF_TOOL_MASK);
|
||||
}
|
||||
|
||||
static Boolean Option_ContinuesThisLevel(int level, ArgToken *tok) {
|
||||
// tok: r30
|
||||
ArgToken *tmp; // r0
|
||||
int ret; // not in stabs but i think this exists
|
||||
|
||||
if (level == 1) {
|
||||
return (tok->val == ATK_1) || (tok->val == ATK_3) || (tok->val == ATK_2);
|
||||
} else if (level == 2) {
|
||||
tmp = Arg_UsedToken();
|
||||
ret = (tok->val == ATK_5 && tmp->val != ATK_3) || (tok->val == ATK_2 && tmp->val != ATK_1);
|
||||
Arg_UndoToken();
|
||||
return ret;
|
||||
} else if (level == 3) {
|
||||
return (tok->val == ATK_4) || (tok->val == ATK_2);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static short endingStack[5][3];
|
||||
static Boolean Option_IsEndingThisLevel(int level, ArgToken *tok) {
|
||||
// level, tok: r0
|
||||
ArgToken *tmp; // r0
|
||||
|
||||
if (!tok)
|
||||
return 0;
|
||||
// todo
|
||||
}
|
||||
|
||||
static Boolean Option_IsEndingLevel(int level, ArgToken *tok) {
|
||||
// level: r30
|
||||
// tok: r31
|
||||
}
|
||||
|
||||
int Option_Parse(Option *opt, int oflags) {
|
||||
// opt: r24
|
||||
// oflags: r25
|
||||
int ret; // r29
|
||||
int pushed; // r28
|
||||
int samelevel; // r30
|
||||
int subparse; // r27
|
||||
int flags; // r26
|
||||
char errstr[1024]; // stack 0x3C
|
||||
Option **cscan; // r30
|
||||
Option **scan; // r5
|
||||
int goingtosubparse; // r30
|
||||
ArgToken *tok; // r0
|
||||
}
|
||||
|
||||
static int Option_MatchString(char *list, char *str, int flags, int *result) {
|
||||
// list: r26
|
||||
// str: r27
|
||||
// flags: r0
|
||||
// result: r28
|
||||
int str_len; // r0
|
||||
char cpy[64]; // stack 0x3C
|
||||
}
|
||||
|
||||
static Option *Option_Lookup(OptionList *search, int unk, int *flags) {
|
||||
// search: r0
|
||||
// flags: r25
|
||||
Option **os; // r29
|
||||
Option *stickyopt; // r28
|
||||
int stickyflags; // r27
|
||||
Boolean matched; // r0
|
||||
char *names; // r26
|
||||
}
|
||||
|
||||
static int Options_DoParse(OptionList *search, int flags) {
|
||||
// search: r26
|
||||
// flags: r28
|
||||
int haderrors; // r30
|
||||
int parsedany; // r23
|
||||
int failed; // r24
|
||||
int matchflags; // stack 0x3C
|
||||
int subparse; // r20
|
||||
ArgToken *starttok; // r0
|
||||
ArgToken *tok; // r25
|
||||
ArgToken *opttok; // r27
|
||||
Option *opt; // r16
|
||||
Boolean isOpt; // r0
|
||||
char *lptr; // r17
|
||||
char *optname; // r16
|
||||
char saveopt[1024]; // stack 0xBC
|
||||
// Option *opt; // r3
|
||||
// char saveopt[64]; // stack 0x7C
|
||||
// ArgToken *prev; // r0
|
||||
// char sticky[64]; // stack 0x3C
|
||||
// ArgToken *prev; // r16
|
||||
}
|
||||
|
||||
int Options_Parse(OptionList *options, int flags) {
|
||||
// options: r30
|
||||
// flags: r31
|
||||
int ret; // r31
|
||||
char savecuropt[64]; // stack 0x3C
|
||||
|
||||
Options_Reset(options);
|
||||
Option_PushList(options);
|
||||
|
||||
if (!(flags & 2)) {
|
||||
ret = Options_DoParse(options, flags);
|
||||
if (Option_ThisTool() == OTF_TOOL_COMPILER)
|
||||
Arg_AddToToolArgs(&linkargs, 1, 0);
|
||||
} else {
|
||||
strcpy(savecuropt, curopt);
|
||||
ret = Options_DoParse(options, flags);
|
||||
strcpy(curopt, savecuropt);
|
||||
}
|
||||
|
||||
Option_PopList();
|
||||
return ret;
|
||||
}
|
||||
|
||||
int Option_ParseDefaultOption(OptionList *options) {
|
||||
// options: r31
|
||||
int ret; // r31
|
||||
Option *dopt; // r0
|
||||
int matchflags; // 0x3C
|
||||
|
||||
Options_Reset(options);
|
||||
Option_PushList(options);
|
||||
|
||||
strcpy(curopt, "defaultoptions");
|
||||
dopt = Option_Lookup(options, 0, &matchflags);
|
||||
if (!dopt) {
|
||||
CLPFatalError("Default options not defined");
|
||||
ret = 1;
|
||||
} else {
|
||||
ret = Option_Parse(dopt, 0);
|
||||
}
|
||||
|
||||
Option_PopList();
|
||||
return ret;
|
||||
}
|
||||
|
||||
void Option_ParamError(short id, va_list ap) {
|
||||
char buf[4096];
|
||||
|
||||
CLPGetErrorString(id, buf);
|
||||
sprintf(&buf[strlen(buf)], "\nwhile parsing option '");
|
||||
Args_SpellStack(&buf[strlen(buf)], 0);
|
||||
sprintf(&buf[strlen(buf)], "'");
|
||||
CLPReportError_V(buf, ap);
|
||||
}
|
||||
|
||||
void Option_ParamWarning(short id, va_list ap) {
|
||||
char buf[1024];
|
||||
|
||||
CLPGetErrorString(id, buf);
|
||||
sprintf(&buf[strlen(buf)], "\nwhile parsing option '");
|
||||
Args_SpellStack(&buf[strlen(buf)], 0);
|
||||
sprintf(&buf[strlen(buf)], "'");
|
||||
CLPReportWarning_V(buf, ap);
|
||||
}
|
||||
|
||||
void Option_OptionError(short id, va_list ap) {
|
||||
char buf[1024];
|
||||
|
||||
CLPGetErrorString(id, buf);
|
||||
if (Args_StackSize() >= 2) {
|
||||
sprintf(&buf[strlen(buf)], "\nwhile parsing option '");
|
||||
Args_SpellStack(&buf[strlen(buf)], 0);
|
||||
sprintf(&buf[strlen(buf)], "'");
|
||||
}
|
||||
CLPReportError_V(buf, ap);
|
||||
}
|
||||
|
||||
void Option_OptionWarning(short id, va_list ap) {
|
||||
char buf[1024];
|
||||
|
||||
CLPGetErrorString(id, buf);
|
||||
if (Args_StackSize() >= 2) {
|
||||
sprintf(&buf[strlen(buf)], "\nwhile parsing option '");
|
||||
Args_SpellStack(&buf[strlen(buf)], 0);
|
||||
sprintf(&buf[strlen(buf)], "'");
|
||||
}
|
||||
CLPReportWarning_V(buf, ap);
|
||||
}
|
||||
|
||||
void Option_Error(short id, ...) {
|
||||
va_list va;
|
||||
va_start(va, id);
|
||||
Option_OptionError(id, va);
|
||||
va_end(va);
|
||||
}
|
||||
|
||||
void Option_Warning(short id, ...) {
|
||||
va_list va;
|
||||
va_start(va, id);
|
||||
Option_OptionWarning(id, va);
|
||||
va_end(va);
|
||||
}
|
||||
|
||||
int Options_Help(const char *keyword) {
|
||||
// keyword: r31
|
||||
int scan; // r26
|
||||
OptionList *lst; // r25
|
||||
|
||||
Help_Init();
|
||||
|
||||
if (parseopts.helpFlags & HELPFLAGS_USAGE) {
|
||||
ShowVersion(1);
|
||||
Help_Line('=');
|
||||
Help_Usage();
|
||||
} else {
|
||||
ShowVersion(1);
|
||||
for (scan = 0; scan < numoptionlists; scan++) {
|
||||
if ((lst = optionlists[scan])) {
|
||||
if (parseopts.helpFlags & HELPFLAGS_8000) {
|
||||
if (keyword && keyword[0] && lst->help && strstr(lst->help, keyword))
|
||||
Help_Options(lst, 0, "");
|
||||
} else {
|
||||
Help_Options(lst, 0, keyword);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Help_Term();
|
||||
return 1;
|
||||
}
|
||||
|
||||
int Option_Help(const char *opt) {
|
||||
// opt: r31
|
||||
Option *find; // r29
|
||||
int matchflags; // stack 0x3C
|
||||
int ret; // r29
|
||||
|
||||
find = 0;
|
||||
Option_PushList(Options_GetOptions());
|
||||
Option_PushOpt(0, "help");
|
||||
if (opt[0] == MAINOPTCHAR[0])
|
||||
strcpy(curopt, opt + 1);
|
||||
else
|
||||
strcpy(curopt, opt);
|
||||
|
||||
if (!curopt[1])
|
||||
find = Option_Lookup(Options_GetOptions(), 0x700002, &matchflags);
|
||||
if (!find)
|
||||
find = Option_Lookup(Options_GetOptions(), 0x700000, &matchflags);
|
||||
|
||||
if (find) {
|
||||
Help_Init();
|
||||
if (!Help_Option(Options_GetOptions(), find, 0, ""))
|
||||
CLPReportWarning(38, opt);
|
||||
Help_Term();
|
||||
ret = 1;
|
||||
} else {
|
||||
Option_Error(19, opt);
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
Option_PopOpt(curopt);
|
||||
Option_PopList();
|
||||
return ret;
|
||||
}
|
||||
|
||||
int Options_DisplayHelp() {
|
||||
if (parseopts.helpFlags & HELPFLAGS_1)
|
||||
Option_Help(parseopts.helpKey);
|
||||
else
|
||||
Options_Help(parseopts.helpKey);
|
||||
}
|
||||
286
PCode.c
Normal file
286
PCode.c
Normal file
@ -0,0 +1,286 @@
|
||||
#include "CompilerTools.h"
|
||||
#include "PCode.h"
|
||||
|
||||
// TODO RESOLVE ME
|
||||
extern void initialize_aliases();
|
||||
extern void *current_statement;
|
||||
extern PCode *vformatpcode(short op, va_list args);
|
||||
|
||||
PCBlock *pcbasicblocks;
|
||||
PCBlock *pclastblock;
|
||||
void *prologue;
|
||||
void *epilogue;
|
||||
PCBlock **depthfirstordering;
|
||||
int pcblockcount;
|
||||
int pcloopweight;
|
||||
static unsigned short pclabelcount;
|
||||
|
||||
void initpcode() {
|
||||
pclastblock = 0;
|
||||
pcbasicblocks = 0;
|
||||
pcblockcount = 0;
|
||||
pclabelcount = 0;
|
||||
pcloopweight = 1;
|
||||
initialize_aliases();
|
||||
}
|
||||
|
||||
PCode *makepcode(short op, ...) {
|
||||
PCode *pcode;
|
||||
va_list list;
|
||||
|
||||
va_start(list, op);
|
||||
pcode = vformatpcode(op, list);
|
||||
// TODO
|
||||
return pcode;
|
||||
}
|
||||
|
||||
void emitpcode(short op, ...) {
|
||||
PCode *pcode;
|
||||
va_list list;
|
||||
|
||||
va_start(list, op);
|
||||
pcode = vformatpcode(op, list);
|
||||
// TODO
|
||||
appendpcode(pclastblock, pcode);
|
||||
}
|
||||
|
||||
PCode *copypcode(PCode *pcode) {
|
||||
PCode *newpc;
|
||||
int flag;
|
||||
|
||||
flag = 0;
|
||||
// TODO
|
||||
|
||||
return newpc;
|
||||
}
|
||||
|
||||
PCLabel *makepclabel() {
|
||||
PCLabel *label;
|
||||
|
||||
label = (PCLabel *) lalloc(sizeof(PCLabel));
|
||||
memclrw(label, sizeof(PCLabel));
|
||||
label->index = pclabelcount++;
|
||||
return label;
|
||||
}
|
||||
|
||||
PCBlock *makepcblock() {
|
||||
PCBlock *block;
|
||||
|
||||
block = (PCBlock *) lalloc(sizeof(PCBlock));
|
||||
memclrw(block, sizeof(PCBlock));
|
||||
block->loopWeight = pcloopweight;
|
||||
block->blockIndex = pcblockcount++;
|
||||
if (pclastblock) {
|
||||
pclastblock->nextBlock = block;
|
||||
block->prevBlock = pclastblock;
|
||||
} else {
|
||||
pcbasicblocks = block;
|
||||
}
|
||||
pclastblock = block;
|
||||
return block;
|
||||
}
|
||||
|
||||
void pclabel(PCBlock *block, PCLabel *label) {
|
||||
PCLink *iter;
|
||||
PCLink *next;
|
||||
|
||||
iter = (PCLink *) label->block;
|
||||
while (iter) {
|
||||
next = (PCLink *) iter->block;
|
||||
iter->block = block;
|
||||
iter = next;
|
||||
}
|
||||
|
||||
label->block = block;
|
||||
label->resolved = 1;
|
||||
label->nextLabel = block->labels;
|
||||
block->labels = label;
|
||||
}
|
||||
|
||||
void pcbranch(PCBlock *block, PCLabel *label) {
|
||||
PCLink *link;
|
||||
|
||||
link = (PCLink *) lalloc(sizeof(PCLink));
|
||||
memclrw(link, sizeof(PCLink));
|
||||
|
||||
link->block = label->block;
|
||||
if (!label->resolved)
|
||||
label->block = (PCBlock *) link;
|
||||
link->nextLink = block->successors;
|
||||
block->successors = link;
|
||||
}
|
||||
|
||||
void pccomputepredecessors() {
|
||||
PCBlock *block;
|
||||
PCLink *succ;
|
||||
PCLink *pred;
|
||||
|
||||
for (block = pcbasicblocks; block; block = block->nextBlock) {
|
||||
for (succ = block->successors; succ; succ = succ->nextLink) {
|
||||
pred = (PCLink *) lalloc(sizeof(PCLink));
|
||||
memclrw(pred, sizeof(PCLink));
|
||||
|
||||
pred->block = block;
|
||||
pred->nextLink = succ->block->predecessors;
|
||||
succ->block->predecessors = pred;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void deleteblock(PCBlock *block) {
|
||||
block->prevBlock->nextBlock = block->nextBlock;
|
||||
if (block->nextBlock)
|
||||
block->nextBlock->prevBlock = block->prevBlock;
|
||||
block->flags |= fPCBlockFlag20;
|
||||
}
|
||||
|
||||
void deleteunreachableblocks() {
|
||||
PCBlock *block;
|
||||
|
||||
computedepthfirstordering();
|
||||
|
||||
for (block = pcbasicblocks->nextBlock; block; block = block->nextBlock) {
|
||||
if (!(block->flags & fPCBlockFlag4))
|
||||
deleteblock(block);
|
||||
}
|
||||
}
|
||||
|
||||
void appendpcode(PCBlock *block, PCode *pcode) {
|
||||
if (block->firstPCode) {
|
||||
pcode->nextPCode = 0;
|
||||
pcode->prevPCode = block->lastPCode;
|
||||
block->lastPCode->nextPCode = pcode;
|
||||
block->lastPCode = pcode;
|
||||
} else {
|
||||
block->lastPCode = pcode;
|
||||
block->firstPCode = pcode;
|
||||
pcode->prevPCode = 0;
|
||||
pcode->nextPCode = 0;
|
||||
}
|
||||
pcode->block = block;
|
||||
block->pcodeCount++;
|
||||
}
|
||||
|
||||
void deletepcode(PCode *pcode) {
|
||||
PCBlock *block;
|
||||
|
||||
block = pcode->block;
|
||||
if (pcode->prevPCode)
|
||||
pcode->prevPCode->nextPCode = pcode->nextPCode;
|
||||
else
|
||||
block->firstPCode = pcode->nextPCode;
|
||||
if (pcode->nextPCode)
|
||||
pcode->nextPCode->prevPCode = pcode->prevPCode;
|
||||
else
|
||||
block->lastPCode = pcode->prevPCode;
|
||||
|
||||
pcode->block = 0;
|
||||
block->pcodeCount--;
|
||||
block->flags &= ~fPCBlockFlag8;
|
||||
}
|
||||
|
||||
void insertpcodebefore(PCode *anchor, PCode *newpcode) {
|
||||
PCBlock *block;
|
||||
|
||||
block = anchor->block;
|
||||
if (anchor->prevPCode)
|
||||
anchor->prevPCode->nextPCode = newpcode;
|
||||
else
|
||||
block->firstPCode = newpcode;
|
||||
newpcode->nextPCode = anchor;
|
||||
newpcode->prevPCode = anchor->prevPCode;
|
||||
anchor->prevPCode = newpcode;
|
||||
newpcode->_1C = anchor->_1C;
|
||||
|
||||
newpcode->block = block;
|
||||
block->pcodeCount++;
|
||||
block->flags &= ~fPCBlockFlag8;
|
||||
}
|
||||
|
||||
void insertpcodeafter(PCode *anchor, PCode *newpcode) {
|
||||
PCBlock *block;
|
||||
|
||||
block = anchor->block;
|
||||
if (anchor->nextPCode)
|
||||
anchor->nextPCode->prevPCode = newpcode;
|
||||
else
|
||||
block->lastPCode = newpcode;
|
||||
newpcode->prevPCode = anchor;
|
||||
newpcode->nextPCode = anchor->nextPCode;
|
||||
anchor->nextPCode = newpcode;
|
||||
newpcode->_1C = anchor->_1C;
|
||||
|
||||
newpcode->block = block;
|
||||
block->pcodeCount++;
|
||||
block->flags &= ~fPCBlockFlag8;
|
||||
}
|
||||
|
||||
void setpcodeflags(int flags) {
|
||||
pclastblock->lastPCode->flags |= flags;
|
||||
if (flags & fSideEffects)
|
||||
pclastblock->lastPCode->flags &= ~(fIsCSE | fCommutative | fPCodeFlag10);
|
||||
}
|
||||
|
||||
void clearpcodeflags(int flags) {
|
||||
pclastblock->lastPCode->flags &= ~flags;
|
||||
}
|
||||
|
||||
int pccomputeoffsets() {
|
||||
int offset;
|
||||
PCBlock *block;
|
||||
|
||||
offset = 0;
|
||||
for (block = pcbasicblocks; block; block = block->nextBlock) {
|
||||
block->codeOffset = offset;
|
||||
offset += block->pcodeCount * 4;
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
typedef struct _DFO {
|
||||
PCBlock *block;
|
||||
PCLink *link;
|
||||
} DFO;
|
||||
|
||||
static int depthfirstorder;
|
||||
|
||||
void computedepthfirstordering() {
|
||||
PCBlock *block;
|
||||
PCLink *link;
|
||||
DFO *dfo;
|
||||
int index;
|
||||
|
||||
depthfirstordering = (PCBlock **) lalloc(sizeof(PCBlock *) * pcblockcount);
|
||||
memclrw(depthfirstordering, sizeof(PCBlock *) * pcblockcount);
|
||||
depthfirstorder = pcblockcount;
|
||||
|
||||
for (block = pcbasicblocks; block; block = block->nextBlock) {
|
||||
block->flags &= ~fPCBlockFlag4;
|
||||
}
|
||||
|
||||
dfo = (DFO *) oalloc(sizeof(DFO) * pcblockcount);
|
||||
pcbasicblocks->flags |= fPCBlockFlag4;
|
||||
|
||||
dfo->block = pcbasicblocks;
|
||||
dfo->link = pcbasicblocks->successors;
|
||||
index = 1;
|
||||
while (index) {
|
||||
if ((link = dfo[index - 1].link)) {
|
||||
dfo[index - 1].link = link->nextLink;
|
||||
block = link->block;
|
||||
if (!(block->flags & fPCBlockFlag4)) {
|
||||
block->flags |= fPCBlockFlag4;
|
||||
dfo[index].block = block;
|
||||
dfo[index].link = block->successors;
|
||||
index++;
|
||||
}
|
||||
} else {
|
||||
depthfirstordering[--depthfirstorder] = dfo[--index].block;
|
||||
}
|
||||
}
|
||||
|
||||
while (depthfirstorder) {
|
||||
depthfirstordering[--depthfirstorder] = 0;
|
||||
}
|
||||
}
|
||||
110
PCode.h
Normal file
110
PCode.h
Normal file
@ -0,0 +1,110 @@
|
||||
#pragma once
|
||||
|
||||
typedef struct _PCodeArg {
|
||||
unsigned int _0;
|
||||
unsigned int _4;
|
||||
unsigned int _8;
|
||||
} PCodeArg;
|
||||
|
||||
typedef struct _PCode {
|
||||
struct _PCode *nextPCode;
|
||||
struct _PCode *prevPCode;
|
||||
struct _PCBlock *block;
|
||||
unsigned int xx_C;
|
||||
unsigned int _10;
|
||||
int flags;
|
||||
unsigned int _18;
|
||||
unsigned int _1C;
|
||||
short op;
|
||||
short argCount;
|
||||
PCodeArg args[0];
|
||||
} PCode;
|
||||
|
||||
typedef struct _PCLabel {
|
||||
struct _PCLabel *nextLabel;
|
||||
struct _PCBlock *block;
|
||||
short resolved;
|
||||
short index;
|
||||
} PCLabel;
|
||||
|
||||
typedef struct _PCLink {
|
||||
struct _PCLink *nextLink;
|
||||
struct _PCBlock *block;
|
||||
} PCLink;
|
||||
|
||||
typedef struct _PCBlock {
|
||||
struct _PCBlock *nextBlock;
|
||||
struct _PCBlock *prevBlock;
|
||||
PCLabel *labels;
|
||||
PCLink *predecessors;
|
||||
PCLink *successors;
|
||||
PCode *firstPCode;
|
||||
PCode *lastPCode;
|
||||
int blockIndex;
|
||||
int codeOffset; // in bytes
|
||||
int loopWeight;
|
||||
short pcodeCount;
|
||||
unsigned short flags;
|
||||
} PCBlock;
|
||||
|
||||
/* PCode Flags */
|
||||
enum {
|
||||
fPCodeFlag1 = 1,
|
||||
fPCodeFlag2 = 2,
|
||||
fPCodeFlag4 = 4,
|
||||
fPCodeFlag8 = 8,
|
||||
fPCodeFlag10 = 0x10,
|
||||
fIsPtrOp = 0x20,
|
||||
fIsConst = 0x40,
|
||||
fIsVolatile = 0x80,
|
||||
fSideEffects = 0x100,
|
||||
fPCodeFlag200 = 0x200,
|
||||
fPCodeFlag400 = 0x400,
|
||||
fPCodeFlag800 = 0x800,
|
||||
fPCodeFlag1000 = 0x1000,
|
||||
fCommutative = 0x2000,
|
||||
fIsCSE = 0x4000,
|
||||
fOverflow = 0x800000,
|
||||
fLink = 0x1000000,
|
||||
fBranchNotTaken = 0x4000000,
|
||||
fBranchTaken = 0x8000000,
|
||||
fAbsolute = 0x10000000,
|
||||
fSetsCarry = 0x10000000,
|
||||
};
|
||||
|
||||
enum {
|
||||
fPCBlockFlag1 = 1,
|
||||
fPCBlockFlag2 = 2,
|
||||
fPCBlockFlag4 = 4,
|
||||
fPCBlockFlag8 = 8,
|
||||
fPCBlockFlag10 = 0x10,
|
||||
fPCBlockFlag20 = 0x20
|
||||
};
|
||||
|
||||
extern PCBlock *pcbasicblocks;
|
||||
extern PCBlock *pclastblock;
|
||||
extern void *prologue;
|
||||
extern void *epilogue;
|
||||
extern PCBlock **depthfirstordering;
|
||||
extern int pcblockcount;
|
||||
extern int pcloopweight;
|
||||
|
||||
extern void initpcode();
|
||||
extern PCode *makepcode(short op, ...);
|
||||
extern void emitpcode(short op, ...);
|
||||
extern PCode *copypcode(PCode *pcode);
|
||||
extern PCLabel *makepclabel();
|
||||
extern PCBlock *makepcblock();
|
||||
extern void pclabel(PCBlock *block, PCLabel *label);
|
||||
extern void pcbranch(PCBlock *block, PCLabel *label);
|
||||
extern void pccomputepredecessors();
|
||||
extern void deleteblock(PCBlock *block);
|
||||
extern void deleteunreachableblocks();
|
||||
extern void appendpcode(PCBlock *block, PCode *pcode);
|
||||
extern void deletepcode(PCode *pcode);
|
||||
extern void insertpcodebefore(PCode *anchor, PCode *newpcode);
|
||||
extern void insertpcodeafter(PCode *anchor, PCode *newpcode);
|
||||
extern void setpcodeflags(int flags);
|
||||
extern void clearpcodeflags(int flags);
|
||||
extern int pccomputeoffsets();
|
||||
extern void computedepthfirstordering();
|
||||
55
PCodeInfo.c
Normal file
55
PCodeInfo.c
Normal file
@ -0,0 +1,55 @@
|
||||
#include "PCodeInfo.h"
|
||||
|
||||
void pcode_get_hi_lo(int a1, char a2, int *pA, int *pB) {
|
||||
|
||||
}
|
||||
|
||||
int pcode_check_imm_bits(int a1, int a2, int a3) {
|
||||
|
||||
}
|
||||
|
||||
int pcode_const_from_format(char *buf, int *pResult) {
|
||||
|
||||
}
|
||||
|
||||
PCode *vformatpcode(short opcode, va_list argList) {
|
||||
|
||||
}
|
||||
|
||||
int expectandformatoperand(PCodeArg *operand, unsigned char expectedKind, char a3, int bitCount, char *buf) {
|
||||
}
|
||||
|
||||
int formatoperand(PCodeArg *operand, char *buf) {
|
||||
|
||||
}
|
||||
|
||||
void formatoperands(PCode *pcode, char *buf, int showBasicBlocks) {
|
||||
|
||||
}
|
||||
|
||||
PCode *makecopyinstruction(PCodeArg *a, PCodeArg *b) {
|
||||
|
||||
}
|
||||
|
||||
int is_location_independent(PCode *pcode) {
|
||||
|
||||
}
|
||||
|
||||
int can_reuse_stored_value(PCode *a, PCode *b) {
|
||||
|
||||
}
|
||||
|
||||
int nbytes_loaded_or_stored_by(PCode *pcode) {
|
||||
|
||||
}
|
||||
|
||||
void change_num_operands(PCode *pcode, int newNum) {
|
||||
|
||||
}
|
||||
|
||||
void change_opcode(PCode *pcode, short opcode) {
|
||||
pcode->flags = (pcode->flags & ~(opcodeinfo[pcode->op].flags & ~fIsPtrOp)) | opcodeinfo[opcode].flags;
|
||||
if ((pcode->flags & fPCodeFlag10) && (pcode->flags & (fPCodeFlag1 | fPCodeFlag8)))
|
||||
pcode->flags &= ~fPCodeFlag10;
|
||||
pcode->op = opcode;
|
||||
}
|
||||
462
PCodeInfo.h
Normal file
462
PCodeInfo.h
Normal file
@ -0,0 +1,462 @@
|
||||
#pragma once
|
||||
|
||||
#include "PCode.h"
|
||||
|
||||
typedef struct _OpcodeInfo {
|
||||
const char *name;
|
||||
const char *format;
|
||||
unsigned char x8;
|
||||
unsigned char x9;
|
||||
int xA;
|
||||
unsigned int insn;
|
||||
} OpcodeInfo;
|
||||
|
||||
enum {
|
||||
PC_B = 0x0,
|
||||
PC_BL = 0x1,
|
||||
PC_BC = 0x2,
|
||||
PC_BCLR = 0x3,
|
||||
PC_BCCTR = 0x4,
|
||||
PC_BT = 0x5,
|
||||
PC_BTLR = 0x6,
|
||||
PC_BTCTR = 0x7,
|
||||
PC_BF = 0x8,
|
||||
PC_BFLR = 0x9,
|
||||
PC_BFCTR = 0xA,
|
||||
PC_BDNZ = 0xB,
|
||||
PC_BDNZT = 0xC,
|
||||
PC_BDNZF = 0xD,
|
||||
PC_BDZ = 0xE,
|
||||
PC_BDZT = 0xF,
|
||||
PC_BDZF = 0x10,
|
||||
PC_BLR = 0x11,
|
||||
PC_BCTR = 0x12,
|
||||
PC_BCTRL = 0x13,
|
||||
PC_BLRL = 0x14,
|
||||
PC_LBZ = 0x15,
|
||||
PC_LBZU = 0x16,
|
||||
PC_LBZX = 0x17,
|
||||
PC_LBZUX = 0x18,
|
||||
PC_LHZ = 0x19,
|
||||
PC_LHZU = 0x1A,
|
||||
PC_LHZX = 0x1B,
|
||||
PC_LHZUX = 0x1C,
|
||||
PC_LHA = 0x1D,
|
||||
PC_LHAU = 0x1E,
|
||||
PC_LHAX = 0x1F,
|
||||
PC_LHAUX = 0x20,
|
||||
PC_LHBRX = 0x21,
|
||||
PC_LWZ = 0x22,
|
||||
PC_LWZU = 0x23,
|
||||
PC_LWZX = 0x24,
|
||||
PC_LWZUX = 0x25,
|
||||
PC_LWBRX = 0x26,
|
||||
PC_LMW = 0x27,
|
||||
PC_STB = 0x28,
|
||||
PC_STBU = 0x29,
|
||||
PC_STBX = 0x2A,
|
||||
PC_STBUX = 0x2B,
|
||||
PC_STH = 0x2C,
|
||||
PC_STHU = 0x2D,
|
||||
PC_STHX = 0x2E,
|
||||
PC_STHUX = 0x2F,
|
||||
PC_STHBRX = 0x30,
|
||||
PC_STW = 0x31,
|
||||
PC_STWU = 0x32,
|
||||
PC_STWX = 0x33,
|
||||
PC_STWUX = 0x34,
|
||||
PC_STWBRX = 0x35,
|
||||
PC_STMW = 0x36,
|
||||
PC_DCBF = 0x37,
|
||||
PC_DCBST = 0x38,
|
||||
PC_DCBT = 0x39,
|
||||
PC_DCBTST = 0x3A,
|
||||
PC_DCBZ = 0x3B,
|
||||
PC_ADD = 0x3C,
|
||||
PC_ADDC = 0x3D,
|
||||
PC_ADDE = 0x3E,
|
||||
PC_ADDI = 0x3F,
|
||||
PC_ADDIC = 0x40,
|
||||
PC_ADDICR = 0x41,
|
||||
PC_ADDIS = 0x42,
|
||||
PC_ADDME = 0x43,
|
||||
PC_ADDZE = 0x44,
|
||||
PC_DIVW = 0x45,
|
||||
PC_DIVWU = 0x46,
|
||||
PC_MULHW = 0x47,
|
||||
PC_MULHWU = 0x48,
|
||||
PC_MULLI = 0x49,
|
||||
PC_MULLW = 0x4A,
|
||||
PC_NEG = 0x4B,
|
||||
PC_SUBF = 0x4C,
|
||||
PC_SUBFC = 0x4D,
|
||||
PC_SUBFE = 0x4E,
|
||||
PC_SUBFIC = 0x4F,
|
||||
PC_SUBFME = 0x50,
|
||||
PC_SUBFZE = 0x51,
|
||||
PC_CMPI = 0x52,
|
||||
PC_CMP = 0x53,
|
||||
PC_CMPLI = 0x54,
|
||||
PC_CMPL = 0x55,
|
||||
PC_ANDI = 0x56,
|
||||
PC_ANDIS = 0x57,
|
||||
PC_ORI = 0x58,
|
||||
PC_ORIS = 0x59,
|
||||
PC_XORI = 0x5A,
|
||||
PC_XORIS = 0x5B,
|
||||
PC_AND = 0x5C,
|
||||
PC_OR = 0x5D,
|
||||
PC_XOR = 0x5E,
|
||||
PC_NAND = 0x5F,
|
||||
PC_NOR = 0x60,
|
||||
PC_EQV = 0x61,
|
||||
PC_ANDC = 0x62,
|
||||
PC_ORC = 0x63,
|
||||
PC_EXTSB = 0x64,
|
||||
PC_EXTSH = 0x65,
|
||||
PC_CNTLZW = 0x66,
|
||||
PC_RLWINM = 0x67,
|
||||
PC_RLWNM = 0x68,
|
||||
PC_RLWIMI = 0x69,
|
||||
PC_SLW = 0x6A,
|
||||
PC_SRW = 0x6B,
|
||||
PC_SRAWI = 0x6C,
|
||||
PC_SRAW = 0x6D,
|
||||
PC_CRAND = 0x6E,
|
||||
PC_CRANDC = 0x6F,
|
||||
PC_CREQV = 0x70,
|
||||
PC_CRNAND = 0x71,
|
||||
PC_CRNOR = 0x72,
|
||||
PC_CROR = 0x73,
|
||||
PC_CRORC = 0x74,
|
||||
PC_CRXOR = 0x75,
|
||||
PC_MCRF = 0x76,
|
||||
PC_MTXER = 0x77,
|
||||
PC_MTCTR = 0x78,
|
||||
PC_MTLR = 0x79,
|
||||
PC_MTCRF = 0x7A,
|
||||
PC_MTMSR = 0x7B,
|
||||
PC_MTSPR = 0x7C,
|
||||
PC_MFMSR = 0x7D,
|
||||
PC_MFSPR = 0x7E,
|
||||
PC_MFXER = 0x7F,
|
||||
PC_MFCTR = 0x80,
|
||||
PC_MFLR = 0x81,
|
||||
PC_MFCR = 0x82,
|
||||
PC_MFFS = 0x83,
|
||||
PC_MTFSF = 0x84,
|
||||
PC_EIEIO = 0x85,
|
||||
PC_ISYNC = 0x86,
|
||||
PC_SYNC = 0x87,
|
||||
PC_RFI = 0x88,
|
||||
PC_LI = 0x89,
|
||||
PC_LIS = 0x8A,
|
||||
PC_MR = 0x8B,
|
||||
PC_NOP = 0x8C,
|
||||
PC_NOT = 0x8D,
|
||||
PC_LFS = 0x8E,
|
||||
PC_LFSU = 0x8F,
|
||||
PC_LFSX = 0x90,
|
||||
PC_LFSUX = 0x91,
|
||||
PC_LFD = 0x92,
|
||||
PC_LFDU = 0x93,
|
||||
PC_LFDX = 0x94,
|
||||
PC_LFDUX = 0x95,
|
||||
PC_STFS = 0x96,
|
||||
PC_STFSU = 0x97,
|
||||
PC_STFSX = 0x98,
|
||||
PC_STFSUX = 0x99,
|
||||
PC_STFD = 0x9A,
|
||||
PC_STFDU = 0x9B,
|
||||
PC_STFDX = 0x9C,
|
||||
PC_STFDUX = 0x9D,
|
||||
PC_FMR = 0x9E,
|
||||
PC_FABS = 0x9F,
|
||||
PC_FNEG = 0xA0,
|
||||
PC_FNABS = 0xA1,
|
||||
PC_FADD = 0xA2,
|
||||
PC_FADDS = 0xA3,
|
||||
PC_FSUB = 0xA4,
|
||||
PC_FSUBS = 0xA5,
|
||||
PC_FMUL = 0xA6,
|
||||
PC_FMULS = 0xA7,
|
||||
PC_FDIV = 0xA8,
|
||||
PC_FDIVS = 0xA9,
|
||||
PC_FMADD = 0xAA,
|
||||
PC_FMADDS = 0xAB,
|
||||
PC_FMSUB = 0xAC,
|
||||
PC_FMSUBS = 0xAD,
|
||||
PC_FNMADD = 0xAE,
|
||||
PC_FNMADDS = 0xAF,
|
||||
PC_FNMSUB = 0xB0,
|
||||
PC_FNMSUBS = 0xB1,
|
||||
PC_FRES = 0xB2,
|
||||
PC_FRSQRTE = 0xB3,
|
||||
PC_FSEL = 0xB4,
|
||||
PC_FRSP = 0xB5,
|
||||
PC_FCTIW = 0xB6,
|
||||
PC_FCTIWZ = 0xB7,
|
||||
PC_FCMPU = 0xB8,
|
||||
PC_FCMPO = 0xB9,
|
||||
PC_LWARX = 0xBA,
|
||||
PC_LSWI = 0xBB,
|
||||
PC_LSWX = 0xBC,
|
||||
PC_STFIWX = 0xBD,
|
||||
PC_STSWI = 0xBE,
|
||||
PC_STSWX = 0xBF,
|
||||
PC_STWCX = 0xC0,
|
||||
PC_ECIWX = 0xC1,
|
||||
PC_ECOWX = 0xC2,
|
||||
PC_DCBI = 0xC3,
|
||||
PC_ICBI = 0xC4,
|
||||
PC_MCRFS = 0xC5,
|
||||
PC_MCRXR = 0xC6,
|
||||
PC_MFTB = 0xC7,
|
||||
PC_MFSR = 0xC8,
|
||||
PC_MTSR = 0xC9,
|
||||
PC_MFSRIN = 0xCA,
|
||||
PC_MTSRIN = 0xCB,
|
||||
PC_MTFSB0 = 0xCC,
|
||||
PC_MTFSB1 = 0xCD,
|
||||
PC_MTFSFI = 0xCE,
|
||||
PC_SC = 0xCF,
|
||||
PC_FSQRT = 0xD0,
|
||||
PC_FSQRTS = 0xD1,
|
||||
PC_TLBIA = 0xD2,
|
||||
PC_TLBIE = 0xD3,
|
||||
PC_TLBLD = 0xD4,
|
||||
PC_TLBLI = 0xD5,
|
||||
PC_TLBSYNC = 0xD6,
|
||||
PC_TW = 0xD7,
|
||||
PC_TRAP = 0xD8,
|
||||
PC_TWI = 0xD9,
|
||||
PC_OPWORD = 0xDA,
|
||||
PC_MFROM = 0xDB,
|
||||
PC_DSA = 0xDC,
|
||||
PC_ESA = 0xDD,
|
||||
PC_DCCCI = 0xDE,
|
||||
PC_DCREAD = 0xDF,
|
||||
PC_ICBT = 0xE0,
|
||||
PC_ICCCI = 0xE1,
|
||||
PC_ICREAD = 0xE2,
|
||||
PC_RFCI = 0xE3,
|
||||
PC_TLBRE = 0xE4,
|
||||
PC_TLBSX = 0xE5,
|
||||
PC_TLBWE = 0xE6,
|
||||
PC_WRTEE = 0xE7,
|
||||
PC_WRTEEI = 0xE8,
|
||||
PC_MFDCR = 0xE9,
|
||||
PC_MTDCR = 0xEA,
|
||||
PC_DCBA = 0xEB,
|
||||
PC_DSS = 0xEC,
|
||||
PC_DSSALL = 0xED,
|
||||
PC_DST = 0xEE,
|
||||
PC_DSTT = 0xEF,
|
||||
PC_DSTST = 0xF0,
|
||||
PC_DSTSTT = 0xF1,
|
||||
PC_LVEBX = 0xF2,
|
||||
PC_LVEHX = 0xF3,
|
||||
PC_LVEWX = 0xF4,
|
||||
PC_LVSL = 0xF5,
|
||||
PC_LVSR = 0xF6,
|
||||
PC_LVX = 0xF7,
|
||||
PC_LVXL = 0xF8,
|
||||
PC_STVEBX = 0xF9,
|
||||
PC_STVEHX = 0xFA,
|
||||
PC_STVEWX = 0xFB,
|
||||
PC_STVX = 0xFC,
|
||||
PC_STVXL = 0xFD,
|
||||
PC_MFVSCR = 0xFE,
|
||||
PC_MTVSCR = 0xFF,
|
||||
PC_VADDCUW = 0x100,
|
||||
PC_VADDFP = 0x101,
|
||||
PC_VADDSBS = 0x102,
|
||||
PC_VADDSHS = 0x103,
|
||||
PC_VADDSWS = 0x104,
|
||||
PC_VADDUBM = 0x105,
|
||||
PC_VADDUBS = 0x106,
|
||||
PC_VADDUHM = 0x107,
|
||||
PC_VADDUHS = 0x108,
|
||||
PC_VADDUWM = 0x109,
|
||||
PC_VADDUWS = 0x10A,
|
||||
PC_VAND = 0x10B,
|
||||
PC_VANDC = 0x10C,
|
||||
PC_VAVGSB = 0x10D,
|
||||
PC_VAVGSH = 0x10E,
|
||||
PC_VAVGSW = 0x10F,
|
||||
PC_VAVGUB = 0x110,
|
||||
PC_VAVGUH = 0x111,
|
||||
PC_VAVGUW = 0x112,
|
||||
PC_VCFSX = 0x113,
|
||||
PC_VCFUX = 0x114,
|
||||
PC_VCMPBFP = 0x115,
|
||||
PC_VCMPEQFP = 0x116,
|
||||
PC_VCMPEQUB = 0x117,
|
||||
PC_VCMPEQUH = 0x118,
|
||||
PC_VCMPEQUW = 0x119,
|
||||
PC_VCMPGEFP = 0x11A,
|
||||
PC_VCMPGTFP = 0x11B,
|
||||
PC_VCMPGTSB = 0x11C,
|
||||
PC_VCMPGTSH = 0x11D,
|
||||
PC_VCMPGTSW = 0x11E,
|
||||
PC_VCMPGTUB = 0x11F,
|
||||
PC_VCMPGTUH = 0x120,
|
||||
PC_VCMPGTUW = 0x121,
|
||||
PC_VCTSXS = 0x122,
|
||||
PC_VCTUXS = 0x123,
|
||||
PC_VEXPTEFP = 0x124,
|
||||
PC_VLOGEFP = 0x125,
|
||||
PC_VMAXFP = 0x126,
|
||||
PC_VMAXSB = 0x127,
|
||||
PC_VMAXSH = 0x128,
|
||||
PC_VMAXSW = 0x129,
|
||||
PC_VMAXUB = 0x12A,
|
||||
PC_VMAXUH = 0x12B,
|
||||
PC_VMAXUW = 0x12C,
|
||||
PC_VMINFP = 0x12D,
|
||||
PC_VMINSB = 0x12E,
|
||||
PC_VMINSH = 0x12F,
|
||||
PC_VMINSW = 0x130,
|
||||
PC_VMINUB = 0x131,
|
||||
PC_VMINUH = 0x132,
|
||||
PC_VMINUW = 0x133,
|
||||
PC_VMRGHB = 0x134,
|
||||
PC_VMRGHH = 0x135,
|
||||
PC_VMRGHW = 0x136,
|
||||
PC_VMRGLB = 0x137,
|
||||
PC_VMRGLH = 0x138,
|
||||
PC_VMRGLW = 0x139,
|
||||
PC_VMULESB = 0x13A,
|
||||
PC_VMULESH = 0x13B,
|
||||
PC_VMULEUB = 0x13C,
|
||||
PC_VMULEUH = 0x13D,
|
||||
PC_VMULOSB = 0x13E,
|
||||
PC_VMULOSH = 0x13F,
|
||||
PC_VMULOUB = 0x140,
|
||||
PC_VMULOUH = 0x141,
|
||||
PC_VNOR = 0x142,
|
||||
PC_VOR = 0x143,
|
||||
PC_VPKPX = 0x144,
|
||||
PC_VPKSHSS = 0x145,
|
||||
PC_VPKSHUS = 0x146,
|
||||
PC_VPKSWSS = 0x147,
|
||||
PC_VPKSWUS = 0x148,
|
||||
PC_VPKUHUM = 0x149,
|
||||
PC_VPKUHUS = 0x14A,
|
||||
PC_VPKUWUM = 0x14B,
|
||||
PC_VPKUWUS = 0x14C,
|
||||
PC_VREFP = 0x14D,
|
||||
PC_VRFIM = 0x14E,
|
||||
PC_VRFIN = 0x14F,
|
||||
PC_VRFIP = 0x150,
|
||||
PC_VRFIZ = 0x151,
|
||||
PC_VRLB = 0x152,
|
||||
PC_VRLH = 0x153,
|
||||
PC_VRLW = 0x154,
|
||||
PC_VRSQRTEFP = 0x155,
|
||||
PC_VSL = 0x156,
|
||||
PC_VSLB = 0x157,
|
||||
PC_VSLH = 0x158,
|
||||
PC_VSLO = 0x159,
|
||||
PC_VSLW = 0x15A,
|
||||
PC_VSPLTB = 0x15B,
|
||||
PC_VSPLTH = 0x15C,
|
||||
PC_VSPLTW = 0x15D,
|
||||
PC_VSPLTISB = 0x15E,
|
||||
PC_VSPLTISH = 0x15F,
|
||||
PC_VSPLTISW = 0x160,
|
||||
PC_VSR = 0x161,
|
||||
PC_VSRAB = 0x162,
|
||||
PC_VSRAH = 0x163,
|
||||
PC_VSRAW = 0x164,
|
||||
PC_VSRB = 0x165,
|
||||
PC_VSRH = 0x166,
|
||||
PC_VSRO = 0x167,
|
||||
PC_VSRW = 0x168,
|
||||
PC_VSUBCUW = 0x169,
|
||||
PC_VSUBFP = 0x16A,
|
||||
PC_VSUBSBS = 0x16B,
|
||||
PC_VSUBSHS = 0x16C,
|
||||
PC_VSUBSWS = 0x16D,
|
||||
PC_VSUBUBM = 0x16E,
|
||||
PC_VSUBUBS = 0x16F,
|
||||
PC_VSUBUHM = 0x170,
|
||||
PC_VSUBUHS = 0x171,
|
||||
PC_VSUBUWM = 0x172,
|
||||
PC_VSUBUWS = 0x173,
|
||||
PC_VSUMSWS = 0x174,
|
||||
PC_VSUM2SWS = 0x175,
|
||||
PC_VSUM4SBS = 0x176,
|
||||
PC_VSUM4SHS = 0x177,
|
||||
PC_VSUM4UBS = 0x178,
|
||||
PC_VUPKHPX = 0x179,
|
||||
PC_VUPKHSB = 0x17A,
|
||||
PC_VUPKHSH = 0x17B,
|
||||
PC_VUPKLPX = 0x17C,
|
||||
PC_VUPKLSB = 0x17D,
|
||||
PC_VUPKLSH = 0x17E,
|
||||
PC_VXOR = 0x17F,
|
||||
PC_VMADDFP = 0x180,
|
||||
PC_VMHADDSHS = 0x181,
|
||||
PC_VMHRADDSHS = 0x182,
|
||||
PC_VMLADDUHM = 0x183,
|
||||
PC_VMSUMMBM = 0x184,
|
||||
PC_VMSUMSHM = 0x185,
|
||||
PC_VMSUMSHS = 0x186,
|
||||
PC_VMSUMUBM = 0x187,
|
||||
PC_VMSUMUHM = 0x188,
|
||||
PC_VMSUMUHS = 0x189,
|
||||
PC_VNMSUBFP = 0x18A,
|
||||
PC_VPERM = 0x18B,
|
||||
PC_VSEL = 0x18C,
|
||||
PC_VSLDOI = 0x18D,
|
||||
PC_VMR = 0x18E,
|
||||
PC_VMRP = 0x18F,
|
||||
PC_SLE = 0x190,
|
||||
PC_SLEQ = 0x191,
|
||||
PC_SLIQ = 0x192,
|
||||
PC_SLLIQ = 0x193,
|
||||
PC_SLLQ = 0x194,
|
||||
PC_SLQ = 0x195,
|
||||
PC_SRAIQ = 0x196,
|
||||
PC_SRAQ = 0x197,
|
||||
PC_SRE = 0x198,
|
||||
PC_SREA = 0x199,
|
||||
PC_SREQ = 0x19A,
|
||||
PC_SRIQ = 0x19B,
|
||||
PC_SRLIQ = 0x19C,
|
||||
PC_SRLQ = 0x19D,
|
||||
PC_SRQ = 0x19E,
|
||||
PC_MASKG = 0x19F,
|
||||
PC_MASKIR = 0x1A0,
|
||||
PC_LSCBX = 0x1A1,
|
||||
PC_DIV = 0x1A2,
|
||||
PC_DIVS = 0x1A3,
|
||||
PC_DOZ = 0x1A4,
|
||||
PC_MUL = 0x1A5,
|
||||
PC_NABS = 0x1A6,
|
||||
PC_ABS = 0x1A7,
|
||||
PC_CLCS = 0x1A8,
|
||||
PC_DOZI = 0x1A9,
|
||||
PC_RLMI = 0x1AA,
|
||||
PC_RRIB = 0x1AB,
|
||||
PC_PENTRY = 0x1AC,
|
||||
PC_PEXIT = 0x1AD,
|
||||
OPCODE_MAX = 0x1AE
|
||||
};
|
||||
|
||||
extern OpcodeInfo opcodeInfo[OPCODE_MAX];
|
||||
|
||||
extern void pcode_get_hi_lo(int a1, char a2, int *pA, int *pB);
|
||||
extern int pcode_check_imm_bits(int a1, int a2, int a3);
|
||||
extern int pcode_const_from_format(char *buf, int *pResult);
|
||||
extern PCode *vformatpcode(short opcode, va_list argList);
|
||||
extern int expectandformatoperand(PCodeArg *operand, unsigned char expectedKind, char a3, int bitCount, char *buf);
|
||||
extern int formatoperand(PCodeArg *operand, char *buf);
|
||||
extern void formatoperands(PCode *pcode, char *buf, int showBasicBlocks);
|
||||
extern PCode *makecopyinstruction(PCodeArg *a, PCodeArg *b);
|
||||
extern int is_location_independent(PCode *pcode);
|
||||
extern int can_reuse_stored_value(PCode *a, PCode *b);
|
||||
extern int nbytes_loaded_or_stored_by(PCode *pcode);
|
||||
extern void change_num_operands(PCode *pcode, int newNum);
|
||||
extern void change_opcode(PCode *pcode, short opcode);
|
||||
226
ParserFace.c
Normal file
226
ParserFace.c
Normal file
@ -0,0 +1,226 @@
|
||||
#include "UCWInterface.h"
|
||||
|
||||
struct ParseOptsType parseopts;
|
||||
|
||||
// TODO move me imports
|
||||
extern CWResult CWSecretGetNamedPreferences(CWPluginContext context, const char *name, Handle *pHandle);
|
||||
extern CWResult CWParserSetNamedPreferences(CWPluginContext context, const char *name, Handle pHandle);
|
||||
extern CWResult CWParserGetCommandLine(CWPluginContext context, CWCommandLineArgs **pArgs);
|
||||
extern CWResult CWParserGetToolInfo(CWPluginContext context, struct ToolVersionInfo **pToolVersion);
|
||||
extern CWResult CWParserGetTargetInfo(CWPluginContext context, unsigned long *pCpu, unsigned long *pOs);
|
||||
extern CWResult CWParserGetPanels(CWPluginContext context, int *pNumPanels, char ***pPanelNames);
|
||||
extern CWResult CWParserGetPlugins(CWPluginContext context, int *pNumPlugins, struct CLPluginInfo **pPlugins);
|
||||
extern void/*?*/ CWGetPluginRequest(CWPluginContext context, long *request);
|
||||
extern void/*?*/ CWDonePluginRequest(CWPluginContext context, CWResult result);
|
||||
extern void *pTool;
|
||||
extern void SetupParserToolOptions();
|
||||
extern void CLPReportError(short code, ...);
|
||||
extern unsigned char ParserToolMatchesPlugin(unsigned long plugintype, unsigned long language, unsigned long cpu, unsigned long os);
|
||||
extern unsigned char ParserToolHandlesPanels(int numPanels, char **panelNames);
|
||||
// TODO move me imports
|
||||
|
||||
char *failedCallback;
|
||||
|
||||
static CWResult SetupParamBlock(CWPluginContext context) {
|
||||
struct PCmdLineEnvir cle;
|
||||
Handle h;
|
||||
int x;
|
||||
CWResult result;
|
||||
|
||||
memset(&parseopts, 0, sizeof(parseopts));
|
||||
parseopts.context = context;
|
||||
|
||||
result = CWSecretGetNamedPreferences(context, "CmdLine Environment", &h);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
cle = **((struct PCmdLineEnvir **) h);
|
||||
parseopts.underIDE = cle.underIDE;
|
||||
parseopts.ioRows = cle.rows;
|
||||
parseopts.ioCols = cle.cols;
|
||||
|
||||
result = CWParserGetCommandLine(context, &parseopts.args);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
result = CWParserGetToolInfo(context, &parseopts.toolVersion);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
result = CWParserGetTargetInfo(context, &parseopts.cpu, &parseopts.os);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
result = CWParserGetPanels(context, &parseopts.numPanels, &parseopts.panelNames);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
result = CWParserGetPlugins(context, &parseopts.numPlugins, &parseopts.plugins);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
parseopts.passingArgs = 0;
|
||||
for (x = 0; x < parseopts.numPlugins; x++) {
|
||||
if (parseopts.plugins[x].storeCommandLine)
|
||||
parseopts.passingArgs = 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static CWResult SetupOptions(CWPluginContext context) {
|
||||
if (!pTool) {
|
||||
return 2;
|
||||
} else {
|
||||
SetupParserToolOptions();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static CWResult Parse(CWPluginContext context) {
|
||||
CWResult result;
|
||||
|
||||
// TODO
|
||||
return result;
|
||||
}
|
||||
|
||||
Handle Parser_FindPrefPanel(char *name) {
|
||||
Handle h;
|
||||
int idx;
|
||||
|
||||
// TODO pTool
|
||||
}
|
||||
|
||||
CWResult Parser_StorePanels(CWPluginContext context) {
|
||||
int idx;
|
||||
CWResult result;
|
||||
char *name;
|
||||
Handle h;
|
||||
|
||||
for (idx = 0; idx < parseopts.numPanels; idx++) {
|
||||
name = parseopts.panelNames[idx];
|
||||
h = Parser_FindPrefPanel(name);
|
||||
if (h) {
|
||||
result = CWParserSetNamedPreferences(parseopts.context, name, h);
|
||||
if (result) {
|
||||
CLPReportError(68, name);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static CWResult StoreResults(CWPluginContext context) {
|
||||
// TODO Arg
|
||||
}
|
||||
|
||||
short CWParser_GetDropInFlags(const DropInFlags **flags, long *flagsSize) {
|
||||
static const DropInFlags sFlags = {
|
||||
kCurrentDropInFlagsVersion,
|
||||
CWFOURCHAR('P','a','r','s'),
|
||||
7,
|
||||
0,
|
||||
'Seep',
|
||||
12
|
||||
};
|
||||
*flags = &sFlags;
|
||||
*flagsSize = sizeof(sFlags);
|
||||
return 0;
|
||||
}
|
||||
|
||||
short CWParser_GetDropInName(const char **dropinName) {
|
||||
static const char *sDropInName = "Command-Line Parser";
|
||||
*dropinName = sDropInName;
|
||||
return 0;
|
||||
}
|
||||
|
||||
short CWParser_GetDisplayName(const char **displayName) {
|
||||
static const char *sDisplayName = "Command-Line Parser";
|
||||
*displayName = sDisplayName;
|
||||
return 0;
|
||||
}
|
||||
|
||||
short CWParser_GetPanelList(const CWPanelList **panelList) {
|
||||
static const CWPanelList sPanelList = {
|
||||
kCurrentCWFamilyListVersion,
|
||||
0,
|
||||
0
|
||||
};
|
||||
*panelList = &sPanelList;
|
||||
return 0;
|
||||
}
|
||||
|
||||
short CWParser_GetTargetList(const CWTargetList **targetList) {
|
||||
static const unsigned long sCPU = '****';
|
||||
static const unsigned long sOS = '****';
|
||||
static const CWTargetList sTargetList = {
|
||||
kCurrentCWTargetListVersion,
|
||||
1,
|
||||
&sCPU,
|
||||
1,
|
||||
&sOS
|
||||
};
|
||||
*targetList = &sTargetList;
|
||||
return 0;
|
||||
}
|
||||
|
||||
short CWParser_GetVersionInfo(const VersionInfo **versioninfo) {
|
||||
static const VersionInfo vi = {
|
||||
1, 1, 0, 0
|
||||
};
|
||||
*versioninfo = &vi;
|
||||
return 0;
|
||||
}
|
||||
|
||||
short Parser_SupportsPlugin(struct CLPluginInfo *pluginfo, CWDataType cpu, CWDataType os, Boolean *isSupported) {
|
||||
*isSupported = ParserToolMatchesPlugin(pluginfo->plugintype, pluginfo->language, cpu, os);
|
||||
return 0;
|
||||
}
|
||||
|
||||
short Parser_SupportsPanels(int numPanels, char **panelNames, Boolean *isSupported) {
|
||||
*isSupported = ParserToolHandlesPanels(numPanels, panelNames);
|
||||
return 0;
|
||||
}
|
||||
|
||||
jmp_buf exit_plugin;
|
||||
|
||||
short parser_main(CWPluginContext context) {
|
||||
long request;
|
||||
CWResult result;
|
||||
|
||||
CWGetPluginRequest(context, &request);
|
||||
result = setjmp(exit_plugin);
|
||||
if (result == 0) {
|
||||
switch (request) {
|
||||
case reqInitialize:
|
||||
result = 0;
|
||||
break;
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
result = SetupParamBlock(context);
|
||||
if (!result)
|
||||
result = Parser_StorePanels(context);
|
||||
break;
|
||||
case 2:
|
||||
result = SetupParamBlock(context);
|
||||
if (!result) {
|
||||
result = SetupOptions(context);
|
||||
if (!result) {
|
||||
result = Parse(context);
|
||||
if (!result)
|
||||
result = StoreResults(context);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (failedCallback && result != 1)
|
||||
fprintf(stderr, "Unexpected error in %s [%d]\n", failedCallback, result);
|
||||
}
|
||||
CWDonePluginRequest(context, result);
|
||||
|
||||
return result;
|
||||
}
|
||||
384
UCLTMain.c
Normal file
384
UCLTMain.c
Normal file
@ -0,0 +1,384 @@
|
||||
#include "UCWInterface.h"
|
||||
|
||||
static short CLT_dummymain() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetDropInFlags(const DropInFlags **flags, long *flagsSize) {
|
||||
static const DropInFlags sFlags = {
|
||||
kCurrentDropInFlagsVersion,
|
||||
CWFOURCHAR('c','l','d','r'),
|
||||
7,
|
||||
0,
|
||||
0,
|
||||
12
|
||||
};
|
||||
*flags = &sFlags;
|
||||
*flagsSize = sizeof(sFlags);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetDropInName(const char **dropInName) {
|
||||
static const char *sDropInName = "Command-Line Driver";
|
||||
*dropInName = sDropInName;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetDisplayName(const char **displayName) {
|
||||
static const char *sDisplayName = "Command-Line Driver";
|
||||
*displayName = sDisplayName;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetPanelList(const CWPanelList **panelList) {
|
||||
static const char *sPanelNames[4];
|
||||
static CWPanelList sPanelList = {
|
||||
kCurrentCWPanelListVersion,
|
||||
4,
|
||||
sPanelNames
|
||||
};
|
||||
|
||||
sPanelNames[0] = "CmdLine Panel";
|
||||
if (clState.plugintype == CWDROPINCOMPILERTYPE) {
|
||||
sPanelNames[1] = "CmdLine Compiler Panel";
|
||||
sPanelNames[2] = "CmdLine Linker Panel";
|
||||
sPanelList.count = 3;
|
||||
} else {
|
||||
sPanelNames[1] = "CmdLine Linker Panel";
|
||||
sPanelList.count = 2;
|
||||
}
|
||||
*panelList = &sPanelList;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetTargetList(const CWTargetList **targetList) {
|
||||
static CWDataType sCPU = CWFOURCHAR('*','*','*','*');
|
||||
static CWDataType sOS = CWFOURCHAR('*','*','*','*');
|
||||
static CWTargetList sTargetList = {
|
||||
kCurrentCWTargetListVersion,
|
||||
1,
|
||||
&sCPU,
|
||||
1,
|
||||
&sOS
|
||||
};
|
||||
*targetList = &sTargetList;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetVersionInfo(const VersionInfo **versioninfo) {
|
||||
static const VersionInfo vi = {
|
||||
3, 0, 0, 0
|
||||
};
|
||||
*versioninfo = &vi;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short CLT_GetFileTypeMappings(const OSFileTypeMappingList **mappingList) {
|
||||
static const OSFileTypeMapping ftmes[2] = {
|
||||
{CWFOURCHAR('B','r','w','s'), "DubL", 4, 0, 0},
|
||||
{CWFOURCHAR('M','M','P','r'), "looc", 4, 0, 0}
|
||||
};
|
||||
static const OSFileTypeMappingList ftml = {
|
||||
2,
|
||||
ftmes
|
||||
};
|
||||
*mappingList = &ftml;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static BasePluginCallbacks clcb = {
|
||||
CLT_dummymain,
|
||||
CLT_GetDropInFlags,
|
||||
CLT_GetDisplayName,
|
||||
CLT_GetDropInName,
|
||||
CLT_GetPanelList,
|
||||
0,
|
||||
0,
|
||||
CLT_GetVersionInfo,
|
||||
CLT_GetFileTypeMappings
|
||||
};
|
||||
|
||||
static int RegisterStaticCmdLinePlugin() {
|
||||
return RegisterStaticPlugin(&clcb);
|
||||
}
|
||||
|
||||
const char *STR12000[100]; // TODO do me later
|
||||
|
||||
static int RegisterCmdLineResources() {
|
||||
return RegisterResource("Command-line strings", 12000, &STR12000);
|
||||
}
|
||||
|
||||
static int special_debug(unsigned char flag, char *) {
|
||||
if (flag) {
|
||||
SetupDebuggingTraps();
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int special_plugin_debug(unsigned char flag, char *) {
|
||||
if (flag) {
|
||||
clState.pluginDebug = 1;
|
||||
return 1;
|
||||
} else {
|
||||
return clState.pluginDebug;
|
||||
}
|
||||
}
|
||||
|
||||
static int special_stdout_base(unsigned char flag, char *) {
|
||||
if (flag) {
|
||||
return 1;
|
||||
} else {
|
||||
return clState.stdoutBase != 0;
|
||||
}
|
||||
}
|
||||
|
||||
struct SpecialOption {
|
||||
const char *name;
|
||||
char **location;
|
||||
int (*callback)(unsigned char a, char *b);
|
||||
};
|
||||
static struct SpecialOption special_options[3] = {
|
||||
{"", 0, special_debug},
|
||||
{"--plugin-debug", 0, special_plugin_debug},
|
||||
{"--stdout", /*TODO clState*/ 0, special_stdout_base}
|
||||
};
|
||||
|
||||
void Main_PreParse(int *pArgc, char ***pArgv) {
|
||||
int i;
|
||||
struct SpecialOption *opt;
|
||||
|
||||
if (*pArgc > 1) {
|
||||
restart:
|
||||
for (i = 0, opt = &special_options[0]; i < 3; i++, opt++) {
|
||||
if (!strcmp(opt->name, (*pArgv)[1])) {
|
||||
if (opt->location) {
|
||||
*opt->location = (*pArgv)[2];
|
||||
opt->callback(1, *opt->location);
|
||||
(*pArgv)[1] = (*pArgv)[0];
|
||||
(*pArgc)--;
|
||||
(*pArgv)++;
|
||||
|
||||
(*pArgv)[1] = (*pArgv)[0];
|
||||
(*pArgc)--;
|
||||
(*pArgv)++;
|
||||
} else {
|
||||
opt->callback(1, 0);
|
||||
(*pArgv)[1] = (*pArgv)[0];
|
||||
(*pArgc)--;
|
||||
(*pArgv)++;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ((*pArgc) > 1 && i < 3)
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
|
||||
void Main_PassSpecialArgs(void *unk1, void *unk2) {
|
||||
int i;
|
||||
struct SpecialOption *opt;
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
opt = &special_options[i];
|
||||
if (opt->callback(0, 0)) {
|
||||
AppendArgumentList(unk1, unk2, opt->name);
|
||||
if (opt->location)
|
||||
AppendArgumentList(unk1, unk2, (*opt->location) ? *opt->location : "");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int MainInitialized;
|
||||
void *gProj;
|
||||
PCmdLine optsCmdLine;
|
||||
PCmdLineEnvir optsEnvir;
|
||||
PCmdLineCompiler optsCompiler;
|
||||
PCmdLineLinker optsLinker;
|
||||
|
||||
int Main_Initialize(int argc, const char **argv) {
|
||||
static char secret[8];
|
||||
char buf[256];
|
||||
|
||||
OS_InitProgram(&argc, &argv);
|
||||
memset(&clState, 0, sizeof(CLState));
|
||||
special_options[0].name = secret;
|
||||
secret[7] = 0;
|
||||
secret[4] = 'b';
|
||||
secret[1] = '-';
|
||||
secret[5] = 'u';
|
||||
secret[2] = 'd';
|
||||
secret[0] = '-';
|
||||
secret[3] = 'e';
|
||||
secret[6] = 'g';
|
||||
|
||||
Main_PreParse(&argc, &argv);
|
||||
clState.argc = argc;
|
||||
clState.argv = argv;
|
||||
// TODO more shite
|
||||
|
||||
MainInitialized = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int Main_Terminate(int code) {
|
||||
if (MainInitialized) {
|
||||
Plugins_Term();
|
||||
License_Terminate();
|
||||
Proj_Terminate(gProj);
|
||||
IO_Terminate();
|
||||
MainInitialized = 0;
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
static int Main_ParseCommandLine() {
|
||||
// TODO: clState, Plugins, gTarg, ...
|
||||
}
|
||||
|
||||
static int Main_SetupParamBlock() {
|
||||
// TODO: OS, PrefPanes, clState, ...
|
||||
PrefPanelsChangedCallback(0);
|
||||
}
|
||||
|
||||
static int Main_ResolveProject() {
|
||||
// TODO: Various project things
|
||||
}
|
||||
|
||||
static int UpdatePCmdLineFromVersion(const PCmdLine *oldVer, PCmdLine *newVer) {
|
||||
static unsigned char warned;
|
||||
short ver = oldVer->version;
|
||||
*newVer = *oldVer;
|
||||
|
||||
// TODO: clState
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int UpdatePCmdLineEnvirFromVersion(const PCmdLineEnvir *oldVer, PCmdLineEnvir *newVer) {
|
||||
static unsigned char warned;
|
||||
short ver = oldVer->version;
|
||||
*newVer = *oldVer;
|
||||
|
||||
// TODO: clState
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int UpdatePCmdLineCompilerFromVersion(const PCmdLineCompiler *oldVer, PCmdLineCompiler *newVer) {
|
||||
static unsigned char warned;
|
||||
short ver = oldVer->version;
|
||||
*newVer = *oldVer;
|
||||
|
||||
// TODO: clState
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int UpdatePCmdLineLinkerFromVersion(const PCmdLineLinker *oldVer, PCmdLineLinker *newVer) {
|
||||
static unsigned char warned;
|
||||
short ver = oldVer->version;
|
||||
*newVer = *oldVer;
|
||||
|
||||
// TODO: clState
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int UpdatePrefPanels(const char *name) {
|
||||
PrefPanel *panel;
|
||||
Handle handle;
|
||||
|
||||
if (!name || !ustrcmp(name, "CmdLine Panel")) {
|
||||
if ((panel = Prefs_FindPanel("CmdLine Panel")) && (handle = PrefPanel_GetHandle(panel))) {
|
||||
if (name) {
|
||||
if (!UpdatePCmdLineFromVersion((PCmdLine *) *handle, &optsCmdLine))
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
CLReportError(91, "CmdLine Panel");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (!name || !ustrcmp(name, "CmdLine Environment")) {
|
||||
if ((panel = Prefs_FindPanel("CmdLine Environment")) && (handle = PrefPanel_GetHandle(panel))) {
|
||||
if (name) {
|
||||
if (!UpdatePCmdLineEnvirFromVersion((PCmdLineEnvir *) *handle, &optsEnvir))
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
CLReportError(91, "CmdLine Environment");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (!name || !ustrcmp(name, "CmdLine Compiler Panel")) {
|
||||
if ((panel = Prefs_FindPanel("CmdLine Compiler Panel")) && (handle = PrefPanel_GetHandle(panel))) {
|
||||
if (name) {
|
||||
if (!UpdatePCmdLineCompilerFromVersion((PCmdLineCompiler *) *handle, &optsCompiler))
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
CLReportError(91, "CmdLine Compiler Panel");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (!name || !ustrcmp(name, "CmdLine Linker Panel")) {
|
||||
if ((panel = Prefs_FindPanel("CmdLine Linker Panel")) && (handle = PrefPanel_GetHandle(panel))) {
|
||||
if (name) {
|
||||
if (!UpdatePCmdLineLinkerFromVersion((PCmdLineLinker *) *handle, &optsLinker))
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
CLReportError(91, "CmdLine Linker Panel");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int SetupCmdLinePrefPanels() {
|
||||
int result;
|
||||
|
||||
PrefPanelsChangedCallback = UpdatePrefPanels;
|
||||
result = Prefs_AddPanel(
|
||||
PrefPanel_New("CmdLine Environment", &optsEnvir, sizeof(PCmdLineEnvir))
|
||||
);
|
||||
result |= (
|
||||
Prefs_AddPanel(PrefPanel_New("CmdLine Panel", 0, sizeof(PCmdLine)))
|
||||
&& Prefs_AddPanel(PrefPanel_New("CmdLine Compiler Panel", 0, sizeof(PCmdLineCompiler)))
|
||||
&& Prefs_AddPanel(PrefPanel_New("CmdLine Linker Panel", 0, sizeof(PCmdLineLinker)))
|
||||
);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static int Main_SetupContext() {
|
||||
// TODO Target, Plugins, clState
|
||||
return 1;
|
||||
}
|
||||
|
||||
jmp_buf exit_program;
|
||||
|
||||
int Main_Driver() {
|
||||
volatile int result;
|
||||
|
||||
result = setjmp(exit_program);
|
||||
if (!result) {
|
||||
if (!SetupCmdLinePrefPanels())
|
||||
CLFatalError("Could not initialize preferences");
|
||||
|
||||
Main_SetupContext();
|
||||
if (!(result = Main_ParseCommandLine())) {
|
||||
if (!(result = Main_SetupParamBlock()))
|
||||
result = Main_ResolveProject();
|
||||
}
|
||||
} else {
|
||||
result = 1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
110
UMain.c
Normal file
110
UMain.c
Normal file
@ -0,0 +1,110 @@
|
||||
#include "UCWInterface.h"
|
||||
|
||||
// 1C40 to 2008
|
||||
|
||||
// TODO move me
|
||||
// TODO move me
|
||||
|
||||
// unsure where this is, may be here, maybe not?
|
||||
extern char cmdline_build_date[32];
|
||||
extern char cmdline_build_time[32];
|
||||
|
||||
int main(int argc, const char **argv) {
|
||||
unsigned long cpu;
|
||||
unsigned long os;
|
||||
unsigned long language;
|
||||
unsigned long plugintype;
|
||||
unsigned long style;
|
||||
int result;
|
||||
|
||||
if (CmdLine_Initialize(argc, argv, CMDLINE_BUILD_DATE, CMDLINE_BUILD_TIME))
|
||||
exit(1);
|
||||
|
||||
if (!RegisterStaticParserResources() || !RegisterStaticTargetResources()) {
|
||||
fprintf(stderr, "\nFATAL ERROR: Could not initialize resource strings\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (!RegisterStaticParserPlugins() || !RegisterStaticTargetPlugins()) {
|
||||
fprintf(stderr, "\nFATAL ERROR: Could not initialize built-in plugins\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (!RegisterStaticParserToolInfo()) {
|
||||
fprintf(stderr, "\nFATAL ERROR: Could not initialize options\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
GetStaticTarget(&cpu, &os);
|
||||
SetBuildTarget(cpu, os);
|
||||
GetStaticPluginType(&language, &plugintype);
|
||||
SetPluginType(language, plugintype);
|
||||
GetStaticParserPluginType(&style);
|
||||
SetParserType(style);
|
||||
|
||||
result = CmdLine_Driver();
|
||||
if (result) {
|
||||
if (result == 2)
|
||||
fprintf(stderr, "\nUser break, cancelled...\n");
|
||||
else
|
||||
fprintf(stderr, "\nErrors caused tool to abort.\n");
|
||||
}
|
||||
CmdLine_Terminate(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
int RegisterResource(const char *name, short index, void *data) {
|
||||
Handle r;
|
||||
|
||||
if (data == 0) {
|
||||
r = GetResource('STR#', index);
|
||||
if (r == 0) {
|
||||
CLFatalError("Resource ('STR#',%d) '%s' not found in executable\n", index, name);
|
||||
return 0;
|
||||
}
|
||||
ReleaseResource(r);
|
||||
return 1;
|
||||
} else {
|
||||
return Res_AddResource(name, index, data);
|
||||
}
|
||||
}
|
||||
|
||||
int RegisterStaticPlugin(const BasePluginCallbacks *cb) {
|
||||
return Plugins_Add(Plugin_New(cb, 0, 0));
|
||||
}
|
||||
|
||||
int RegisterStaticCompilerLinkerPlugin(const BasePluginCallbacks *cb, void *b) {
|
||||
return Plugins_Add(Plugin_New(cb, b, 0));
|
||||
}
|
||||
|
||||
int RegisterStaticParserPlugin(const BasePluginCallbacks *cb, void *b) {
|
||||
return Plugins_Add(Plugin_New(cb, 0, b));
|
||||
}
|
||||
|
||||
void SetBuildTarget(CWDataType cpu, CWDataType os) {
|
||||
clState.cpu = cpu;
|
||||
clState.os = os;
|
||||
}
|
||||
|
||||
void SetParserType(CWDataType style) {
|
||||
clState.style = style;
|
||||
}
|
||||
|
||||
void SetPluginType(CWDataType language, CWDataType plugintype) {
|
||||
clState.language = language;
|
||||
clState.plugintype = plugintype;
|
||||
}
|
||||
|
||||
int CmdLine_Initialize(int argc, const char **argv, const char *buildDate, const char *buildTime) {
|
||||
strncpy(cmdline_build_date, buildDate, sizeof(cmdline_build_date));
|
||||
strncpy(cmdline_build_time, buildTime, sizeof(cmdline_build_time));
|
||||
return Main_Initialize(argc, argv);
|
||||
}
|
||||
|
||||
int CmdLine_Driver() {
|
||||
return Main_Driver();
|
||||
}
|
||||
|
||||
int CmdLine_Terminate(int code) {
|
||||
return Main_Terminate(code);
|
||||
}
|
||||
1918
mwcc_decomp.h
Normal file
1918
mwcc_decomp.h
Normal file
File diff suppressed because it is too large
Load Diff
1
sdk_hdrs/CWDropInPanel.h
Executable file
1
sdk_hdrs/CWDropInPanel.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/CWPluginErrors.h
Executable file
1
sdk_hdrs/CWPluginErrors.h
Executable file
@ -0,0 +1 @@
|
||||
/*
* CWPluginErrors.h - CW_Result constants for plugin errors
*
* Copyright © 1995-1997 Metrowerks, Inc. All rights reserved.
*
*/
#ifndef __CWPluginErrors_H__
#define __CWPluginErrors_H__
#ifdef __MWERKS__
# pragma once
#endif
enum
{
// common errors for all plugins
cwNoErr, /* successful return */
cwErrUserCanceled, /* operation canceled by user */
cwErrRequestFailed, /* generic failure when plugin fails */
cwErrInvalidParameter, /* one or more callback parameters invalid */
cwErrInvalidCallback, /* invalid given current request and plugin type*/
cwErrInvalidMPCallback, /* this request is not support from MP threads */
cwErrOSError, /* OS-specific, call CWGetCallbackOSError() */
cwErrOutOfMemory, /* not enough memory */
cwErrFileNotFound, /* file not found on disk */
cwErrUnknownFile, /* bad file number, doesn't exist */
cwErrSilent, /* request failed but plugin didn't report any */
/* errors and doesn't want IDE to report that */
/* an unknown error occurred */
cwErrCantSetAttribute, /* plugin requested inapplicable file flags in */
/* CWAddProjectEntry */
cwErrStringBufferOverflow, /* an output string buffer was too small */
cwErrDirectoryNotFound, /* unable to find a directory being sought */
cwErrLastCommonError = 512,
// compiler/linker errors
cwErrUnknownSegment, /* bad segment number, doesn't exist */
cwErrSBMNotFound, /* */
cwErrObjectFileNotStored, /* No external object file has been stored */
cwErrLicenseCheckFailed,/* license check failed, error reported by IDE */
cwErrFileSpecNotSpecified, /* a file spec was unspecified */
cwErrFileSpecInvalid, /* a file spec was invalid */
cwErrLastCompilerLinkerError = 1024
};
#endif // __CWPluginErrors_H__
|
||||
1
sdk_hdrs/CWPlugins.h
Executable file
1
sdk_hdrs/CWPlugins.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/CWRuntimeFeatures.h
Executable file
1
sdk_hdrs/CWRuntimeFeatures.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/CWUnixPluginPrefix.h
Executable file
1
sdk_hdrs/CWUnixPluginPrefix.h
Executable file
@ -0,0 +1 @@
|
||||
/*
* CWUnixPluginPrefix.h
*
* Copyright © 1999 Metrowerks, Inc. All rights reserved.
*
*/
#ifndef MW_CWUnixPluginPrefix_H
#define MW_CWUnixPluginPrefix_H
#define CW_USE_PRAGMA_EXPORT 0
#include "CWRuntimeFeatures.h"
#ifdef __MWERKS__
#if !__option(bool)
#ifndef true
#define true 1
#endif
#ifndef false
#define false 0
#endif
#endif
#endif
#endif /* MW_CWUnixPluginPrefix_H */
|
||||
1
sdk_hdrs/CWWinPluginPrefix.h
Executable file
1
sdk_hdrs/CWWinPluginPrefix.h
Executable file
@ -0,0 +1 @@
|
||||
#include <Win32Headers.mch>
#ifndef WIN32
#define WIN32 1
#endif
#define CW_USE_PRAGMA_EXPORT 0
#ifdef __MWERKS__
#if !__option(bool)
#ifndef true
#define true 1
#endif
#ifndef false
#define false 0
#endif
#endif
#endif
|
||||
1
sdk_hdrs/CatTypes.h
Executable file
1
sdk_hdrs/CatTypes.h
Executable file
@ -0,0 +1 @@
|
||||
#ifndef __CATTYPES_H__
#define __CATTYPES_H__
typedef int CatNodeID;
#define NODE_NULL -1
#define NODE_ROOT 0
#define kCatalogClass "CodeWarrior.CatalogModelObject"
#define kFolderClass "CodeWarrior.FolderModelObject"
#define kTrashNodeClass "CodeWarrior.TrashNode"
// internal properties used in the catalog
#define kContentsFolder "ContentsFolder"
#define kClass "Class"
#define kComments "Comments"
#define kFile "File"
#define kNodeLocked "Locked"
#define kModDate "Modified"
#define kName "Name"
#define kID "ID"
#define kFolderSuffix "_Contents"
#define kDefCatalogExt "ctlg"
#define kDefCatalogFolderExt "ctlgf"
// Command group ID for commands in the catalog menu...
const long cmdGroup_CatalogMenu = 10000;
// catalog-specific menu commands to go with those defined by the IDE;
// such as cmd_Cut, cmd_Copy, etc.
const long cmd_CatalogRename = 10000; // plugin commands in the range 10000-10999
const long cmd_CatalogProperties = 10001;
const long cmd_ShowCatalogBrowser = 10002;
const long cmd_ShowCatalogPalette = 10003;
const long cmd_NewCatalog = 10004;
const long cmd_NewFolder = 10005;
const long cmd_OpenCatalog = 10006;
const long cmd_CloseCatalog = 10007;
const long cmd_ImportControls = 10008;
const long cmd_ShowPrevious = 10009;
const long cmd_ShowNext = 10010;
const long cmd_ExpandIndexView = 10011;
const long cmd_CollapseIndexView = 10012;
const long cmd_ToggleIndexView = 10013;
const long cmd_CloseCatalogPalette = 10014;
enum UPDATE_TYPE
{
UPDATE_NONE = 0,
UPDATE_CHILDREN,
UPDATE_DESCENDANTS
};
enum CatTransType
{
CATTRANS_TYPE_UNKNOWN,
CATTRANS_TYPE_ALIAS,
CATTRANS_TYPE_COPY,
CATTRANS_TYPE_DELETE,
CATTRANS_TYPE_DROP,
CATTRANS_TYPE_EDITPROPERTIES,
CATTRANS_TYPE_LOCK,
CATTRANS_TYPE_MOVE,
CATTRANS_TYPE_PASTE,
CATTRANS_TYPE_RENAME,
CATTRANS_TYPE_UNLOCK
};
struct CatWindowData
{
bool fUseDefSize;
bool fUseDefPos;
SIZE size;
POINT pos;
CatWindowData() : fUseDefSize(true), fUseDefPos(true)
{
pos.x = pos.y = 0;
size.cx = size.cy = 0;
}
};
#endif // __CATTYPES_H__
|
||||
1
sdk_hdrs/CompilerMapping.h
Executable file
1
sdk_hdrs/CompilerMapping.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/DropInCompilerLinker.h
Executable file
1
sdk_hdrs/DropInCompilerLinker.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/DropInPanel.h
Executable file
1
sdk_hdrs/DropInPanel.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/DropInPanelWin32.h
Executable file
1
sdk_hdrs/DropInPanelWin32.h
Executable file
@ -0,0 +1 @@
|
||||
/*
DropInPanelWin32.h
This is the old name for the file that is now called CWDropInPanel.h.
It is here for backward compatibility with older panels. New panels
should include CWDropInPanel.h instead.
*/
#ifndef __DROPINPANELWIN32_H__
#define __DROPINPANELWIN32_H__
#include "CWDropInPanel.h"
#endif
|
||||
1
sdk_hdrs/DropInVCS.h
Executable file
1
sdk_hdrs/DropInVCS.h
Executable file
File diff suppressed because one or more lines are too long
1
sdk_hdrs/MWBrowse.h
Executable file
1
sdk_hdrs/MWBrowse.h
Executable file
@ -0,0 +1 @@
|
||||
/*
* MWBrowse.h
*
* Copyright © 1993-96 Metrowerks, Inc. All rights reserved.
*
* Types and constants needed for emitting CodeWarrior
* browse information.
*/
#ifndef __MWBROWSE_H__
#define __MWBROWSE_H__
#ifdef __MWERKS__
#pragma once
#endif
#include "MWLangDefs.h"
#ifdef __MWERKS__
#pragma options align=mac68k
#endif
#ifdef _MSC_VER
#pragma pack(push,2)
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define BROWSE_HEADER 0xBEABBAEB
#define BROWSE_VERSION 2
#define BROWSE_EARLIEST_COMPATIBLE_VERSION 2
typedef struct BrowseHeader {
long browse_header; // always set to BROWSE_HEADER
long browse_version; // always set to BROWSE_VERSION
short browse_language; // the language of this translation unit, enum ELanguage
short uses_name_table; // TRUE: uses name table from CW object code
long earliest_compatible_version;// always set to BROWSE_EARLIEST_COMPATIBLE_VERSION
long reserved[15]; // for future extensions
} BrowseHeader;
typedef unsigned char EBrowserItem;
enum {
browseFunction, // function, procedure, or method
browseGlobal, // global variable
browseClass, // class, struct, or union
browseMacro, // macro
browseEnum, // enum, enumerated type member
browseTypedef, // user-defined type other than class
browseConstant, // constant value
browseTemplate, // C++ template
browsePackage, // Java package
browseCompSymbolStart = 0x70,
browseEnd = 0xFF // used to denote end-of-list
};
// flag constants for functions, member functions, data members
enum
{
kAbstract = 1, // abstract/pure virtual
kStatic = 2, // static member
kFinal = 4, // final Java class, method, or data member
kMember = 8, // item is a class member
// reserve flags 0x10, 0x20, and 0x40 for other general flags
// flags specific to classes
kInterface = 0x80, // class is Java interface
kPublic = 0x100, // class is public Java class
// flags specific to functions and member functions
kInline = 0x80, // inline function
kPascal = 0x100, // pascal function
kAsm = 0x200, // asm function
kVirtual = 0x400, // virtual member function
kCtor = 0x800, // is constructor
kDtor = 0x1000, // is destructor
kNative = 0x2000, // native Java method
kSynch = 0x4000, // synchronized Java method
kIntrinsic = 0x8000, // intrinsic routine (for General Magic)
kConst = 0x10000, // const function
// flags specific to data members
kTransient = 0x80, // transient Java data member
kVolatile = 0x100 // volatile Java data member
};
typedef enum EAccess
{ // can be used as mask values
accessNone = 0,
accessPrivate = 1,
accessProtected = 2,
accessPublic = 4,
accessAll = accessPrivate+accessProtected+accessPublic
} EAccess;
typedef unsigned char EMember;
enum
{
memberFunction, // member function/method
memberData, // data member/field
memberEnd = 0xFF // denotes end-of-list
};
typedef enum ETemplateType
{ // templates are either class or function templates
templateClass,
templateFunction
} ETemplateType;
/********************************************************************************/
/* Old (pre-CW9) browse data support definitions */
/********************************************************************************/
#define BROWSE_OLD_VERSION 0
enum {
BROWSE_SCOPE_STATIC, // local to this file
BROWSE_SCOPE_EXTERN // global to all files
};
enum {
BROWSE_OBJECT_FUNCTION, // function object
BROWSE_OBJECT_DATA // data object
};
enum { // browse data types
BROWSE_END, // end of browse data
BROWSE_OBJECT // a function/data definition
};
typedef struct BrowseObjectDef {
short type; // always BROWSE_OBJECT
short size; // size of following data
char object_type; // one of: (BROWSE_OBJECT_FUNCTION,BROWSE_OBJECT_DATA)
char object_scope; // one of: (BROWSE_SCOPE_STATIC,BROWSE_SCOPE_EXTERN)
long source_offset; // offset of declartation in source code
// char name[...]; followed by padded object name (c-string)
// char classname[...]; followed by padded class name string (c-string)
} BrowseObjectDef;
typedef struct BrowseHeader_Old {
long browse_header; // always set to BROWSE_HEADER
long browse_version; // always set to BROWSE_VERSION
long reserved[14]; // for future extensions
} BrowseHeader_Old;
#ifdef __cplusplus
}
#endif
#ifdef _MSC_VER
#pragma pack(pop)
#endif
#ifdef __MWERKS__
#pragma options align=reset
#endif
#endif // __MWBROWSE_H__
|
||||
1
sdk_hdrs/MWLangDefs.h
Executable file
1
sdk_hdrs/MWLangDefs.h
Executable file
@ -0,0 +1 @@
|
||||
/*
* MWLangDefs.h
*
* Copyright © 1994-1996 metrowerks inc. All rights reserved.
*
* Language constants.
*/
#ifndef MWLangDefs_H
#define MWLangDefs_H
enum ELanguage
{
langUnknown,
langC,
langCPlus,
langPascal,
langObjectPascal,
langJava,
langAssembler, // don't care which assembler
langFortran,
langRez
};
#endif // !MWLangDefs_H
|
||||
3
setup.sh
Normal file
3
setup.sh
Normal file
@ -0,0 +1,3 @@
|
||||
#export MWCIncludes=/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MacOS\ Support/Universal/Interfaces/CIncludes:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C/MSL_Common/Include
|
||||
#export MWCIncludes=/usr/include
|
||||
export MWCIncludes=/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MacOS\ X\ Support/MacHeaders\ Mach-O
|
||||
Loading…
x
Reference in New Issue
Block a user