summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--Arguments.c604
-rw-r--r--CError.c319
-rw-r--r--CInt64.c893
-rw-r--r--CInt64.h85
-rw-r--r--CompilerTools.c1230
-rw-r--r--CompilerTools.h134
-rw-r--r--Help.c564
-rw-r--r--Option.c630
-rw-r--r--PCode.c286
-rw-r--r--PCode.h110
-rw-r--r--PCodeInfo.c55
-rw-r--r--PCodeInfo.h462
-rw-r--r--ParserFace.c226
-rw-r--r--UCLTMain.c384
-rw-r--r--UMain.c110
-rw-r--r--mwcc_decomp.h1918
-rwxr-xr-xsdk_hdrs/CWDropInPanel.h1
-rwxr-xr-xsdk_hdrs/CWPluginErrors.h1
-rwxr-xr-xsdk_hdrs/CWPlugins.h1
-rwxr-xr-xsdk_hdrs/CWRuntimeFeatures.h1
-rwxr-xr-xsdk_hdrs/CWUnixPluginPrefix.h1
-rwxr-xr-xsdk_hdrs/CWWinPluginPrefix.h1
-rwxr-xr-xsdk_hdrs/CatTypes.h1
-rwxr-xr-xsdk_hdrs/CompilerMapping.h1
-rwxr-xr-xsdk_hdrs/DropInCompilerLinker.h1
-rwxr-xr-xsdk_hdrs/DropInPanel.h1
-rwxr-xr-xsdk_hdrs/DropInPanelWin32.h1
-rwxr-xr-xsdk_hdrs/DropInVCS.h1
-rwxr-xr-xsdk_hdrs/MWBrowse.h1
-rwxr-xr-xsdk_hdrs/MWLangDefs.h1
-rw-r--r--setup.sh3
31 files changed, 8027 insertions, 0 deletions
diff --git a/Arguments.c b/Arguments.c
new file mode 100644
index 0000000..2f66ee9
--- /dev/null
+++ b/Arguments.c
@@ -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);
+ }
+}
diff --git a/CError.c b/CError.c
new file mode 100644
index 0000000..5179463
--- /dev/null
+++ b/CError.c
@@ -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) {
+
+}
diff --git a/CInt64.c b/CInt64.c
new file mode 100644
index 0000000..9b793bd
--- /dev/null
+++ b/CInt64.c
@@ -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;
+}
diff --git a/CInt64.h b/CInt64.h
new file mode 100644
index 0000000..37030f9
--- /dev/null
+++ b/CInt64.h
@@ -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); \ No newline at end of file
diff --git a/CompilerTools.c b/CompilerTools.c
new file mode 100644
index 0000000..daba8df
--- /dev/null
+++ b/CompilerTools.c
@@ -0,0 +1,1230 @@
+#include "CompilerTools.h"
+
+static short lheaplockcount;
+static void (*heaperror)();
+static Allocator bheap;
+static Allocator oheap;
+static Allocator aheap;
+static Allocator lheap;
+static Allocator gheap;
+long hash_name_id;
+StringNode **name_hash_nodes;
+void (*GListErrorProc)();
+
+void CompilerGetPString(short index, unsigned char *str) {
+ COS_GetPString(str, 10100, index);
+}
+
+void CompilerGetCString(short index, char *str) {
+ COS_GetString(str, 10100, index);
+}
+
+unsigned char *CTool_CtoPstr(char *input) {
+ char *work = input;
+ int length = 0;
+ int i;
+
+ while (*work) {
+ ++length;
+ ++work;
+ }
+
+ for (i = length; i > 0; i--) {
+ work[0] = work[-1];
+ --work;
+ }
+
+ input[0] = length;
+ return (unsigned char *) input;
+}
+
+static void GListError() {
+ if (GListErrorProc)
+ GListErrorProc();
+}
+
+int InitGList(GList *list, long capacity) {
+ if ((list->data = COS_NewOSHandle(capacity)) == 0)
+ if ((list->data = COS_NewHandle(capacity)) == 0)
+ return -1;
+ list->size = 0;
+ list->expansion = capacity >> 1;
+ list->capacity = capacity;
+ return 0;
+}
+
+void FreeGList(GList *list) {
+ if (list->data != 0) {
+ COS_FreeHandle(list->data);
+ list->data = 0;
+ }
+ list->capacity = 0;
+ list->size = 0;
+}
+
+void LockGList(GList *list) {
+ COS_LockHandleHi(list->data);
+}
+
+void UnlockGList(GList *list) {
+ COS_UnlockHandle(list->data);
+}
+
+void ShrinkGList(GList *list) {
+ COS_ResizeHandle(list->data, list->capacity = list->size);
+}
+
+void AppendGListData(GList *list, const void *data, long size) {
+ if ((list->size + size) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
+ GListError();
+ }
+
+ memcpy(*list->data + list->size, data, size);
+ list->size += size;
+}
+
+void AppendGListNoData(GList *list, long size) {
+ if ((list->size + size) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
+ GListError();
+ }
+
+ list->size += size;
+}
+
+void AppendGListByte(GList *list, char v) {
+ if ((list->size + 1) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += 1 + list->expansion))
+ GListError();
+ }
+
+ (*list->data)[list->size++] = v;
+}
+
+void AppendGListWord(GList *list, short v) {
+ char *p;
+
+ if ((list->size + 2) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += 2 + list->expansion))
+ GListError();
+ }
+
+ p = *list->data + list->size;
+ list->size += 2;
+ *(p++) = ((unsigned char *) &v)[0];
+ *(p++) = ((unsigned char *) &v)[1];
+}
+
+void AppendGListTargetEndianWord(GList *list, short v) {
+ char *p;
+
+ if ((list->size + 2) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += 2 + list->expansion))
+ GListError();
+ }
+
+ p = *list->data + list->size;
+ list->size += 2;
+ *(p++) = ((unsigned char *) &v)[0];
+ *(p++) = ((unsigned char *) &v)[1];
+}
+
+void AppendGListLong(GList *list, long v) {
+ char *p;
+
+ if ((list->size + 4) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += 4 + list->expansion))
+ GListError();
+ }
+
+ p = *list->data + list->size;
+ list->size += 4;
+ *(p++) = ((unsigned char *) &v)[0];
+ *(p++) = ((unsigned char *) &v)[1];
+ *(p++) = ((unsigned char *) &v)[2];
+ *(p++) = ((unsigned char *) &v)[3];
+}
+
+void AppendGListTargetEndianLong(GList *list, long v) {
+ char *p;
+
+ if ((list->size + 4) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += 4 + list->expansion))
+ GListError();
+ }
+
+ p = *list->data + list->size;
+ list->size += 4;
+ *(p++) = ((unsigned char *) &v)[0];
+ *(p++) = ((unsigned char *) &v)[1];
+ *(p++) = ((unsigned char *) &v)[2];
+ *(p++) = ((unsigned char *) &v)[3];
+}
+
+void AppendGListID(GList *list, const char *str) {
+ unsigned long size = strlen(str) + 1;
+ if ((list->size + size) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
+ GListError();
+ }
+
+ memcpy(*list->data + list->size, str, size);
+ list->size += size;
+}
+
+void AppendGListName(GList *list, const char *str) {
+ unsigned long size = strlen(str);
+ if ((list->size + size) > list->capacity) {
+ if (!COS_ResizeHandle(list->data, list->capacity += size + list->expansion))
+ GListError();
+ }
+
+ memcpy(*list->data + list->size, str, size);
+ list->size += size;
+}
+
+void RemoveGListData(GList *list, long size) {
+ list->size -= size;
+ if (list->capacity > (list->size + list->expansion * 2))
+ COS_ResizeHandle(list->data, list->capacity = list->size + list->expansion);
+}
+
+char GetGListByte(GList *list) {
+ unsigned char *p;
+
+ p = (unsigned char *) (*list->data + list->size);
+ list->size++;
+ return p[0];
+}
+
+short GetGListWord(GList *list) {
+ unsigned char *p;
+ union { unsigned char bytes[2]; short s; } data;
+
+ p = (unsigned char *) (*list->data + list->size);
+ list->size += 2;
+ data.bytes[0] = p[0];
+ data.bytes[1] = p[1];
+ return data.s;
+}
+
+long GetGListLong(GList *list) {
+ unsigned char *p;
+ union { unsigned char bytes[4]; long l; } data;
+
+ p = (unsigned char *) (*list->data + list->size);
+ list->size += 4;
+ data.bytes[0] = p[0];
+ data.bytes[1] = p[1];
+ data.bytes[2] = p[2];
+ data.bytes[3] = p[3];
+ return data.l;
+}
+
+short GetGListID(GList *list, char *buf) {
+ short len;
+ char *p;
+
+ len = 1;
+ p = *list->data + list->size;
+ while (*p) {
+ *(buf++) = *(p++);
+ len++;
+ }
+
+ *buf = *p;
+ list->size += len;
+ return len;
+}
+
+void GetGListData(GList *list, char *buf, long size) {
+ memcpy(buf, *list->data + list->size, size);
+ list->size += size;
+}
+
+static long hashpjw(const char *str) {
+ unsigned long work = 0;
+ unsigned long tmp;
+
+ while (*str) {
+ work = (work << 4) + *str;
+ tmp = work & 0xF0000000;
+ if (tmp) {
+ work ^= (tmp >> 24);
+ work ^= tmp;
+ }
+ str++;
+ }
+
+ return work % 0xFFFFFD;
+}
+
+static short PHash(const unsigned char *str) {
+ short result;
+ short counter;
+ unsigned char work;
+ const unsigned char *p;
+
+ result = str[0];
+ result &= 0xFF;
+ p = &str[1];
+ if (str[0]) {
+ counter = result;
+ work = 0;
+ while (counter > 0) {
+ work = (work >> 3) | (work << 5);
+ work += *p;
+ --counter;
+ ++p;
+ }
+
+ result = (result << 8) | work;
+ }
+
+ return result & 0x7FF;
+}
+
+short CHash(const char *str) {
+ /* not matching :( */
+ short result; // orig r4
+ unsigned char work; // orig r5
+ short counter; // orig r3
+
+ // i am: r4 = result, r5 = counter, r3 = work
+
+ if (result = strlen(str) & 0xFF) {
+ counter = result;
+ work = 0;
+ while (counter > 0) {
+ work = (work >> 3) | (work << 5);
+ work = work + *(str++);
+ counter--;
+ }
+ result = (result << 8) | work;
+ }
+
+ return result & 0x7FF;
+}
+
+StringNode *GetHashNameNode(const char *str) {
+ StringNode *node;
+ short hash;
+
+ hash = CHash(str);
+ node = name_hash_nodes[hash];
+ if (node == 0) {
+ node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ name_hash_nodes[hash] = node;
+ node->next = 0;
+ node->index = hash_name_id++;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ for (;;) {
+ if (strcmp(str, node->data) == 0) {
+ if (node->index < 0)
+ node->index = hash_name_id++;
+ return node;
+ }
+
+ if (node->next == 0) {
+ node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ node = node->next;
+ node->next = 0;
+ node->index = hash_name_id++;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ node = node->next;
+ }
+ }
+ }
+}
+
+StringNode *GetHashNameNodeHash(const char *str, short hash) {
+ StringNode *node;
+
+ node = name_hash_nodes[hash];
+ if (node == 0) {
+ node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ name_hash_nodes[hash] = node;
+ node->next = 0;
+ node->index = hash_name_id++;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ for (;;) {
+ if (strcmp(str, node->data) == 0)
+ return node;
+
+ if (node->next == 0) {
+ node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ node = node->next;
+ node->next = 0;
+ node->index = hash_name_id++;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ node = node->next;
+ }
+ }
+ }
+}
+
+StringNode *GetHashNameNodeHash2(const char *str, short hash) {
+ StringNode *node;
+
+ node = name_hash_nodes[hash];
+ if (node == 0) {
+ node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ name_hash_nodes[hash] = node;
+ node->next = 0;
+ node->index = -1;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ for (;;) {
+ if (strcmp(str, node->data) == 0)
+ return node;
+
+ if (node->next == 0) {
+ node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ node = node->next;
+ node->next = 0;
+ node->index = -1;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ node = node->next;
+ }
+ }
+ }
+}
+
+StringNode *GetHashNameNodeExport(const char *str) {
+ // not matching
+ StringNode *node;
+ short hash;
+
+ hash = CHash(str);
+ if ((node = name_hash_nodes[hash]) == 0) {
+ node = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ name_hash_nodes[hash] = node;
+ node->next = 0;
+ node->index = -1;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ for (;;) {
+ if (strcmp(str, node->data) == 0)
+ return node;
+
+ if (node->next == 0) {
+ node->next = (StringNode *) galloc(strlen(str) + sizeof(StringNode));
+ node = node->next;
+ node->next = 0;
+ node->index = -1;
+ node->hash = hash;
+ strcpy(node->data, str);
+ return node;
+ } else {
+ node = node->next;
+ }
+ }
+ }
+}
+
+long GetHashNameNodeExportID(StringNode *node) {
+ if (node->index < 0)
+ node->index = hash_name_id++;
+ return node->index;
+}
+
+StringNode *GetHashNameNodeByID(long id) {
+ StringNode *node;
+ short i;
+
+ for (i = 0; i < 2048; i++) {
+ for (node = name_hash_nodes[i]; node; node = node->next) {
+ if (id == node->index)
+ return node;
+ }
+ }
+
+ return 0;
+}
+
+void NameHashExportReset() {
+ short i;
+ StringNode *node;
+
+ for (i = 0; i < 0x800; i++) {
+ node = name_hash_nodes[i];
+ while (node) {
+ node->index = -1;
+ node = node->next;
+ }
+ }
+
+ hash_name_id = 1;
+}
+
+void NameHashWriteNameTable(GList *list) {
+ StringNode *node;
+ StringNode **nodes;
+ short grp;
+ int i;
+
+ nodes = (StringNode **) galloc(sizeof(StringNode *) * hash_name_id);
+
+ for (grp = 0; grp < 0x800; grp++) {
+ node = name_hash_nodes[grp];
+ while (node) {
+ if (node->index > 0)
+ nodes[node->index] = node;
+ node = node->next;
+ }
+ }
+
+ for (i = 1; i < hash_name_id; i++) {
+ node = nodes[i];
+ AppendGListWord(list, node->hash);
+ AppendGListID(list, node->data);
+ }
+
+ if (list->size & 1)
+ AppendGListByte(list, 0);
+}
+
+void NameHashWriteTargetEndianNameTable(GList *list) {
+ StringNode *node;
+ StringNode **nodes;
+ short grp;
+ int i;
+
+ nodes = (StringNode **) galloc(sizeof(StringNode *) * hash_name_id);
+ memclrw(nodes, sizeof(StringNode *) * hash_name_id);
+
+ for (grp = 0; grp < 0x800; grp++) {
+ node = name_hash_nodes[grp];
+ while (node) {
+ if (node->index > 0)
+ nodes[node->index] = node;
+ node = node->next;
+ }
+ }
+
+ for (i = 1; i < hash_name_id; i++) {
+ node = nodes[i];
+ if (node == 0) {
+ AppendGListTargetEndianWord(list, 0);
+ AppendGListID(list, "");
+ } else {
+ AppendGListTargetEndianWord(list, node->hash);
+ AppendGListID(list, node->data);
+ }
+ }
+
+ if (list->size & 1)
+ AppendGListByte(list, 0);
+}
+
+void InitNameHash() {
+ name_hash_nodes = (StringNode **) galloc(0x800 * sizeof(StringNode *));
+ memclrw(name_hash_nodes, 0x800 * sizeof(StringNode *));
+ hash_name_id = 1;
+}
+
+long CTool_TotalHeapSize() {
+ long total = 0;
+ AllocatorBlock *block;
+
+ for (block = gheap.blockList; block; block = block->nextBlock) {
+ total += block->size;
+ }
+ for (block = lheap.blockList; block; block = block->nextBlock) {
+ total += block->size;
+ }
+ for (block = aheap.blockList; block; block = block->nextBlock) {
+ total += block->size;
+ }
+ for (block = oheap.blockList; block; block = block->nextBlock) {
+ total += block->size;
+ }
+ for (block = bheap.blockList; block; block = block->nextBlock) {
+ total += block->size;
+ }
+
+ return total;
+}
+
+static void getheapinfo(HeapInfo *result, Allocator *heap) {
+ AllocatorBlock *block;
+
+ result->_4 = heap->paddingSize;
+ for (block = heap->blockList; block; block = block->nextBlock) {
+ result->_8 += block->size - sizeof(AllocatorBlock);
+ result->xx_C += block->remaining;
+ result->_0++;
+ if (block->remaining > result->_18)
+ result->_18 = block->remaining;
+ }
+
+ result->_10 = result->_8 / result->_0;
+ result->_14 = result->xx_C / result->_0;
+}
+
+void CTool_GetHeapInfo(HeapInfo *result, unsigned char heapID) {
+ memclrw(result, sizeof(HeapInfo));
+
+ switch (heapID) {
+ case 0:
+ getheapinfo(result, &gheap);
+ break;
+ case 1:
+ getheapinfo(result, &lheap);
+ break;
+ case 2:
+ getheapinfo(result, &aheap);
+ break;
+ case 3:
+ getheapinfo(result, &oheap);
+ break;
+ case 4:
+ getheapinfo(result, &bheap);
+ break;
+ case 5:
+ getheapinfo(result, &gheap);
+ getheapinfo(result, &lheap);
+ getheapinfo(result, &aheap);
+ getheapinfo(result, &oheap);
+ getheapinfo(result, &bheap);
+ break;
+ }
+}
+
+static void MoreHeapSpace(Allocator *alloc, long size) {
+ Handle blockHandle;
+ long blockSize;
+ AllocatorBlock *block;
+
+ block = alloc->blockList;
+ if (block) {
+ alloc->lastBlockUsed->remaining = alloc->remaining;
+ while (block) {
+ if (block->remaining >= size)
+ goto gotBlock;
+ block = block->nextBlock;
+ }
+ }
+
+ /* create new block */
+ blockSize = size + alloc->paddingSize;
+ if (systemHandles) {
+ blockHandle = COS_NewOSHandle(blockSize << 1);
+ if (blockHandle != 0)
+ goto createdTempDoubleBlock;
+ blockHandle = COS_NewOSHandle(blockSize);
+ if (blockHandle != 0)
+ goto createdBlock;
+ }
+ blockHandle = COS_NewHandle(blockSize);
+ if (blockHandle != 0)
+ goto createdBlock;
+
+ if (heaperror)
+ heaperror();
+ return;
+
+ createdTempDoubleBlock:
+ blockSize <<= 1;
+ goto createdBlock;
+ createdBlock:
+ COS_LockHandleHi(blockHandle);
+ block = (AllocatorBlock *) *blockHandle;
+ block->nextBlock = alloc->blockList;
+ alloc->blockList = block;
+ block->handle = blockHandle;
+ block->size = blockSize;
+ block->remaining = blockSize - sizeof(AllocatorBlock);
+ gotBlock:
+ alloc->lastBlockUsed = block;
+ alloc->remaining = block->remaining;
+ alloc->ptrToFreeArea = ((char *) block) + block->size - block->remaining;
+}
+
+int initheaps(heaperror_t failureCallback) {
+ heaperror = 0;
+ lheaplockcount = 0;
+
+ memclrw(&gheap, sizeof(Allocator));
+ memclrw(&lheap, sizeof(Allocator));
+ memclrw(&aheap, sizeof(Allocator));
+ memclrw(&oheap, sizeof(Allocator));
+ memclrw(&bheap, sizeof(Allocator));
+
+ gheap.paddingSize = 0x38000;
+ lheap.paddingSize = 0x10000;
+ aheap.paddingSize = 0x4000;
+ oheap.paddingSize = 0x40000;
+ bheap.paddingSize = 0x4000;
+
+ MoreHeapSpace(&gheap, 0);
+ MoreHeapSpace(&lheap, 0);
+ MoreHeapSpace(&aheap, 0);
+ MoreHeapSpace(&oheap, 0);
+ MoreHeapSpace(&bheap, 0);
+
+ gheap.paddingSize = 0x8000;
+ lheap.paddingSize = 0x8000;
+
+ heaperror = failureCallback;
+
+ if (!gheap.lastBlockUsed || !lheap.lastBlockUsed || !aheap.lastBlockUsed || !oheap.lastBlockUsed || !bheap.lastBlockUsed)
+ return -1;
+ else
+ return 0;
+}
+
+int initgheap(heaperror_t failureCallback) {
+ heaperror = 0;
+ lheaplockcount = 0;
+
+ memclrw(&gheap, sizeof(Allocator));
+ memclrw(&lheap, sizeof(Allocator));
+ memclrw(&aheap, sizeof(Allocator));
+ memclrw(&oheap, sizeof(Allocator));
+ memclrw(&bheap, sizeof(Allocator));
+
+ gheap.paddingSize = 0x38000;
+ MoreHeapSpace(&gheap, 0);
+ gheap.paddingSize = 0x8000;
+
+ heaperror = failureCallback;
+
+ if (!gheap.lastBlockUsed)
+ return -1;
+ else
+ return 0;
+}
+
+heaperror_t getheaperror() {
+ return heaperror;
+}
+
+void setheaperror(heaperror_t failureCallback) {
+ heaperror = failureCallback;
+}
+
+static void relheap(Allocator *alloc) {
+ AllocatorBlock *block;
+ Handle handle;
+
+ block = alloc->blockList;
+ while (block) {
+ handle = block->handle;
+ block = block->nextBlock;
+ COS_FreeHandle(handle);
+ }
+
+ memclrw(alloc, sizeof(Allocator));
+}
+
+void releaseheaps() {
+ relheap(&gheap);
+ relheap(&lheap);
+ relheap(&aheap);
+ relheap(&oheap);
+ relheap(&bheap);
+}
+
+void releasegheap() {
+ relheap(&gheap);
+}
+
+void releaseoheap() {
+ relheap(&gheap);
+ oheap.paddingSize = 0x40000;
+ MoreHeapSpace(&oheap, 0);
+}
+
+char *galloc(long size) {
+ long alignedSize;
+ char *ptr;
+
+ alignedSize = (size & ~7) + 8;
+ if (gheap.remaining < alignedSize)
+ MoreHeapSpace(&gheap, alignedSize);
+
+ gheap.remaining -= alignedSize;
+ ptr = (char *) gheap.ptrToFreeArea;
+ gheap.ptrToFreeArea = ptr + alignedSize;
+ return ptr;
+}
+
+char *lalloc(long size) {
+ long alignedSize;
+ char *ptr;
+
+ alignedSize = (size & ~7) + 8;
+ if (lheap.remaining < alignedSize)
+ MoreHeapSpace(&lheap, alignedSize);
+
+ lheap.remaining -= alignedSize;
+ ptr = (char *) lheap.ptrToFreeArea;
+ lheap.ptrToFreeArea = ptr + alignedSize;
+ return ptr;
+}
+
+char *aalloc(long size) {
+ long alignedSize;
+ char *ptr;
+
+ alignedSize = (size & ~7) + 8;
+ if (aheap.remaining < alignedSize)
+ MoreHeapSpace(&aheap, alignedSize);
+
+ aheap.remaining -= alignedSize;
+ ptr = (char *) aheap.ptrToFreeArea;
+ aheap.ptrToFreeArea = ptr + alignedSize;
+ return ptr;
+}
+
+char *oalloc(long size) {
+ long alignedSize;
+ char *ptr;
+
+ alignedSize = (size & ~7) + 8;
+ if (oheap.remaining < alignedSize)
+ MoreHeapSpace(&oheap, alignedSize);
+
+ oheap.remaining -= alignedSize;
+ ptr = (char *) oheap.ptrToFreeArea;
+ oheap.ptrToFreeArea = ptr + alignedSize;
+ return ptr;
+}
+
+char *balloc(long size) {
+ long alignedSize;
+ char *ptr;
+
+ alignedSize = (size & ~7) + 8;
+ if (bheap.remaining < alignedSize)
+ MoreHeapSpace(&bheap, alignedSize);
+
+ bheap.remaining -= alignedSize;
+ ptr = (char *) bheap.ptrToFreeArea;
+ bheap.ptrToFreeArea = ptr + alignedSize;
+ return ptr;
+}
+
+void locklheap() {
+ lheaplockcount++;
+}
+
+void unlocklheap() {
+ if (lheaplockcount > 0)
+ --lheaplockcount;
+}
+
+void freelheap() {
+ AllocatorBlock *block;
+
+ if (lheaplockcount == 0) {
+ block = lheap.blockList;
+ lheap.lastBlockUsed = block;
+ lheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
+ lheap.remaining = block->size - sizeof(AllocatorBlock);
+
+ while (block) {
+ block->remaining = block->size - sizeof(AllocatorBlock);
+ block = block->nextBlock;
+ }
+ }
+}
+
+void freeaheap() {
+ AllocatorBlock *block;
+
+ block = aheap.blockList;
+ aheap.lastBlockUsed = block;
+ aheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
+ aheap.remaining = block->size - sizeof(AllocatorBlock);
+
+ while (block) {
+ block->remaining = block->size - sizeof(AllocatorBlock);
+ block = block->nextBlock;
+ }
+}
+
+void freeoheap() {
+ AllocatorBlock *block;
+
+ block = oheap.blockList;
+ oheap.lastBlockUsed = block;
+ oheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
+ oheap.remaining = block->size - sizeof(AllocatorBlock);
+
+ while (block) {
+ block->remaining = block->size - sizeof(AllocatorBlock);
+ block = block->nextBlock;
+ }
+}
+
+void freebheap() {
+ AllocatorBlock *block;
+
+ block = bheap.blockList;
+ bheap.lastBlockUsed = block;
+ bheap.ptrToFreeArea = ((char *) block) + sizeof(AllocatorBlock);
+ bheap.remaining = block->size - sizeof(AllocatorBlock);
+
+ while (block) {
+ block->remaining = block->size - sizeof(AllocatorBlock);
+ block = block->nextBlock;
+ }
+}
+
+char *ScanHex(char *str, long *output, Boolean *overflow) {
+ long work;
+ int ch;
+
+ work = 0;
+ *overflow = 0;
+
+ for (;;) {
+ ch = *str;
+ if (ch >= '0' && ch <= '9') {
+ ch = ch - '0';
+ } else if (ch >= 'A' && ch <= 'F') {
+ ch = ch - 'A' + 10;
+ } else if (ch >= 'a' && ch <= 'f') {
+ ch = ch - 'a' + 10;
+ } else {
+ break;
+ }
+
+ if (work & 0xF0000000)
+ *overflow = 1;
+ work = (work << 4) | (short) ch;
+ ++str;
+ }
+
+ *output = work;
+ return str;
+}
+
+char *ScanOct(char *str, long *output, Boolean *overflow) {
+ short digit;
+ long work;
+
+ work = 0;
+ *overflow = 0;
+
+ for (;;) {
+ digit = *str - '0';
+ if (digit >= 0 && digit <= 9) {
+ if (digit >= 8) {
+ *overflow = 1;
+ ++str;
+ break;
+ }
+ } else {
+ break;
+ }
+
+ if (work & 0xE0000000)
+ *overflow = 1;
+ work = (work << 3) | digit;
+ ++str;
+ }
+
+ *output = work;
+ return str;
+}
+
+char *ScanDec(char *str, long *output, Boolean *overflow) {
+ short digit;
+ unsigned long work;
+
+ work = 0;
+ *overflow = 0;
+
+ for (;;) {
+ digit = *str - '0';
+ if (digit >= 0 && digit <= 9) {
+ if (work >= 0x19999999 && (work > 0x19999999 || digit > 5))
+ *overflow = 1;
+ } else {
+ break;
+ }
+
+ work = (work << 3) + (work << 1) + digit;
+ ++str;
+ }
+
+ *output = work;
+ return str;
+}
+
+static char *UnmangleClassname(char *work, char **pNameStart, short *pNameLength, char **a4, short *a5, Boolean a6) {
+ char ch;
+ short len;
+ char *p2;
+ short len2;
+ short i;
+ short wtf;
+
+ *pNameLength = 0;
+ if (*(work++) != '_')
+ return work;
+ if (*(work++) != '_') {
+ return work;
+ } else {
+ len = 0;
+ while (work[0] >= '0' && work[0] <= '9') {
+ len = (len * 10) + work[0] - '0';
+ ++work;
+ }
+
+ if (len > 0) {
+ *pNameStart = work;
+ *pNameLength = len;
+
+ if (a6) {
+ p2 = *a4;
+ len2 = *a5;
+ i = 0;
+ wtf = len;
+ while (i < wtf && len2 < 255) {
+ *(p2++) = work[i];
+ ++i;
+ ++len2;
+ }
+ if (len2 < 255) {
+ *(p2++) = ':';
+ len2++;
+ }
+ if (len2 < 255) {
+ *(p2++) = ':';
+ len2++;
+ }
+ *a4 = p2;
+ *a5 = len2;
+ }
+ }
+
+ return work + len;
+ }
+}
+
+static char *UnmangleAppend(char *src, char srcLen, char **pOutput, short *pOutputLen) {
+ char *output;
+ short i;
+ short outputLen;
+
+ output = *pOutput;
+ outputLen = *pOutputLen;
+
+ for (i = 0; i < srcLen && outputLen < 255; i++, outputLen++) {
+ *(output++) = src[i];
+ }
+
+ *pOutput = output;
+ *pOutputLen = outputLen;
+}
+
+void OldUnmangle(char *input, char *output, Boolean flag) {
+ short var26;
+ char *nameStart;
+ short nameLength;
+ char *saved;
+ int i;
+
+ if (*input == '.')
+ ++input;
+
+ var26 = 0;
+ saved = input;
+ if (input[0] == '_' && input[1] == '_') {
+ if (input[2] == 'c' && input[3] == 't') {
+ saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
+ if (nameLength == 0)
+ goto invalid;
+ UnmangleAppend(nameStart, nameLength, &output, &var26);
+ } else if (input[2] == 'd' && input[3] == 't') {
+ saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
+ if (nameLength == 0)
+ goto invalid;
+ if (var26 <= 255) {
+ *(output++) = '~';
+ var26++;
+ }
+ UnmangleAppend(nameStart, nameLength, &output, &var26);
+ } else if (input[2] == 'n' && input[3] == 'w') {
+ saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
+ UnmangleAppend("operator new", 15, &output, &var26);
+ } else if (input[2] == 'd' && input[3] == 'l') {
+ saved = UnmangleClassname(&input[4], &nameStart, &nameLength, &output, &var26, flag);
+ UnmangleAppend("operator delete", 15, &output, &var26);
+ } else {
+ invalid:
+ strncpy(output, input, 256);
+ return;
+ }
+ } else {
+ i = 0;
+ while (*saved) {
+ ++saved;
+ ++i;
+ if (saved[0] == '_' && saved[1] == '_') {
+ saved = UnmangleClassname(saved, &nameStart, &nameLength, &output, &var26, flag);
+ break;
+ }
+ }
+ UnmangleAppend(input, i, &output, &var26);
+ }
+
+ if (flag && saved[0] == 'F') {
+ if (saved[1] == 'v') {
+ UnmangleAppend("(void)", 6, &output, &var26);
+ } else {
+ UnmangleAppend("(...)", 5, &output, &var26);
+ }
+ }
+
+ *output = 0;
+}
+
+short hash(char *str) {
+ char hash = 0;
+
+ while (*str) {
+ hash = hash << 1;
+ hash ^= *(str++);
+ }
+
+ return hash & 0x7F;
+}
+
+void memclr(void *buffer, long size) {
+ memset(buffer, 0, size);
+}
+
+void memclrw(void *buffer, long size) {
+ memset(buffer, 0, size);
+}
+
+void CToLowercase(char *src, char *dst) {
+ char ch;
+
+ do {
+ ch = tolower(*(src++));
+ *(dst++) = ch;
+ } while (ch);
+}
+
+int getbit(long v) {
+ switch (v) {
+ case 0: return -1;
+ case 1: return 0;
+ case 2: return 1;
+ case 4: return 2;
+ case 8: return 3;
+ case 0x10: return 4;
+ case 0x20: return 5;
+ case 0x40: return 6;
+ case 0x80: return 7;
+ case 0x100: return 8;
+ case 0x200: return 9;
+ case 0x400: return 10;
+ case 0x800: return 11;
+ case 0x1000: return 12;
+ case 0x2000: return 13;
+ case 0x4000: return 14;
+ case 0x8000: return 15;
+ case 0x10000: return 16;
+ case 0x20000: return 17;
+ case 0x40000: return 18;
+ case 0x80000: return 19;
+ case 0x100000: return 20;
+ case 0x200000: return 21;
+ case 0x400000: return 22;
+ case 0x800000: return 23;
+ case 0x1000000: return 24;
+ case 0x2000000: return 25;
+ case 0x4000000: return 26;
+ case 0x8000000: return 27;
+ case 0x10000000: return 28;
+ case 0x20000000: return 29;
+ case 0x40000000: return 30;
+ case 0x80000000: return 31;
+ default: return -2;
+ }
+}
+
+void CTool_EndianConvertWord64(WtfWord64 value, unsigned long long *p) {
+ union { unsigned char bytes[8]; WtfWord64 w; } data;
+ data.w.a = value.a;
+ data.w.b = value.b;
+ memcpy(p, data.bytes, 8);
+}
+
+unsigned short CTool_EndianConvertInPlaceWord16Ptr(unsigned short *p) {
+ unsigned short v;
+ v = *p;
+ // this probably has a conversion on non-ppc
+ *p = v;
+ return v;
+}
+
+unsigned long CTool_EndianConvertInPlaceWord32Ptr(unsigned long *p) {
+ unsigned long v;
+ v = *p;
+ // this probably has a conversion on non-ppc
+ *p = v;
+ return v;
+}
+
+void CTool_EndianConvertVector128() {
+ // not correct but idc
+}
+
+StringNode *CTool_GetPathName(const FSSpec *spec, long *mdDat) {
+ char buffer[256];
+ COS_FileGetPathName(buffer, spec, mdDat);
+ return GetHashNameNodeExport(buffer);
+}
+
+Boolean strcat_safe(char *dst, const char *src, int maxLen) {
+ int len;
+ char ch;
+
+ len = strlen(dst);
+ dst += len;
+ maxLen -= len;
+ if (maxLen < 0)
+ return 1;
+
+ while (maxLen != 0) {
+ ch = *(dst++) = *(src++);
+ if (ch == 0)
+ break;
+ --maxLen;
+ }
+
+ if (maxLen == 0 && dst[-1]) {
+ dst[-1] = 0;
+ return 1;
+ } else {
+ return 0;
+ }
+}
diff --git a/CompilerTools.h b/CompilerTools.h
new file mode 100644
index 0000000..5c6607e
--- /dev/null
+++ b/CompilerTools.h
@@ -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);
diff --git a/Help.c b/Help.c
new file mode 100644
index 0000000..d54ab71
--- /dev/null
+++ b/Help.c
@@ -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);
+}
diff --git a/Option.c b/Option.c
new file mode 100644
index 0000000..4a09705
--- /dev/null
+++ b/Option.c
@@ -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);
+}
diff --git a/PCode.c b/PCode.c
new file mode 100644
index 0000000..d677e22
--- /dev/null
+++ b/PCode.c
@@ -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;
+ }
+}
diff --git a/PCode.h b/PCode.h
new file mode 100644
index 0000000..601cfdc
--- /dev/null
+++ b/PCode.h
@@ -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();
diff --git a/PCodeInfo.c b/PCodeInfo.c
new file mode 100644
index 0000000..9d469bc
--- /dev/null
+++ b/PCodeInfo.c
@@ -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;
+}
diff --git a/PCodeInfo.h b/PCodeInfo.h
new file mode 100644
index 0000000..9e3b048
--- /dev/null
+++ b/PCodeInfo.h
@@ -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);
diff --git a/ParserFace.c b/ParserFace.c
new file mode 100644
index 0000000..7ce84e5
--- /dev/null
+++ b/ParserFace.c
@@ -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;
+}
diff --git a/UCLTMain.c b/UCLTMain.c
new file mode 100644
index 0000000..7da89af
--- /dev/null
+++ b/UCLTMain.c
@@ -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;
+}
+
diff --git a/UMain.c b/UMain.c
new file mode 100644
index 0000000..717eee1
--- /dev/null
+++ b/UMain.c
@@ -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);
+}
diff --git a/mwcc_decomp.h b/mwcc_decomp.h
new file mode 100644
index 0000000..f0bd518
--- /dev/null
+++ b/mwcc_decomp.h
@@ -0,0 +1,1918 @@
+#pragma once
+#include <MacHeadersMach-O>
+#define macintosh
+#include "sdk_hdrs/CompilerMapping.h"
+#include "sdk_hdrs/DropInCompilerLinker.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/********************************/
+/* OS Garbage */
+typedef struct OSPathSpec {
+ char s[256];
+} OSPathSpec;
+typedef struct OSNameSpec {
+ char s[64];
+} OSNameSpec;
+typedef struct OSSpec {
+ OSPathSpec path;
+ OSNameSpec name;
+} OSSpec;
+typedef struct OSHandle {
+ void *addr;
+ unsigned long used;
+ unsigned long size;
+} OSHandle;
+typedef struct {
+ OSSpec spec;
+ OSHandle hand;
+ unsigned char loaded;
+ unsigned char changed;
+ unsigned char writeable;
+} OSFileHandle; // assumed name
+
+/********************************/
+/* Option Fuckery */
+#ifdef __MWERKS__
+#pragma options align=packed
+#endif
+typedef struct PARAM_T {
+ char which;
+ char flags;
+ char *myname;
+ struct PARAM_T *next;
+} PARAM_T;
+typedef struct MASK_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char size;
+ unsigned long ormask;
+ unsigned long andmask;
+ void *num;
+} MASK_T;
+typedef struct STRING_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ short maxlen;
+ unsigned char pstring;
+ char *str;
+} STRING_T;
+typedef struct SET_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char size;
+ unsigned long value;
+ char *num;
+} SET_T;
+typedef struct SETSTRING_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char *value;
+ char pstring;
+ void *var;
+} SETSTRING_T;
+typedef struct GENERIC_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ void (*parse)(); // TODO missing sig
+ void *var;
+ char *help;
+} GENERIC_T;
+typedef struct SETTING_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ void (*parse)(); // TODO missing sig
+ char *valuename;
+} SETTING_T;
+typedef struct TOGGLE_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char size;
+ unsigned long mask;
+ void *num;
+} TOGGLE_T;
+typedef struct NUM_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char size;
+ char fit;
+ unsigned long lo;
+ unsigned long hi;
+ void *num;
+} NUM_T;
+typedef struct FILEPATH_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ char fflags;
+ char *defaultstr;
+ void *filename;
+ int maxlen;
+} FILEPATH_T;
+typedef struct IFARG_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ PARAM_T *parg;
+ char *helpa;
+ PARAM_T *pnone;
+ char *helpn;
+} IFARG_T;
+typedef struct ONOFF_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ unsigned char *var;
+} ONOFF_T;
+typedef struct OFFON_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ unsigned char *var;
+} OFFON_T;
+typedef struct FTYPE_T {
+ char which;
+ char flags;
+ char *myname;
+ PARAM_T *next;
+ unsigned long *fc;
+ unsigned char iscreator;
+} FTYPE_T;
+typedef struct OptionList {
+ char *help;
+ int flags;
+ struct Option **list;
+} OptionList;
+typedef struct Option {
+ char *names;
+ int avail;
+ PARAM_T *param;
+ OptionList *sub;
+ OptionList *conflicts;
+ char *help;
+} Option;
+enum {
+ HELPFLAGS_1 = 1,
+ HELPFLAGS_IGNORED = 2,
+ HELPFLAGS_OBSOLETE = 4,
+ HELPFLAGS_DEPRECATED = 8,
+ HELPFLAGS_SECRET = 0x10,
+ HELPFLAGS_MEANINGLESS = 0x20,
+ HELPFLAGS_COMPATIBLE = 0x40,
+ HELPFLAGS_NORMAL = 0x80, // andmask = 0xE?
+ HELPFLAGS_SPACES = 0x100,
+ HELPFLAGS_TOOL = 0x200,
+ HELPFLAGS_TOOL_THIS = 0x400,
+ HELPFLAGS_TOOL_OTHER = 0x800,
+ HELPFLAGS_TOOL_BOTH = 0xC00,
+ HELPFLAGS_1000 = 0x1000,
+ HELPFLAGS_2000 = 0x2000,
+ HELPFLAGS_USAGE = 0x4000,
+ HELPFLAGS_8000 = 0x8000,
+ HELPFLAGS_10000 = 0x10000,
+ HELPFLAGS_20000 = 0x20000,
+ HELPFLAGS_40000 = 0x40000,
+ HELPFLAGS_80000 = 0x80000,
+ HELPFLAGS_100000 = 0x100000,
+ HELPFLAGS_200000 = 0x200000,
+ HELPFLAGS_400000 = 0x400000,
+ HELPFLAGS_700000 = 0x700000,
+ HELPFLAGS_800000 = 0x800000,
+ HELPFLAGS_801828 = 0x801828,
+ HELPFLAGS_1000000 = 0x1000000,
+ HELPFLAGS_2000000 = 0x2000000,
+ HELPFLAGS_4000000 = 0x4000000,
+ HELPFLAGS_8000000 = 0x8000000,
+ HELPFLAGS_10000000 = 0x10000000,
+ HELPFLAGS_20000000 = 0x20000000,
+ HELPFLAGS_40000000 = 0x40000000,
+ HELPFLAGS_80000000 = 0x80000000
+};
+enum {
+ OTF_GLOBAL = 1,
+ OTF2 = 2,
+ OTF_CASED = 4,
+ OTF_OBSOLETE = 8,
+ OTF_SUBSTITUTED = 0x10,
+ OTF_DEPRECATED = 0x20,
+ OTF_TOOL_LINKER = 0x40,
+ OTF_TOOL_DISASSEMBLER = 0x80,
+ OTF_TOOL_COMPILER = 0x100,
+ OTF_TOOL_MASK = OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_TOOL_COMPILER,
+ OTF200 = 0x200,
+ OTF400 = 0x400,
+ OTF700 = 0x700,
+ OTF_IGNORED = 0x800,
+ OTFC00 = 0xC00,
+ OTF_SECRET = 0x1000,
+ OTF2000 = 0x2000,
+ OTF_COMPATIBILITY = 0x4000,
+ OTF8000 = 0x8000,
+ OTF10000 = 0x10000,
+ OTF20000 = 0x20000,
+ OTF40000 = 0x40000,
+ OTF_WARNING = 0x80000,
+ OTF_SLFLAGS_8 = 0x100000,
+ OTF_SLFLAGS_10 = 0x200000,
+ OTF_SLFLAGS_20 = 0x400000,
+ OTF_SLFLAGS_MASK = OTF_SLFLAGS_8 | OTF_SLFLAGS_10 | OTF_SLFLAGS_20,
+ OTF_MEANINGLESS = 0x800000,
+ OTF_ALL_HIDDEN_BY_DEFAULT = OTF_OBSOLETE | OTF_DEPRECATED | OTF_IGNORED | OTF_SECRET | OTF_MEANINGLESS,
+ OTF1000000 = 0x1000000,
+ OTF2000000 = 0x2000000,
+ OTF4000000 = 0x4000000,
+ OTF8000000 = 0x8000000,
+ OTF10000000 = 0x10000000,
+ OTF20000000 = 0x20000000,
+ OTF40000000 = 0x40000000,
+ OTF80000000 = 0x80000000
+};
+
+enum {
+ PARAMWHICH_None = 0,
+ PARAMWHICH_FTypeCreator = 1,
+ PARAMWHICH_FilePath = 2,
+ PARAMWHICH_Number = 3,
+ PARAMWHICH_String = 4,
+ PARAMWHICH_5 = 5,
+ PARAMWHICH_6 = 6,
+ PARAMWHICH_OnOff = 7,
+ PARAMWHICH_OffOn = 8,
+ PARAMWHICH_Mask = 9,
+ PARAMWHICH_Toggle = 0xA,
+ PARAMWHICH_Set = 0xB,
+ PARAMWHICH_SetString = 0xC,
+ PARAMWHICH_Generic = 0xD,
+ PARAMWHICH_IfArg = 0xE,
+ PARAMWHICH_Setting = 0xF
+};
+enum {
+ PARAMFLAGS_1 = 1,
+ PARAMFLAGS_2 = 2,
+ PARAMFLAGS_3 = 3,
+ PARAMFLAGS_4 = 4,
+ PARAMFLAGS_8 = 8
+};
+enum {
+ SLFLAGS_1 = 1,
+ SLFLAGS_2 = 2,
+ SLFLAGS_4 = 4, // displays =...
+ SLFLAGS_8 = 8, // displays [no] -- produces e.g. [no]err[or] | [no]iserr[or], [no]implicit[conv]
+ SLFLAGS_10 = 0x10, // displays [-]
+ SLFLAGS_20 = 0x20, // displays [no-]
+ SLFLAGS_40 = 0x40
+};
+enum {
+ LISTFLAGS_NONE = 0,
+ LISTFLAGS_4 = 4,
+ LISTFLAGS_COMPILER = 0x100,
+ LISTFLAGS_LINKER = 0x200,
+ LISTFLAGS_DISASSEMBLER = 0x400,
+ LISTFLAGS_TOOL_MASK = LISTFLAGS_COMPILER | LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER
+};
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+
+struct IDEAccessPath {
+ FSSpec pathSpec;
+ unsigned char recursive;
+ long subdirectoryCount;
+ FSSpec *subdirectories;
+};
+
+struct IDEAccessPathList {
+ long userPathCount;
+ struct IDEAccessPath *userPaths;
+ long systemPathCount;
+ struct IDEAccessPath *systemPaths;
+ unsigned char alwaysSearchUserPaths;
+ unsigned char convertPaths;
+};
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct CWObjectFlags {
+ short version;
+ long flags;
+ const char *objFileExt;
+ const char *brsFileExt;
+ const char *ppFileExt;
+ const char *disFileExt;
+ const char *depFileExt;
+ const char *pchFileExt;
+ CWDataType objFileCreator;
+ CWDataType objFileType;
+ CWDataType brsFileCreator;
+ CWDataType brsFileType;
+ CWDataType ppFileCreator;
+ CWDataType ppFileType;
+ CWDataType disFileCreator;
+ CWDataType disFileType;
+ CWDataType depFileCreator;
+ CWDataType depFileType;
+} CWObjectFlags;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+struct CW_BasePluginCallbacks {
+ void (*cbGetFileInfo)();
+ void (*cbFindAndLoadFile)();
+ void (*cbGetFileText)();
+ void (*cbReleaseFileText)();
+ void (*cbGetSegmentInfo)();
+ void (*cbGetOverlay1GroupInfo)();
+ void (*cbGetOverlay1Info)();
+ void (*cbGetOverlay1FileInfo)();
+ void (*cbReportMessage)();
+ void (*cbAlert)();
+ void (*cbShowStatus)();
+ void (*cbUserBreak)();
+ void (*cbGetNamedPreferences)();
+ void (*cbStorePluginData)();
+ void (*cbGetPluginData)();
+ void (*cbSetModDate)();
+ void (*cbAddProjectEntry)();
+ void (*cbCreateNewTextDocument)();
+ void (*cbAllocateMemory)();
+ void (*cbFreeMemory)();
+ void (*cbAllocMemHandle)();
+ void (*cbFreeMemHandle)();
+ void (*cbGetMemHandleSize)();
+ void (*cbResizeMemHandle)();
+ void (*cbLockMemHandle)();
+ void (*cbUnlockMemHandle)();
+ void *cbInternal[8];
+ void (*cbGetTargetName)();
+ void (*cbCacheAccessPathList)();
+ void (*cbPreDialog)();
+ void (*cbPostDialog)();
+ void (*cbPreFileAction)();
+ void (*cbPostFileAction)();
+ void (*cbCheckoutLicense)();
+ void (*cbCheckinLicense)();
+ void (*cbResolveRelativePath)();
+};
+
+struct CWPluginPrivateContext {
+ long request;
+ long apiVersion;
+ void *shellContext;
+ void *pluginStorage;
+ FSSpec projectFile;
+ FSSpec outputFileDirectory;
+ long shellSignature;
+ long pluginType;
+ long numFiles;
+ long numOverlayGroups;
+ short callbackOSError;
+ short pluginOSError;
+ CWIDEInfo *shellInfo;
+ struct IDEAccessPathList *accessPathList;
+ long dontEatEvents;
+ struct FSSpec *targetDataDirectorySpec;
+ long reserved[17];
+ struct CW_BasePluginCallbacks *callbacks;
+};
+
+// Pref panels
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct PCmdLine {
+ short version;
+ short state;
+ short stages;
+ short toDisk;
+ short outNameOwner;
+ unsigned char dryRun;
+ unsigned char debugInfo;
+ short verbose;
+ unsigned char showLines;
+ unsigned char timeWorking;
+ unsigned char noWarnings;
+ unsigned char warningsAreErrors;
+ unsigned short maxErrors;
+ unsigned short maxWarnings;
+ short msgStyle;
+ unsigned char noWrapOutput;
+ unsigned char stderr2stdout;
+ unsigned char noCmdLineWarnings;
+} PCmdLine;
+typedef struct PCmdLineCompiler {
+ short version;
+ unsigned char noSysPath;
+ unsigned char noFail;
+ short includeSearch;
+ char linkerName[64];
+ char objFileExt[15];
+ char brsFileExt[15];
+ char ppFileExt[15];
+ char disFileExt[15];
+ char depFileExt[15];
+ char pchFileExt[15];
+ CWDataType objFileCreator;
+ CWDataType objFileType;
+ CWDataType brsFileCreator;
+ CWDataType brsFileType;
+ CWDataType ppFileCreator;
+ CWDataType ppFileType;
+ CWDataType disFileCreator;
+ CWDataType disFileType;
+ CWDataType depFileCreator;
+ CWDataType depFileType;
+ unsigned char compileIgnored;
+ unsigned char relPathInOutputDir;
+ unsigned char browserEnabled;
+ unsigned char depsOnlyUserFiles;
+ char outMakefile[256];
+ char forcePrecompile;
+ unsigned char ignoreMissingFiles;
+ unsigned char printHeaderNames;
+ char sbmState;
+ char sbmPath[256];
+ unsigned char canonicalIncludes;
+ unsigned char keepObjects;
+} PCmdLineCompiler;
+typedef struct PCmdLineLinker {
+ short version;
+ unsigned char callPreLinker;
+ unsigned char callPostLinker;
+ unsigned char keepLinkerOutput;
+ unsigned char callLinker;
+} PCmdLineLinker;
+typedef struct PCmdLineEnvir {
+ short version;
+ short cols;
+ short rows;
+ unsigned char underIDE;
+} PCmdLineEnvir;
+typedef struct PBackEnd {
+ short version;
+ unsigned char structalignment;
+ unsigned char tracebacktables;
+ unsigned char processor;
+ unsigned char readonlystrings;
+ unsigned char profiler;
+ unsigned char fpcontract;
+ unsigned char schedule;
+ unsigned char peephole;
+ unsigned char processorspecific;
+ unsigned char altivec;
+ unsigned char vrsave;
+ unsigned char autovectorize;
+ unsigned char usebuiltins;
+ unsigned char pic;
+ unsigned char dynamic;
+ unsigned char common;
+ unsigned char implicit_templates;
+ unsigned char reserved[3];
+} PBackEnd;
+typedef struct PDisassembler {
+ short version;
+ unsigned char showcode;
+ unsigned char extended;
+ unsigned char mix;
+ unsigned char nohex;
+ unsigned char showdata;
+ unsigned char showexceptions;
+ unsigned char showsym;
+ unsigned char shownames;
+} PDisassembler;
+typedef struct PMachOLinker {
+ short version;
+ unsigned char linksym;
+ unsigned char symfullpath;
+ unsigned char suppresswarn;
+ unsigned char linkmap;
+ unsigned char multisymerror;
+ unsigned char whatfileloaded;
+ unsigned char whyfileloaded;
+ unsigned char use_objectivec_semantics;
+ char undefinedsymbols;
+ char readonlyrelocs;
+ char reserved_value1;
+ char reserved_value2;
+ short exports;
+ short reserved_short1;
+ unsigned long currentversion;
+ unsigned long compatibleversion;
+ long reserved_long1;
+ char mainname[64];
+ unsigned char prebind;
+ unsigned char dead_strip;
+ unsigned char twolevel_namespace;
+ unsigned char strip_debug_symbols;
+} PMachOLinker;
+typedef struct PMachOProject {
+ short version;
+ short type;
+ unsigned char outfile[64];
+ long filecreator;
+ long filetype;
+ long stacksize;
+ long stackaddress;
+ unsigned long reserved1;
+ unsigned long reserved2;
+ unsigned long reserved3;
+ unsigned long reserved4;
+ unsigned long reserved5;
+ unsigned long reserved6;
+ unsigned long reserved7;
+ unsigned long reserved8;
+ unsigned long reserved9;
+ unsigned long reserved10;
+ unsigned long reserved11;
+ unsigned long reserved12;
+ unsigned long reserved13;
+ unsigned long reserved14;
+ unsigned long reserved15;
+ unsigned long reserved16;
+ unsigned long reserved17;
+ unsigned long reserved18;
+ unsigned long reserved19;
+ unsigned long reserved20;
+ unsigned char flatrsrc;
+ unsigned char filler1;
+ unsigned char filler2;
+ unsigned char filler3;
+ unsigned char separateflatfile[64];
+ unsigned char installpath[256];
+} PMachOProject;
+typedef struct {
+ short version;
+ unsigned char userSetCreator;
+ unsigned char userSetType;
+ unsigned char gPrintMapToStdOutput;
+ unsigned char mapfilename[256];
+ unsigned char symfilename[256];
+} PCLTExtras;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+typedef struct CWCommandLineArgs {
+ int argc;
+ char **argv;
+ char **envp;
+} CWCommandLineArgs;
+
+typedef struct VersionInfo {
+ unsigned short major;
+ unsigned short minor;
+ unsigned short patch;
+ unsigned short build;
+} VersionInfo;
+
+typedef struct CLPluginInfo {
+ unsigned long plugintype;
+ unsigned long language;
+ long dropinflags;
+ char *version;
+ unsigned char storeCommandLine;
+} CLPluginInfo;
+
+typedef struct ToolVersionInfo {
+ char *company;
+ char *product;
+ char *tool;
+ char *copyright;
+ char *version;
+} ToolVersionInfo;
+
+// may not actually be named this
+struct ParseOptsType {
+ CWPluginContext context;
+ char helpKey[64];
+ long helpFlags;
+ unsigned short ioCols;
+ unsigned short ioRows;
+ CWCommandLineArgs *args;
+ ToolVersionInfo *toolVersion;
+ int numPlugins;
+ CLPluginInfo *plugins;
+ int numPanels;
+ char **panelNames;
+ unsigned long cpu;
+ unsigned long os;
+ char lastoutputname[256];
+ long currentSegment;
+ long currentOverlayGroup;
+ long currentOverlay;
+ int possibleFiles;
+ int userSpecifiedFiles;
+ int unusedFiles;
+ unsigned char hadAnyOutput;
+ unsigned char hadErrors;
+ unsigned char showHelp;
+ unsigned char underIDE;
+ unsigned char alwaysUsePaths;
+ unsigned char noOptions;
+ unsigned char printedVersion;
+ unsigned char passingArgs;
+ unsigned char disToFile;
+ unsigned char ppToFile;
+ unsigned char initBefore;
+ unsigned char weakImport;
+ unsigned char mergeIntoOutput;
+ unsigned char success;
+ unsigned char ignoreUnknown;
+ unsigned char unused[2];
+};
+
+// assumed name
+typedef struct CLState {
+ int argc;
+ const char **argv;
+ CWDataType cpu;
+ CWDataType os;
+ CWDataType plugintype;
+ CWDataType language;
+ CWDataType style;
+ OSSpec programPath;
+ const char *programName;
+ short numWarnings;
+ short numErrors;
+ Boolean pluginDebug;
+ Boolean userBreak;
+ Boolean reachedWarningThreshold;
+ Boolean reachedErrorThreshold;
+ OSSpec makefileSpec;
+ OSPathSpec sbmPathSpec;
+ OSHandle browseHandle;
+ const char *stdoutBase;
+ int appendToStdoutBase;
+} CLState;
+
+typedef struct OSFileTypeMapping {
+ CWDataType mactype;
+ const char *magic;
+ char length;
+ const char *mimetype;
+ char executable; // not sure why this is rearranged
+} OSFileTypeMapping;
+
+typedef struct OSFileTypeMappingList {
+ short numMappings;
+ const OSFileTypeMapping *mappings;
+} OSFileTypeMappingList;
+
+typedef struct BasePluginCallbacks {
+ short (*main)();
+ short (*GetDropInFlags)(const DropInFlags **flags, long *flagsSize);
+ short (*GetDisplayName)(const char **displayName);
+ short (*GetDropInName)(const char **dropInName);
+ short (*GetPanelList)(const CWPanelList **panelList);
+ short (*GetFamilyList)(const CWFamilyList **familyList);
+ short (*GetHelpInfo)(const CWHelpInfo **helpInfo);
+ short (*GetVersionInfo)(const VersionInfo **versionInfo);
+ short (*GetFileTypeMappings)(const OSFileTypeMappingList **mappingList);
+} BasePluginCallbacks;
+
+typedef struct CompilerLinkerPluginCallbacks {
+ short (*GetTargetList)(const struct CWTargetList **targetList);
+ short (*GetDefaultMappingList)();
+ short (*Unmangle)();
+ short (*BrSymbolEntryPoint)();
+ short (*GetObjectFlags)();
+ short (*WriteObjectFile)();
+} CompilerLinkerPluginCallbacks;
+
+typedef struct ParserPluginCallbacks {
+ short (*SupportsPlugin)();
+ short (*SupportsPanels)();
+} ParserPluginCallbacks;
+
+typedef struct {
+ char *name;
+ void *ptr;
+ long size;
+} PrefDataPanel; // assumed name
+
+typedef struct {
+ CWDataType TYPE;
+ CWDataType LANG;
+ CWDataType CPU;
+ CWDataType OS;
+ int numPrefPanels;
+ char **prefPanels;
+ char *toolInfo;
+ char *copyright;
+ int numOptionLists;
+ OptionList **optionLists;
+ int numPrefDataPanels;
+ PrefDataPanel *prefDataPanels;
+ int (*PreParse)(); // sig?
+ int (*MidParse)(); // sig?
+ int (*PostParse)(); // sig?
+} ParserTool; // assumed name
+
+typedef struct PrefPanel { // assumed name
+ char *name;
+ Handle data;
+ Handle workData;
+ struct PrefPanel *next;
+} PrefPanel; // assumed name
+
+// CLAccessPaths
+typedef struct Paths {
+ struct Path **array;
+ unsigned short capacity;
+ unsigned short count;
+} Paths; // assumed name
+typedef struct Frameworks {
+ struct Framework **array;
+ unsigned short capacity;
+ unsigned short count;
+} Frameworks; // assumed name
+typedef struct Path {
+ OSPathSpec *spec;
+ Paths *subpaths;
+ int x8;
+ short xC;
+} Path; // assumed name
+typedef struct Framework {
+ OSSpec frameworkSpec;
+ OSPathSpec name;
+ OSPathSpec version;
+ Path *containingPath;
+ Boolean flag344;
+} Framework; // assumed name
+
+// CLFiles
+typedef struct File {
+ struct File *next;
+ int index;
+ // TODO fill me up
+} File;
+typedef struct Files {
+ File *files;
+ int count;
+} Files; // assumed name
+typedef struct VFile {
+ char name[32];
+ Handle hand;
+ struct VFile *next;
+} VFile; // assumed name
+
+// CLOverlays
+typedef struct Overlay {
+ char name[256];
+ int *fileIDList;
+ int fileCount;
+ int fileCapacity;
+ struct Overlay *next;
+} Overlay; // assumed name
+typedef struct OvlGroup {
+ char name[256];
+ CWAddr64 addr;
+ Overlay *overlays;
+ Overlay *lastOverlay;
+ int overlayCount;
+ struct OvlGroup *next;
+} OvlGroup; // assumed name
+typedef struct Overlays {
+ OvlGroup *groups;
+ OvlGroup *lastGroup;
+} Overlays; // assumed name
+
+// CLSegs
+typedef struct Segment {
+ char name[32];
+ short attributes;
+} Segment; // assumed name
+typedef struct Segments {
+ Segment **array;
+ unsigned short capacity;
+ unsigned short count;
+} Segments; // assumed name
+
+// CLDependencies
+typedef struct Incls {
+ struct Target *target;
+ // ...
+ Paths *paths;
+} Incls; // assumed name
+typedef struct Deps {
+ int x0;
+ int x4;
+ int x8;
+ Incls *incls;
+} Deps; // assumed name
+
+// CLTarg
+typedef struct Target {
+ int count0;
+ int count4;
+ int count8;
+ int countC;
+ CWTargetInfo *targetInfo;
+ Segments segments;
+ Overlays overlays;
+ int x28;
+ Files accessPathFiles;
+ Files files2;
+ Incls incls;
+ Paths systemPaths;
+ Paths userPaths;
+ CWDataType language;
+ CWDataType cpu;
+ CWDataType os;
+ char name[64];
+ struct Plugin *preLinker;
+ struct Plugin *linker;
+ struct Plugin *postLinker;
+ unsigned long preLinkerFlags;
+ unsigned long linkerFlags;
+ unsigned long postLinkerFlags;
+ OSPathSpec cwd;
+ VFile *vfiles;
+ struct Target *next;
+} Target; // assumed name
+
+typedef struct Plugin {
+ BasePluginCallbacks *cb;
+ CompilerLinkerPluginCallbacks *clcb;
+ ParserPluginCallbacks *pcb;
+ void *context;
+ char *versionInfoASCII;
+ struct Plugin *next;
+} Plugin;
+
+typedef struct Token {
+ int x0;
+ void *x4;
+} Token;
+
+/********************************/
+/* UMain.c */
+extern int main(int argc, const char **argv);
+extern int RegisterResource(const char *name, short index, void *data);
+extern int RegisterStaticPlugin(const BasePluginCallbacks *cb);
+extern int RegisterStaticCompilerLinkerPlugin(const BasePluginCallbacks *cb, void *b);
+extern int RegisterStaticParserPlugin(const BasePluginCallbacks *cb, void *b);
+extern void SetBuildTarget(CWDataType cpu, CWDataType os);
+extern void SetParserType(CWDataType style);
+extern void SetPluginType(CWDataType language, CWDataType plugintype);
+extern int CmdLine_Initialize(int argc, const char **argv, const char *buildDate, const char *buildTime);
+extern int CmdLine_Driver();
+extern int CmdLine_Terminate(int code);
+
+/********************************/
+/* UCLTMain.c */
+extern void Main_PreParse(int *pArgc, char ***pArgv);
+extern void Main_PassSpecialArgs(void *unk1, void *unk2);
+extern int Main_Initialize(int argc, const char **argv);
+extern int Main_Terminate(int code);
+extern int Main_Driver();
+
+/********************************/
+/* Resources.c */
+
+/********************************/
+/* ?? CL Errors */
+//static void CLGetErrorString(short errid, char *buffer);
+//static void CLMessageReporter(int kind, short errid, va_list ap);
+extern void CLReportError(short errid, ...);
+extern void CLReportWarning(short errid, ...);
+extern void CLReport(short errid, ...);
+extern void CLReportOSError(short errid, long err, ...);
+extern void CLReportCError(short errid, long err, ...);
+extern void CLInternalError(const char *filename, int linenum, const char *format, ...);
+extern void CLFatalError(const char *format, ...);
+
+/********************************/
+/* ?? Res */
+extern void Res_Initialize();
+extern void Res_AddResource(const char *name, short id, const void *data);
+extern const char *Res_GetResource(short listIndex, short strId);
+extern void Res_Cleanup();
+
+/********************************/
+/* CLPlugins.c */
+//static void GetToolVersionInfo();
+extern const ToolVersionInfo *Plugin_GetToolVersionInfo();
+//static const char *Plugin_GetDisplayName(Plugin *plugin);
+extern const char *Plugin_GetDropInName(Plugin *plugin);
+extern VersionInfo *Plugin_GetVersionInfo(Plugin *plugin);
+extern const char *Plugin_GetVersionInfoASCII(Plugin *plugin);
+extern DropInFlags *Plugin_GetDropInFlags(Plugin *plugin);
+extern CWDataType Plugin_GetPluginType(Plugin *plugin);
+extern const CWTargetList *Plugin_CL_GetTargetList(Plugin *plugin);
+extern const CWPanelList *Plugin_GetPanelList(Plugin *plugin);
+extern const CWExtMapList *Plugin_CL_GetExtMapList(Plugin *plugin);
+extern const OSFileTypeMappingList *Plugin_GetFileTypeMappingList(Plugin *plugin);
+extern const CWObjectFlags *Plugin_CL_GetObjectFlags(Plugin *plugin);
+extern Boolean Plugin_MatchesName(Plugin *plugin, const char *name);
+extern Boolean Plugin_CL_MatchesTarget(Plugin *plugin, CWDataType cpu, CWDataType os, Boolean flag);
+extern Boolean Plugins_CL_HaveMatchingTargets(Plugin *a, Plugin *b, Boolean flag);
+//static CL_MatchesExtMapping(CWExtensionMapping *em, CWDataType type, const char *extension, Boolean flag);
+extern Boolean Plugin_CL_MatchesFileType(Plugin *plugin, CWDataType type, const char *extension, Boolean flag);
+extern Boolean Plugin_MatchesType(Plugin *plugin, CWDataType plugintype, CWDataType edit_language, Boolean flag);
+extern Boolean Plugin_Pr_MatchesPlugin(Plugin *plugin, void *unk1, void *unk2, void *unk3); // fixme
+extern Boolean Plugin_Pr_MatchesPanels(Plugin *plugin, void *unk1, void *unk2); // fixme
+extern Boolean Plugin_CL_WriteObjectFile(Plugin *plugin, FSSpec *fss1, FSSpec *fss2, CWDataType creator, CWDataType filetype, Handle h);
+extern Boolean Plugin_CL_GetCompilerMapping(Plugin *plugin, CWDataType type, const char *extension, CompilerMappingFlags *flags);
+//static Boolean SupportedPlugin(Plugin *plugin, const char **errmsg);
+//static Boolean VerifyPanels(Plugin *plugin);
+extern Plugin *Plugin_New(const BasePluginCallbacks *cb, const CompilerLinkerPluginCallbacks *clcb, const ParserPluginCallbacks *pcb);
+extern void Plugin_Free(Plugin *plugin);
+extern int Plugin_VerifyPanels(Plugin *plugin);
+extern void Plugins_Init();
+extern void Plugins_Term();
+extern int Plugins_Add(Plugin *plugin);
+extern Plugin *Plugins_MatchName(Plugin *first, const char *name);
+extern Plugin *Plugins_CL_MatchTarget(Plugin *first, CWDataType cpu, CWDataType os, CWDataType plugintype, CWDataType edit_language);
+extern Plugin *Plugins_CL_MatchFileType(Plugin *first, CWDataType type, const char *extension, Boolean flag);
+extern Plugin *Plugins_GetPluginForFile(Plugin *first, CWDataType plugintype, CWDataType cpu, CWDataType os, CWDataType type, const char *extension);
+extern Plugin *Plugins_GetLinker(Plugin *first, CWDataType cpu, CWDataType os);
+extern Plugin *Plugins_GetPreLinker(Plugin *first, CWDataType cpu, CWDataType os);
+extern Plugin *Plugins_GetPostLinker(Plugin *first, CWDataType cpu, CWDataType os);
+extern Plugin *Plugins_GetParserForPlugin(...); // TODO fixme args
+extern Plugin *Plugins_GetCompilerForLinker(Plugin *first, Plugin *linker, CWDataType type, const char *extension, CWDataType edit_language);
+extern Boolean Plugins_GetPluginList(Plugin *first, int *count, void **list); // TODO fixme define list struct
+extern Boolean Plugins_GetPrefPanelUnion(Plugin *first, int *count, void **list); // TODO fixme define struct
+extern Boolean Plugin_AddFileTypeMappings(Plugin *plugin, void *unk);
+extern Boolean Plugins_AddFileTypeMappingsForTarget(Plugin *first, void *unk, CWDataType cpu, CWDataType os);
+extern short Plugin_Call(Plugin *plugin, void *context);
+
+/********************************/
+/* ?? parser_cb */
+
+/********************************/
+/* CLIO.c */
+
+/********************************/
+/* CLToolExec.c */
+
+/********************************/
+/* OS TU 1 */
+typedef struct uOSTypePair { // unknown name
+ short a;
+ short b;
+} uOSTypePair;
+extern const char *OS_GetErrText(int errnum);
+extern int OS_InitProgram(int *pArgc, const char ***pArgv);
+extern int OS_TermProgram();
+extern int OS_Create(const OSSpec *spec, const uOSTypePair *type);
+extern int OS_Status(const OSSpec *spec);
+extern int OS_GetFileType(const OSSpec *spec, uOSTypePair *type);
+extern int OS_SetFileType(const OSSpec *spec, const uOSTypePair *type);
+extern int OS_GetFileTime(const OSSpec *spec, time_t *ctime, time_t *mtime);
+extern int OS_SetFileTime(const OSSpec *spec, const time_t *ctime, const time_t *mtime);
+extern int OS_Open(const OSSpec *spec, unsigned short mode, int *pRef);
+extern int OS_Write(int ref, const void *data, long *pLen);
+extern int OS_Read(int ref, void *data, long *pLen);
+extern int OS_Seek(int ref, unsigned short how, long offset);
+extern int OS_Tell(int ref, long *pOffset);
+extern int OS_Close(int ref);
+extern int OS_GetSize(int ref, long *pSize);
+extern int OS_SetSize(int ref, long size);
+extern int OS_Delete(const OSSpec *spec);
+extern int OS_Rename(const OSSpec *a, const OSSpec *b);
+extern int OS_Mkdir(const OSSpec *spec);
+extern int OS_Rmdir(const OSPathSpec *spec);
+extern int OS_Chdir(const OSPathSpec *spec);
+extern int OS_GetCWD(OSPathSpec *spec);
+extern int OS_Execute(); // TODO figure out the args for this properly
+extern int OS_IsLegalPath(const char *str);
+extern int OS_IsFullPath(const char *str);
+extern char *OS_GetDirPtr(OSPathSpec *spec);
+//extern int OS_CompactPath(const char *spec, char *dest);
+extern int OS_EqualPath(const char *a, const char *b);
+extern int OS_CanonPath(const char *src, char *dest);
+extern int OS_MakeSpec(const char *path, OSSpec *spec, Boolean *pFlag);
+extern int OS_MakeFileSpec(const char *path, OSSpec *spec);
+extern int OS_MakePathSpec(const char *a, const char *b, OSPathSpec *spec);
+extern int OS_MakeNameSpec(const char *src, OSNameSpec *spec);
+extern int OS_GetRootSpec(OSPathSpec *spec);
+extern char *OS_SpecToString(const OSSpec *spec, char *output, int maxlen);
+extern char *OS_PathSpecToString(const OSPathSpec *spec, char *output, int maxlen);
+extern char *OS_NameSpecToString(const OSNameSpec *spec, char *output, int maxlen);
+extern int OS_SizeOfPathSpec(const OSPathSpec *spec);
+extern int OS_SizeOfNameSpec(const OSNameSpec *spec);
+extern int OS_EqualSpec(const OSSpec *a, const OSSpec *b);
+extern int OS_EqualPathSpec(const OSPathSpec *a, const OSPathSpec *b);
+extern int OS_EqualNameSpec(const OSNameSpec *a, const OSNameSpec *b);
+extern int OS_IsDir(const OSSpec *spec);
+extern int OS_IsFile(const OSSpec *spec);
+extern int OS_IsLink(const OSSpec *spec);
+extern int OS_ResolveLink(const OSSpec *src, OSSpec *dest);
+extern int OS_OpenDir(const OSPathSpec *spec, void *data); // TODO arg type
+extern int OS_ReadDir(void *data, OSSpec *spec, OSNameSpec *nameSpec, Boolean *pFlag);
+extern int OS_CloseDir(void *data); // TODO arg type
+extern long OS_GetMilliseconds();
+extern time_t OS_GetTime(time_t *p);
+extern int OS_NewHandle(unsigned long size, OSHandle *hand);
+extern int OS_ResizeHandle(OSHandle *hand, unsigned long newSize);
+extern void *OS_LockHandle(OSHandle *hand);
+extern void OS_UnlockHandle(OSHandle *hand);
+extern int OS_FreeHandle(OSHandle *hand);
+extern int OS_GetHandleSize(OSHandle *hand, unsigned long *pSize);
+extern void OS_InvalidateHandle(OSHandle *handle);
+extern Boolean OS_ValidHandle(OSHandle *handle);
+extern short OS_MacError(int err);
+extern void OS_TimeToMac(time_t t, unsigned long *pMacTime);
+extern time_t OS_MacToTime(unsigned long macTime, time_t *p);
+extern short OS_RefToMac(int ref);
+extern int OS_MacToRef(short macRef);
+extern int OS_OpenLibrary(const char *a, int *p);
+extern int OS_GetLibrarySymbol(void *a, void *b, int *p);
+extern int OS_CloseLibrary(void *a);
+extern int OS_LoadMacResourceFork(const OSSpec *spec, void **unkA, void **unkB);
+extern int OS_IsMultiByte(const char *str, int offset);
+extern char *strcatn(char *dst, const char *src, int maxlen);
+extern char *strcpyn(char *dst, const char *src, int maxlen);
+extern int ustrcmp(const char *a, const char *b);
+extern int ustrncmp(const char *a, const char *b, int maxlen);
+
+/********************************/
+/* OS TU 2 */
+extern int WildCardMatch(const char *a, const char *b);
+extern OSSpec *OS_MatchPath(const char *path);
+extern char *OS_GetFileNamePtr(char *path);
+extern char *OS_GetDirName(const OSPathSpec *spec, char *buf, int bufsize);
+extern int OS_MakeSpec2(const char *a, const char *b, OSSpec *spec);
+extern int OS_MakeSpecWithPath(const char *pathSpec, const char *str, Boolean flag, OSSpec *spec);
+extern int OS_NameSpecChangeExtension(OSNameSpec *nameSpec, const char *newExt, Boolean flag);
+extern int OS_NameSpecSetExtension(OSNameSpec *nameSpec, const char *newExt);
+extern char *OS_CompactPaths(char *str, const char *a, const char *b, int lenmaybe);
+extern char *OS_SpecToStringRelative(const OSSpec *spec, const OSPathSpec *pathSpec, char *outbuf, int outlen);
+extern int OS_FindFileInPath(const char *filename, const char *paths, OSSpec *spec);
+extern int OS_FindProgram(const char *path, OSSpec *spec);
+extern int OS_CopyHandle(OSHandle *src, OSHandle *dest);
+extern int OS_AppendHandle(OSHandle *hand, const void *data, long size);
+
+/********************************/
+/* CLProj.c */
+typedef struct Proj {
+ Target *target;
+ OSPathSpec projDir;
+ OSNameSpec projName;
+} Proj;
+extern int Proj_Initialize(Proj *proj);
+extern int Proj_Terminate(Proj *proj);
+
+/********************************/
+/* ?? License */
+extern void License_Initialize();
+extern void License_Terminate();
+extern long License_Checkout();
+extern void License_Refresh();
+extern void License_Checkin();
+extern void License_AutoCheckin();
+
+/********************************/
+/* ?? 'x' funcs */
+extern void *xmalloc(const char *str, size_t amount);
+extern void *xcalloc(const char *str, size_t amount);
+extern void *xrealloc(const char *str, void *curPtr, size_t amount);
+extern char *xstrdup(const char *str);
+extern void xfree(void *ptr);
+
+/********************************/
+/* CLPluginRequests.cpp */
+extern Boolean SendParserRequest(
+ Plugin *plugin,
+ Target *target,
+ CWCommandLineArgs *args,
+ CWDataType cpu,
+ CWDataType os,
+ int numPlugin,
+ void *pluginInfo,
+ int numPanels,
+ void *panelNames,
+ void *pluginArgs,
+ void *panelArgs,
+ const char *cmdlineBuildDate,
+ const char *cmdlineBuildTime,
+ ToolVersionInfo *toolVersionInfo
+ );
+extern Boolean SendCompilerRequest(Plugin *plugin, File *file, short request);
+extern Boolean SendTargetInfoRequest(Target *target, Plugin *plugin, int flags);
+extern Boolean SendLinkerRequest(Plugin *plugin, int flags, CWTargetInfo *targetInfo);
+extern Boolean SendDisassemblerRequest(Plugin *plugin, File *file);
+extern Boolean SendInitOrTermRequest(Plugin *plugin, Boolean action);
+
+/********************************/
+/* ?? LM funcs */
+extern unsigned long LMGetTicks();
+extern unsigned long LMGetTime();
+extern short LMGetMemErr();
+extern void LMSetMemErr(short err);
+
+/********************************/
+/* CLFileOps.c */
+extern int GetOutputFile(); // TODO args
+extern int StoreObjectFile(); // TODO args
+extern int CompileFilesInProject();
+extern int LinkProject();
+
+/********************************/
+/* CLPrefs.c */
+extern PrefPanel *PrefPanel_New(const char *name, void *data, long dataSize);
+extern Handle PrefPanel_GetHandle(PrefPanel *panel);
+extern int PrefPanel_PutHandle(PrefPanel *panel, Handle handle);
+extern void Prefs_Initialize();
+extern void Prefs_Terminate();
+extern Boolean Prefs_AddPanel(PrefPanel *panel);
+extern PrefPanel *Prefs_FindPanel(const char *name);
+
+/********************************/
+/* CLTarg.c */
+extern Target *Target_New(const char *name, CWDataType cpu, CWDataType os, CWDataType language);
+extern void Target_Free(Target *target);
+extern void Targets_Term(Target *targets);
+extern void Target_Add(Target **targets, Target *targetToAdd);
+
+/********************************/
+/* CLAccessPaths.c */
+extern Path *Path_Init(const OSPathSpec *pathSpec, Path *path);
+extern Path *Path_New(const OSPathSpec *pathSpec);
+extern void Path_Free(Path *path);
+extern Boolean Paths_Initialize(Paths *paths);
+extern Boolean Paths_Terminate(Paths *paths);
+//static Boolean Paths_GrowPaths(Paths *paths, unsigned short *pIndex);
+extern Boolean Paths_AddPath(Paths *paths, Path *path);
+extern Boolean Paths_InsertPath(Paths *paths, unsigned short index, Path *path);
+extern Boolean Paths_RemovePath(Paths *paths, unsigned short index);
+extern Boolean Paths_DeletePath(Paths *paths, unsigned short index);
+extern Path *Paths_GetPath(Paths *paths, unsigned short index);
+extern unsigned short Paths_Count(const Paths *paths);
+extern Boolean Paths_FindPath(const Paths *paths, const Path *path);
+extern Path *Paths_FindPathSpec(const Paths *paths, const OSPathSpec *pathSpec);
+//static Boolean GatherRecurse(Paths *paths, Path *path);
+extern Boolean Paths_GatherRecurse(Paths *paths);
+extern int Paths_CountRecurse(Paths *paths);
+//static void CopyRecurseFSS(FSSpec **pFss, Paths *paths, unsigned short *pCount);
+extern void Paths_CopyRecurseFSS(FSSpec *fss, Paths *paths, unsigned short count);
+//static Boolean Frameworks_Initialize(Frameworks *frameworks);
+//static Boolean Frameworks_Grow(Frameworks *frameworks, unsigned short *pIndex);
+//static Boolean Frameworks_Add(Frameworks *frameworks, Framework *framework);
+//static Framework *Framework_Init(OSSpec *frameworkSpec, const char *name, const char *version, Framework *framework, Path *containingPath, Boolean flag);
+//static Framework *Framework_New(OSSpec *frameworkSpec, const char *name, const char *version, Path *containingPath, Boolean flag);
+//static Boolean CheckForFileInFrameworkDir(char *buf, const char *dir, OSPathSpec *pathSpec, const char *filename);
+//static Boolean CheckForFileInFramework(char *buf, int fwIndex, const char *filename);
+extern Boolean MakeFrameworkPath(char *buf, const char *frameworkName, OSPathSpec **pOutputSpec);
+extern Boolean Frameworks_AddPath(const OSPathSpec *pathSpec);
+extern Boolean Frameworks_AddFramework(const char *frameworkName, const char *version, Boolean flag);
+extern void Framework_GetEnvInfo();
+extern int Frameworks_GetCount();
+extern Framework *Frameworks_GetInfo(int index);
+
+/********************************/
+/* MacSpecs.c */
+// This is pretty much self-contained lol
+extern OSErr OS_OSPathSpec_To_VolDir(const OSPathSpec *pathSpec, short *pVol, long *pDir);
+extern OSErr OS_OSSpec_To_FSSpec(const OSSpec *spec, FSSpec *fss);
+extern OSErr OS_VolDir_To_OSNameSpec(short vol, long dir, OSNameSpec *nameSpec, long *pDir);
+extern OSErr OS_VolDir_To_OSPathSpec(short vol, long dir, OSPathSpec *pathSpec);
+extern OSErr OS_FSSpec_To_OSSpec(const FSSpec *fss, OSSpec *spec);
+extern OSErr OS_GetRsrcOSSpec(const OSSpec *baseSpec, OSSpec *rsrcSpec, Boolean createFlag);
+
+/********************************/
+/* StringUtils.c */
+extern StringPtr _pstrcpy(StringPtr dst, ConstStringPtr src);
+extern StringPtr _pstrcat(StringPtr dst, ConstStringPtr src);
+extern StringPtr _pstrcharcat(StringPtr dst, unsigned char c);
+extern StringPtr pstrncpy(StringPtr dst, ConstStringPtr src, short maxlen);
+extern StringPtr pstrncat(StringPtr dst, ConstStringPtr src, short maxlen);
+extern int pstrcmp(ConstStringPtr a, ConstStringPtr b);
+extern int pstrchr(ConstStringPtr str, char c);
+extern void c2pstrcpy(StringPtr dst, const char *src);
+extern void p2cstrcpy(char *dst, ConstStringPtr src);
+extern char *mvprintf(char *str, size_t size, const char *format, va_list ap);
+extern char *mprintf(char *str, size_t size, const char *format, ...);
+extern int HPrintF(Handle hand, const char *format, ...);
+
+/********************************/
+/* ?? Handle emulation */
+typedef struct MacHandle {
+ char *addr;
+ OSHandle hand;
+} MacHandle;
+extern OSHandle *OS_PeekMacHandle(MacHandle *mh);
+//static void FixHandlePtr(MacHandle *mh, char *ptr);
+extern MacHandle *OS_CreateMacHandle(OSHandle *hand);
+extern MacHandle *OS_CreateMacHandleDup(MacHandle *mh);
+extern void OS_DestroyMacHandle(MacHandle *mh, OSHandle *hand);
+
+extern OSErr MemError();
+extern Handle NewHandle(long byteCount);
+extern Handle NewHandleClear(long byteCount);
+extern Handle TempNewHandle(long logicalSize, OSErr *resultCode);
+extern void DisposeHandle(Handle h);
+extern void HLock(Handle h);
+extern void HLockHi(Handle h);
+extern void HUnlock(Handle h);
+extern void HPurge(Handle h);
+extern void HNoPurge(Handle h);
+extern SInt8 HGetState(Handle h);
+extern void HSetState(Handle h, SInt8 flags);
+extern long GetHandleSize(Handle h);
+extern void SetHandleSize(Handle h, long size);
+extern OSErr PtrAndHand(const void *ptr1, Handle hand2, long size);
+extern OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size);
+extern OSErr HandToHand(Handle *theHndl);
+extern OSErr HandAndHand(Handle hand1, Handle hand2);
+extern void MoveHHi(Handle h);
+extern void BlockMove(const void *srcPtr, void *destPtr, long byteCount);
+extern void BlockMoveData(const void *srcPtr, void *destPtr, long byteCount);
+extern Ptr NewPtr(long byteCount);
+extern void DisposePtr(Ptr p);
+extern Ptr NewPtrClear(long byteCount);
+extern void DebugStr(ConstStringPtr debuggerMsg);
+extern OSErr HandleZone();
+extern OSErr ApplicationZone();
+
+/********************************/
+/* Files.c */
+typedef struct FileParamInfo { // i think this is internal, move it once i impl Files.c
+ unsigned long creationDate;
+ unsigned long modifiedDate;
+ long logicalLen;
+ long physicalLen;
+ long rLogicalLen;
+ long rPhysicalLen;
+ long x18;
+ long x1C;
+ unsigned char attrib;
+} FileParamInfo; // assumed name
+//static int OS_GetFileParamInfo(const OSSpec *spec, FileParamInfo *info, FInfo *finfo);
+//static int OS_SetFileParamInfo(const OSSpec *spec, FileParamInfo *info, FInfo *finfo);
+extern OSErr HCreate(short vRefNum, long dirID, ConstStr255Param fileName, OSType creator, OSType fileType);
+extern OSErr HOpen(short vRefNum, long dirID, ConstStr255Param fileName, SInt8 permission, short *refNum);
+extern OSErr HOpenDF(short vRefNum, long dirID, ConstStr255Param fileName, SInt8 permission, short *refNum);
+extern OSErr HDelete(short vRefNum, long dirID, ConstStr255Param fileName);
+extern OSErr HRename(short vRefNum, long dirID, ConstStr255Param oldName, ConstStr255Param newName);
+extern OSErr HGetFInfo(short vRefNum, long dirID, ConstStr255Param fileName, FInfo *fndrInfo);
+extern OSErr HSetFInfo(short vRefNum, long dirID, ConstStr255Param fileName, const FInfo *fndrInfo);
+extern OSErr FSpCreate(const FSSpec *spec, OSType creator, OSType fileType, ScriptCode scriptTag);
+extern OSErr FSpDirCreate(const FSSpec *spec, ScriptCode scriptTag, long *createdDirID);
+extern OSErr FSpOpenDF(const FSSpec *spec, SInt8 permission, short *refNum);
+extern OSErr FSpDelete(const FSSpec *spec);
+extern OSErr FSpRename(const FSSpec *spec, ConstStr255Param newName);
+extern OSErr FSpGetFInfo(const FSSpec *spec, FInfo *fndrInfo);
+extern OSErr FSpSetFInfo(const FSSpec *spec, const FInfo *fndrInfo);
+extern OSErr HGetVol(StringPtr volName, short *vRefNum, long *dirID);
+extern OSErr HSetVol(ConstStr63Param volName, short vRefNum, long dirID);
+extern OSErr FlushVol(ConstStr63Param volName, short vRefNum);
+extern OSErr FSRead(short refNum, long *count, void *buffPtr);
+extern OSErr FSWrite(short refNum, long *count, const void *buffPtr);
+extern OSErr FSClose(short refNum);
+extern OSErr GetEOF(short refNum, long *logEOF);
+extern OSErr SetEOF(short refNum, long logEOF);
+extern OSErr GetFPos(short refNum, long *filePos);
+extern OSErr SetFPos(short refNum, short posMode, long posOff);
+extern OSErr GetVInfo(short drvNum, StringPtr volName, short *vRefNum, long *freeBytes);
+extern OSErr PBWriteSync(ParmBlkPtr paramBlock);
+extern OSErr PBHGetFInfoSync(HParmBlkPtr paramBlock);
+extern OSErr PBHSetFInfoSync(HParmBlkPtr paramBlock);
+extern OSErr PBGetCatInfoSync(CInfoPBPtr paramBlock);
+extern OSErr ResolveAliasFile(FSSpec *theSpec, Boolean resolveAliasChains, Boolean *targetIsFolder, Boolean *wasAliased);
+extern OSErr FSMakeFSSpec(short vRefNum, long dirID, ConstStr255Param fileName, FSSpec *spec);
+extern OSErr Allocate(short refNum, long *count);
+extern StringPtr c2pstr(char *str);
+extern char *p2cstr(StringPtr str);
+extern short CharacterByteType(Ptr textBuf, short textOffset, ScriptCode script);
+extern short CharByte();
+extern void GetDateTime(unsigned long *secs);
+extern Boolean EqualString(ConstStr255Param str1, ConstStr255Param str2, Boolean caseSensitive, Boolean diacSensitive);
+extern void GetIndString(Str255 theString, short strListID, short index);
+extern char *getindstring(char *theString, short strListID, short index);
+extern void NumToString(long theNum, Str255 theString);
+extern void StringToNum(ConstStr255Param theString, long *theNum);
+extern int AddFileTypeMappingList(void *a, void *b); // TODO sig
+extern void UseFileTypeMappings(void *a); // TODO sig
+extern OSErr SetMacFileType(const FSSpec *fss, void *a); // TODO sig
+extern OSErr GetMacFileType(const FSSpec *fss, void *a); // TODO sig
+
+/********************************/
+/* CLFiles.c */
+extern File *File_New();
+extern void File_Free(File *file);
+extern int Files_Initialize(Files *files);
+extern int Files_Terminate(Files *files);
+extern int Files_AddFile(Files *files, File *file);
+extern int Files_InsertFile(Files *files, File *file, int index);
+extern File *Files_GetFile(Files *files, int index);
+extern File *Files_FindFile(Files *files, OSSpec *spec);
+extern int Files_Count(Files *files);
+extern int VFiles_Initialize(VFile **vfiles);
+extern int VFiles_Terminate(VFile **vfiles);
+extern VFile *VFile_New(const char *name, Handle data);
+extern int VFiles_Add(VFile **vfiles, VFile *vfile);
+extern VFile *VFiles_Find(VFile *vfiles, const char *name);
+
+/********************************/
+/* CLOverlays.c */
+extern int Overlays_Initialize(Overlays *overlays);
+extern int Overlays_Terminate(Overlays *overlays);
+extern int Overlays_AddOvlGroup(Overlays *overlays, OvlGroup *group, int *pIndex);
+extern OvlGroup *Overlays_GetOvlGroup(Overlays *overlays, int index);
+extern int Overlays_CountGroups(Overlays *overlays);
+extern int Overlays_AddFileToOverlay(Overlays *overlays, int groupIndex, int overlayIndex, int fileID);
+extern Overlay *Overlays_GetOverlayInGroup(Overlays *overlays, int groupIndex, int overlayIndex);
+extern int Overlays_GetFileInOverlay(Overlays *overlays, int groupIndex, int overlayIndex, int fileIndex);
+extern OvlGroup *OvlGroup_New(const char *name, CWAddr64 addr);
+extern void OvlGroup_Delete(OvlGroup *group);
+extern int OvlGroup_AddOverlay(OvlGroup *group, Overlay *overlay, int *pIndex);
+extern Overlay *OvlGroup_GetOverlay(OvlGroup *group, int index);
+extern int OvlGroup_CountOverlays(OvlGroup *group);
+extern Overlay *Overlay_New(const char *name);
+extern void Overlay_Delete(Overlay *overlay);
+extern int Overlay_AddFile(Overlay *overlay, int fileID, int *pIndex);
+extern int Overlay_GetFile(Overlay *overlay, int index);
+extern int Overlay_CountFiles(Overlay *overlay);
+
+/********************************/
+/* CLSegs.c */
+extern Segment *Segment_New(const char *name, unsigned short a);
+extern void Segment_Free(Segment *segment);
+extern int Segments_Initialize(Segments *segments);
+extern int Segments_Terminate(Segments *segments);
+//static Boolean Segments_GrowSegments(Segments *segments, unsigned short *pIndex);
+extern int Segments_AddSegment(Segments *segments, Segment *segment, unsigned short *pIndex);
+extern Boolean Segments_InsertSegment(Segments *segments, unsigned short index, Segment *segment);
+extern Boolean Segments_DeleteSegment(Segments *segments, unsigned short index);
+extern Segment *Segments_GetSegment(Segments *segments, unsigned short index);
+extern unsigned short Segments_Count(const Segments *segments);
+
+/********************************/
+/* CLDropinCallbacks_V10.cpp */
+// TODO
+
+/********************************/
+/* MacFileTypes.c */
+typedef struct OSFileTypeMappingListNode {
+ OSFileTypeMappingList *list;
+ struct OSFileTypeMappingListNode *next;
+} OSFileTypeMappingListNode; // assumed name
+extern void OS_AddFileTypeMappingList(OSFileTypeMappingListNode **node, OSFileTypeMappingList *list);
+extern void OS_UseFileTypeMappings(OSFileTypeMappingListNode *node);
+extern void OS_MacType_To_OSType(OSType mactype, uOSTypePair *ostype);
+extern int OS_SetMacFileType(const OSSpec *spec, OSType mactype);
+extern int OS_GetMacFileTypeMagic(const void *magic, int length, OSType *mactype);
+extern int OS_GetMacFileType(const OSSpec *spec, OSType *mactype);
+extern int OS_SetMacFileCreatorAndType(const OSSpec *spec, OSType creator, OSType mactype);
+
+/********************************/
+/* ?? Handles */
+//extern int OS_LoadFileHandle(OSFileHandle *fh);
+//extern int OS_WriteFileHandle(OSFileHandle *fh);
+extern int OS_NewFileHandle(const OSSpec *spec, OSHandle *hand, Boolean writeable, OSFileHandle *fh);
+extern int OS_LockFileHandle(OSFileHandle *fh, Ptr *h, unsigned long *pSize);
+extern int OS_UnlockFileHandle(OSFileHandle *fh);
+extern int OS_FreeFileHandle(OSFileHandle *fh);
+extern void OS_GetFileHandleSpec(const OSFileHandle *fh, OSSpec *spec);
+
+/********************************/
+/* CLCompilerLinkerDropin_V10.cpp */
+// TODO
+
+/********************************/
+/* CLDependencies.c */
+extern int Incls_Initialize(Incls *incls);
+extern void Incls_Terminate(Incls *incls);
+// IsSysIncl
+// MakeInclFileSpec
+// QuickFindFileInIncls
+// SameIncl
+// FindOrAddGlobalInclPath
+// _FindFileInPath
+// FindFileInPaths
+// AddFileToIncls
+extern int Incls_FindFileInPaths(Incls *incls, ...); // TODO sig
+extern int Deps_Initialize(Deps *deps, Incls *incls);
+extern void Deps_Terminate(Deps *deps);
+extern int Deps_ChangeSpecialAccessPath(OSPathSpec *pathSpec, Boolean flag);
+extern Path *Deps_GetSpecialAccessPath();
+//extern void SetSpecialAccessPathFromIncludeStackTOS();
+// FindDepFile
+// AddDepFile
+extern int Deps_AddDependency(); // TODO sig
+// EscapeName
+extern int Deps_ListDependencies(); // TODO sig
+
+/********************************/
+/* CLWriteObjectFile.c */
+extern Boolean WriteObjectFile(File *file, OSType creator, OSType filetype);
+extern Boolean WriteBrowseData(File *file);
+
+/********************************/
+/* CLBrowser.c */
+// GetBrowseTableInfoAndLock
+extern int Browser_Initialize(OSHandle *hand);
+//static int Destroy(OSHandle *hand);
+extern int Browser_Terminate(OSHandle *hand);
+extern int Browser_SearchFile(OSHandle *hand, const char *path, short *pIndex);
+extern int Browser_SearchAndAddFile(OSHandle *hand, const char *path, short *pIndex);
+//static long CalcDiskSpaceRequirements(...); // needs table type
+//static int ConvertMemToDisk(...); // needs table type
+extern int Browser_PackBrowseFile(Handle h, OSHandle *hand, OSHandle *hand2);
+
+/********************************/
+/* ?? Include Cache */
+// TODO
+
+/********************************/
+/* ?? Error */
+extern char *GetSysErrText(short code, char *buffer);
+
+/********************************/
+/* Might be cc-mach-ppc-mw.c? */
+extern void GetStaticTarget(CWDataType *cpu, CWDataType *os);
+extern void GetStaticPluginType(CWDataType *language, CWDataType *plugintype);
+extern void GetStaticParserPluginType(CWDataType *style);
+extern int RegisterStaticTargetResources();
+extern int RegisterStaticTargetPlugins();
+
+/********************************/
+/* Might be ParserGlue-mach-ppc-cc.c? */
+extern int RegisterStaticParserToolInfo();
+
+/********************************/
+/* Might be cc-mach-ppc.c? */
+extern pascal short CWPlugin_GetDropInFlags(const DropInFlags **flags, long *flagsSize);
+extern pascal short CWPlugin_GetTargetList(const CWTargetList **targetList);
+extern pascal short CWPlugin_GetDropInName(const char **dropinName);
+extern pascal short CWPlugin_GetDisplayName(const char **displayName);
+extern pascal short CWPlugin_GetDefaultMappingList(const CWExtMapList **defaultMappingList);
+extern pascal short CWPlugin_GetPanelList(const CWPanelList **panelList);
+//_CmdLine_GetObjectFlags
+//_CWPlugin_GetVersionInfo
+//_CWPlugin_GetFileTypeMappings
+//_Linker_GetDropInFlags
+//_Linker_GetDropInName
+//_Linker_GetDisplayName
+//_Linker_GetPanelList
+//_Linker_GetTargetList
+//_Linker_GetDefaultMappingList
+extern int RegisterStaticCompilerPlugin();
+extern int RegisterCompilerResources();
+
+/********************************/
+/* libimp-mach-ppc.c */
+// some statics here
+extern int RegisterStaticLibImporterPlugin();
+extern int RegisterLibImporterResources();
+
+/********************************/
+/* TargetOptimizer-ppc-mach.c */
+extern int TargetSetOptFlags(short val, Boolean set);
+extern void TargetDisplayOptimizationOptions(Handle txt);
+extern void TargetSetPragmaOptimizationsToUnspecified();
+
+/********************************/
+/* OptimizerHelpers.c */
+extern int SetPragmaOptimizationsToUnspecified();
+extern int SetOptFlags(char *opt, void *str, ...); // two unknown args
+extern int DisplayOptimizationOptions();
+
+/********************************/
+/* Unk name lol */
+extern int TargetSetWarningFlags(short val, Boolean set);
+extern int TargetDisplayWarningOptions(Handle txt);
+
+/********************************/
+/* WarningHelpers.c */
+extern int SetWarningFlags(char *opt, void *str, ...); // two unknown args
+extern int DisplayWarningOptions();
+
+/********************************/
+/* CCompiler.c */
+
+// LOTS OF STUFF
+
+/********************************/
+/* StaticParserGlue.c */
+extern int RegisterStaticParserResources();
+extern int RegisterStaticParserPlugins();
+
+/********************************/
+/* ParserFace.c */
+extern Handle Parser_FindPrefPanel(char *name);
+extern CWResult Parser_StorePanels(CWPluginContext context);
+extern short CWParser_GetDropInFlags(const DropInFlags **flags, long *flagsSize);
+extern short CWParser_GetDropInName(const char **dropinName);
+extern short CWParser_GetDisplayName(const char **displayName);
+extern short CWParser_GetPanelList(const CWPanelList **panelList);
+extern short CWParser_GetTargetList(const CWTargetList **targetList);
+extern short CWParser_GetVersionInfo(const VersionInfo **versioninfo);
+extern short Parser_SupportsPlugin(struct CLPluginInfo *pluginfo, CWDataType cpu, CWDataType os, Boolean *isSupported);
+extern short Parser_SupportsPanels(int numPanels, char **panelNames, Boolean *isSupported);
+extern short parser_main(CWPluginContext context);
+
+extern struct ParseOptsType parseopts;
+
+/********************************/
+/* ParserHelpers.c */
+extern int FindFileInPath(const char *filename, OSSpec *fss);
+extern char *GetEnvVar(const char *name, Boolean warn, char **match);
+//static Boolean MatchesExtension(const char *list, const char *filename);
+extern int Opt_AddAccessPath(const char *opt, void *var, const char *arg);
+extern int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg);
+extern int Opt_AddFramework(const char *opt, void *var, const char *arg);
+extern void ListParseMessage(void *errprint, const char *envvar, short id); // TODO funcptr sig - same as CLPReportWarning_V, CLPReportError_V
+extern int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *text, Boolean system, long position, Boolean recursive);
+extern int Opt_FindAndAddFile(const char *opt, void *var, const char *arg);
+extern int Opt_FindAndAddFileRef(const char *opt, void *var, const char *arg);
+extern int Opt_AddUnixLibraryFile(const char *opt, void *var, const char *arg);
+extern int AddFileList(const char *list, char sep1, char sep2, int source, char *text, long position);
+extern int IsFileInOutputDirectory(const OSSpec *file);
+extern void GetCFileNameInOutputDirectory(const char *input, char *name, int maxlen);
+extern void GetPFileNameInOutputDirectory(const char *input, unsigned char *name, int len);
+extern void AddStringLenToHandle(Handle h, const char *str, int len);
+extern void AddStringToHandle(Handle h, const char *str);
+extern int Opt_PrintVersion(const char *opt, void *var, const char *arg);
+extern void GetFirstSourceFilenameBase(char *buffer, char *defaul);
+extern int Opt_SavePrefs(const char *opt, void *var, const char *arg);
+extern int ParseNumber(const char *arg, Boolean emit_error, long *ret, const char **endptr);
+extern int Opt_MaybeMoveAccessPaths(const char *opt, void *var, const char *arg);
+
+/********************************/
+/* ToolHelpers.c */
+extern int Opt_HandleOutputName(const char *opt, void *, const char *filename);
+extern int ValidateToolState(Boolean mustHaveFiles);
+extern void ToolReportMessage(short errid, short type, va_list va);
+extern void ToolReportWarning(short id, ...);
+extern void ToolReportError(short id, ...);
+extern void ToolReportOSError(short id, ...);
+extern void ToolReportInfo(short id, ...);
+extern int Opt_DoNotLink(const char *opt, void *var, const char *arg);
+extern int Opt_IncreaseVerbosity(const char *opt, void *var, const char *arg);
+extern int Opt_SetStage(const char *opt, void *str, const char *arg, void *unk);
+// lots of the Opt_ funcs have weird sigs, need to double check them
+extern int Opt_RedirectStream(const char *opt, void *file, const char *filename);
+
+/********************************/
+/* ParserHelpers-cc.c */
+typedef struct {
+ void *value;
+ const char *pragma;
+ int flags;
+} Pragma; // assumed name
+extern int Opt_AddStringToDefines(const char *opt, void *str, const char *param);
+extern int Opt_DefineSymbol(const char *var, const char *value);
+extern int Opt_UndefineSymbol(const char *opt, void *, const char *arg);
+extern int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename);
+extern int Opt_PragmaTrueFalse(const char *, void *flag, const char *, int flags);
+extern int Opt_PragmaFalseTrue(const char *, void *flag, const char *, int flags);
+extern int Opt_PragmaOnOff(const char *, void *flag, const char *arg);
+extern int Opt_PragmaOffOn(const char *, void *flag, const char *arg);
+extern int SetupPragmas(const Pragma *pragmas);
+
+/********************************/
+/* Arguments.c */
+typedef struct {
+ short val;
+ char *text;
+} ArgToken;
+enum {
+ ATK_0,
+ ATK_1,
+ ATK_2,
+ ATK_3,
+ ATK_4,
+ ATK_5
+};
+typedef struct {
+ int argc;
+ int nargv;
+ char **argv;
+} anon0_50;
+
+extern void Arg_Init(int theargc, char **theargv);
+extern void Arg_Terminate();
+extern void Arg_Reset();
+extern void Arg_Stop(ArgToken *where);
+extern ArgToken *Arg_PeekToken();
+extern ArgToken *Arg_UsedToken();
+extern int Arg_IsEmpty();
+extern ArgToken *Arg_GetToken();
+extern ArgToken *Arg_UndoToken();
+extern const char *Arg_GetTokenName(ArgToken *tok);
+extern const char *Arg_GetTokenText(ArgToken *tok, char *buffer, int maxlen, unsigned char warn);
+extern void Arg_InitToolArgs(anon0_50 *ta);
+extern void Arg_AddToToolArgs(anon0_50 *ta, short tokval, char *toktxt);
+extern void Arg_FinishToolArgs(anon0_50 *ta);
+extern void Arg_ToolArgsForPlugin(anon0_50 *ta, struct CWCommandLineArgs *args);
+extern void Arg_FreeToolArgs(anon0_50 *ta);
+
+/********************************/
+/* ToolHelpers-cc.c */
+extern int Opt_DummyLinkerRoutine(const char *opt);
+extern int Opt_DummyLinkerSettingRoutine(const char *var, const char *val);
+extern void FinishCompilerTool();
+
+/********************************/
+/* IO.c */
+extern void ShowTextHandle(const char *description, Handle text);
+extern void ShowVersion(Boolean decorate);
+
+/********************************/
+/* Projects.c */
+extern int GetFileCount();
+extern void SetFileOutputName(long position, short which, char *outfilename);
+extern int AddFileToProject(OSSpec *oss, short which, char *outfilename, Boolean exists, long position);
+extern Boolean GetFileInfo(long position, OSSpec *spec, char *plugin);
+extern int AddAccessPath(const OSPathSpec *oss, short type, long position, Boolean recursive);
+extern int MoveSystemPathsIntoUserList();
+extern void AddVirtualFile(const char *filename, Handle *text);
+extern void GetOutputFileDirectory(OSPathSpec *dir);
+extern void SetOutputFileDirectory(const OSPathSpec *dir);
+extern void AddOverlayGroup(const char *name, CWAddr64 *addr, long *groupnum, long *overlaynum);
+extern void AddOverlay(long groupnum, const char *name, long *overlaynum);
+extern void AddSegment(const char *name, short attrs, long *segmentnum);
+extern void ChangeSegment(long segmentnum, const char *name, short attrs);
+extern int GetSegment(long segmentnum, char *name, short *attrs);
+
+/********************************/
+/* Targets.c */
+extern int SetParserToolInfo(ParserTool *tool);
+extern Boolean ParserToolMatchesPlugin(CWDataType type, CWDataType lang, CWDataType cpu, CWDataType os);
+extern Boolean ParserToolHandlesPanels(int numPanels, const char **panelNames);
+extern Boolean SetupParserToolOptions();
+
+/********************************/
+/* Option.c */
+typedef struct {
+ void *first;
+ void *second;
+} Opt50;
+typedef struct {
+ Option *opt;
+ char *curopt;
+} Opt52;
+typedef struct {
+ union {
+ Opt50 v;
+ OptionList *lst;
+ Opt52 o;
+ char *param;
+ } e;
+ short flags;
+} Opt48;
+//static void Option_PushList(OptionList *lst);
+//static void Option_PushOpt(Option *opt, const char *optname);
+//static void Option_PopOpt(const char *optname);
+//static void Option_PopList();
+extern void Args_InitStack();
+extern int Args_StackSize();
+extern void Args_Push(short flags, void *first, void *second);
+extern Opt48 *Args_Pop(short flags);
+extern void Args_SpellStack(char *buffer, short flags);
+extern void Args_AddToToolArgs(anon0_50 *ta);
+extern void Options_Init();
+extern OptionList *Options_GetOptions();
+extern void Options_SortOptions();
+//static void Options_AddOption(Option *opt);
+extern int Options_AddList(OptionList *optlst);
+extern int Options_AddLists(OptionList **optlst);
+//static void Options_Reset(OptionList *optlst);
+//static void Option_SpellList(char *buffer, OptionList *conflicts, int flags);
+extern int Option_ForTool(Option *opt, int which);
+extern int Option_ThisTool();
+extern int Option_ForThisTool(Option *opt);
+extern int Option_AlsoPassedToTool(Option *opt, int which);
+extern int Option_AlsoPassedFromThisTool(Option *opt);
+//static Boolean Option_ContinuesThisLevel(int level, ArgToken *tok);
+//static Boolean Option_IsEndingThisLevel(int level, ArgToken *tok);
+//static Boolean Option_IsEndingLevel(int level, ArgToken *tok);
+extern int Option_Parse(Option *opt, int oflags);
+//static int Option_MatchString(char *list, char *str, int flags, int *result);
+//static Option *Option_Lookup(OptionList *search, void *unk, int *flags);
+//static int Options_DoParse(OptionList *search, int flags);
+extern int Options_Parse(OptionList *options, int flags);
+extern int Option_ParseDefaultOption(OptionList *options);
+extern void Option_ParamError(short id, va_list ap);
+extern void Option_ParamWarning(short id, va_list ap);
+extern void Option_OptionError(short id, va_list ap);
+extern void Option_OptionWarning(short id, va_list ap);
+extern void Option_Error(short id, ...);
+extern void Option_Warning(short id, ...);
+extern int Options_Help(const char *keyword);
+extern int Option_Help(const char *opt);
+extern int Options_DisplayHelp();
+
+/********************************/
+/* ParserErrors.c */
+extern void CLPReportError_V(const char *format, va_list ap);
+extern void CLPReportWarning_V(const char *format, va_list ap);
+extern void CLPReport_V(const char *format, va_list ap);
+extern void CLPStatus_V(const char *format, va_list ap);
+extern void CLPAlert_V(const char *format, va_list ap);
+extern void CLPOSAlert_V(const char *format, long err, va_list ap);
+extern void CLPGetErrorString(short errid, char *buffer);
+extern void CLPReportError(short errid, ...);
+extern void CLPReportWarning(short errid, ...);
+extern void CLPReport(short errid, ...);
+extern void CLPAlert(short errid, ...);
+extern void CLPOSAlert(short errid, short err, ...);
+extern void CLPProgress(short errid, ...);
+extern void CLPStatus(short errid, ...);
+extern void CLPFatalError(const char *format, ...);
+
+/********************************/
+/* Utils.c */
+extern int my_tolower(char c);
+extern int my_isdigit(char c);
+extern int my_isalpha(char c);
+extern int my_isalnum(char c);
+extern int my_isxdigit(char c);
+extern char *Utils_SpellList(char *list, char *buffer, char opts);
+extern int Utils_CompareOptionString(const char *a, const char *b, int cased, int sticky);
+
+/********************************/
+/* Parameter.c */
+//static int Param_None();
+//static void DescHelpParam_None(PARAM_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_None();
+
+//static void DescHelpParam_Number(NUM_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Number();
+//static int Param_Number(NUM_T *p, const char *pstr);
+
+//static void DescHelpParam_FTypeCreator(FTYPE_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_FTypeCreator();
+//static int Param_FTypeCreator(FTYPE_T *p, const char *pstr);
+
+//static void DescHelpParam_String(STRING_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_String();
+//static int Param_String(STRING_T *p, const char *pstr);
+
+//static void DescHelpParam_ID_or_SYM(STRING_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_ID_or_SYM();
+//static int Param_ID_or_SYM(STRING_T *p, const char *pstr);
+
+//static void DescHelpParam_OnOff(ONOFF_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_OnOff();
+//static int Param_OnOff(ONOFF_T *p, const char *pstr);
+
+//static void DescHelpParam_OffOn(ONOFF_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_OffOn();
+//static int Param_OffOn(OFFON_T *p, const char *pstr);
+
+//static void DescHelpParam_FilePath(FILEPATH_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_FilePath();
+//static int Param_FilePath(FILEPATH_T *p, const char *pstr);
+
+//static void DescHelpParam_Mask(MASK_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Mask(MASK_T *p);
+//static int Param_Mask(MASK_T *p, const char *pstr, int flags);
+
+//static void DescHelpParam_Toggle(TOGGLE_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Toggle(TOGGLE_T *p);
+//static int Param_Toggle(TOGGLE_T *p, const char *pstr);
+
+//static void DescHelpParam_Set(SET_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Set(SET_T *p);
+//static int Param_Set(SET_T *p, const char *pstr, int flags);
+
+//static void DescHelpParam_SetString(SETSTRING_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_SetString(SETSTRING_T *p);
+//static int Param_SetString(SETSTRING_T *p, const char *pstr, int flags);
+
+//static void DescHelpParam_Generic(GENERIC_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Generic(GENERIC_T *p);
+//static int Param_Generic(GENERIC_T *p, const char *pstr, int flags);
+
+//static void DescHelpParam_Setting(SETTING_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_Setting(SETTING_T *p);
+//static int Param_Setting(SETTING_T *p, const char *pstr, int flags);
+
+//static void DescHelpParam_IfArg(IFARG_T *p, const char **desc, const char **help, const char **defaul);
+//static int CompareParam_IfArg(IFARG_T *p);
+//static int Param_IfArg(IFARG_T *p, const char *pstr, int flags);
+
+//static int Param_Parse(PARAM_T *param, const char *cparam, int flags);
+extern void Param_DescHelp(PARAM_T *param, const char **desc, const char **help, const char **defaul);
+extern int Param_Compare(PARAM_T *param);
+//static void Param_PushParam(const char *param);
+//static void Param_PopParam();
+//static Boolean Param_IsNonTextFile(const char *fname, Boolean warn);
+//static int Param_GetArgument(PARAM_T *param, const char *cparam, int exec);
+extern int Params_Parse(PARAM_T *param, int flags);
+extern void Param_Error(short id, ...);
+extern void Param_Warning(short id, ...);
+
+/********************************/
+/* Help.c */
+extern int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const char *keyword);
+extern void Help_Options(struct OptionList *lst, int subprint, const char *keyword);
+extern void Help_Usage();
+extern void Help_Null();
+extern void Help_Init();
+extern void Help_Line(char ch);
+extern void Help_Term();
+
+/********************************/
+/* */
+
+/********************************/
+/* */
+
+/********************************/
+/* ?? COS */
+// static COS_pstrcpy
+// static COS_pstrcat
+// static COS_pstrcharcat
+// static COS_pstrcmp
+extern Handle COS_NewHandle(long byteCount);
+extern Handle COS_NewOSHandle(long logicalSize);
+extern void COS_FreeHandle(Handle handle);
+extern Boolean COS_ResizeHandle(Handle handle, long newSize);
+extern long COS_GetHandleSize(Handle handle);
+extern void COS_LockHandle(Handle handle);
+extern void COS_LockHandleHi(Handle handle);
+extern void COS_UnlockHandle(Handle handle);
+extern int COS_GetHandleState(Handle handle);
+extern void COS_SetHandleState(Handle handle, int state);
+extern Boolean COS_IsLockedState(int state);
+extern char *COS_NewPtr(long byteCount);
+extern char *COS_NewPtrClear(long byteCount);
+extern void COS_FreePtr(char *ptr);
+extern void COS_AppendPtrToHandle(char *ptr1, Handle hand2, long size);
+extern short COS_GetMemErr();
+extern long COS_GetTicks();
+extern long COS_GetTime();
+extern void COS_GetString(char *buffer, short strListID, short index);
+extern void COS_GetPString(unsigned char *buffer, short strListID, short index);
+extern Boolean COS_IsMultiByte(char *buffer, char *str);
+extern short COS_FileNew(const FSSpec *spec, short *refNum, FourCharCode creator, FourCharCode fileType);
+extern short COS_FileOpen(const FSSpec *spec, short *refNum);
+extern short COS_FileGetType(const FSSpec *spec, FourCharCode *fileType);
+extern short COS_FileGetSize(short refNum, long *logEOF);
+extern short COS_FileRead(short refNum, void *buffPtr, long count);
+extern short COS_FileWrite(short refNum, const void *buffPtr, long count);
+extern short COS_FileGetPos(short refNum, long *filePos);
+extern short COS_FileSetPos(short refNum, long filePos);
+extern short COS_FileClose(short refNum);
+extern void COS_FileSetFSSpec(FSSpec *spec, unsigned char *path);
+extern short COS_FileMakeFSSpec(short vRefNum, long dirID, unsigned char *fileName, FSSpec *spec);
+extern short COS_FileMakeFSSpecWithPath(const FSSpec *inputSpec, unsigned char *fileName, FSSpec *spec);
+extern short COS_FileGetFileInfo(const FSSpec *spec, OSType *creator, OSType *fileType);
+extern void COS_FileGetFSSpecInfo(const FSSpec *spec, short *vRefNum, long *dirID, unsigned char *fileName);
+//static void COS_MakePath(short vRefNum, long dirID, char *path);
+extern void COS_FileGetPathName(char *buffer, const FSSpec *spec, long *mdDat);
+extern Boolean COS_EqualFileSpec(const FSSpec *a, const FSSpec *b);
+
+/********************************/
+/* */
+
+// TODO sort me
+extern Proj *gProj;
+extern ParserTool *pTool;
+extern PCmdLine optsCmdLine;
+extern PCmdLineEnvir optsEnvir;
+extern PCmdLineCompiler optsCompiler;
+extern PCmdLineLinker optsLinker;
+extern CLState clState;
+
+/********************************/
+/* CmdLineBuildDate.c */
+extern char CMDLINE_BUILD_DATE[];
+extern char CMDLINE_BUILD_TIME[];
+
+
+/********************************/
+/* MISC */
+extern void IO_Terminate();
+extern void SetupDebuggingTraps();
+extern void AppendArgumentList(void *unk1, void *unk2, const char *arg);
+
+extern int (*PrefPanelsChangedCallback)(const char *);
+extern Boolean systemHandles;
+extern char *MAINOPTCHAR;
+extern char *SEPOPTSTR;
+extern char compat;
+extern anon0_50 linkargs;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sdk_hdrs/CWDropInPanel.h b/sdk_hdrs/CWDropInPanel.h
new file mode 100755
index 0000000..4aa7a21
--- /dev/null
+++ b/sdk_hdrs/CWDropInPanel.h
@@ -0,0 +1 @@
+/* * CWDropInPanel.h * * Copyright © 1999 Metrowerks inc. All rights reserved. * * DropIn Preferences Panel Interface for UNIX/WIN32 Metrowerks CodeWarriorª */ #ifndef __CWDROPINPANEL_H__ #define __CWDROPINPANEL_H__ #ifdef __MWERKS__ # pragma once #endif #ifndef __CWPlugins_H__ #include "CWPlugins.h" #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifdef __cplusplus extern "C" { #endif /* * Convenience macros for swapping pref-panel values. Use this macros only if your * system/libraries do not provide their own public swapping functions/macros. * */ /* Swap 16-bit(short) value */ #define CWPREF_BYTESWAP_SHORT(value) value = \ (((((unsigned short)(value))<<8) & 0xFF00) | \ ((((unsigned short)(value))>>8) & 0x00FF)) /* Swap 32-bit(long) value */ #define CWPREF_BYTESWAP_LONG(value) value = \ (((((unsigned long)(value))<<24) & 0xFF000000) | \ ((((unsigned long)(value))<< 8) & 0x00FF0000) | \ ((((unsigned long)(value))>> 8) & 0x0000FF00) | \ ((((unsigned long)(value))>>24) & 0x000000FF)) #ifndef __DROPINPANEL_H__ /* API version numbers */ #define DROPINPANELAPIVERSION_1 1 /* CW7 API version */ #define DROPINPANELAPIVERSION_2 2 /* intermediate version */ #define DROPINPANELAPIVERSION_3 3 /* CW8 API version */ #define DROPINPANELAPIVERSION_4 4 /* CW9 API version */ #define DROPINPANELAPIVERSION_5 5 /* CW Pro 2 API version */ #define DROPINPANELAPIVERSION_7 7 /* CW Pro 3 Mac API version */ #define DROPINPANELAPIVERSION_8 8 /* CW Pro 3 Win32 API version */ #define DROPINPANELAPIVERSION_9 9 /* CW Pro 5 Win32 API version */ #define DROPINPANELAPIVERSION_10 10 /* CW Pro 6 Win32 API version */ #define DROPINPANELAPIVERSION_11 11 /* CW Pro 7 Win32 API version */ #define DROPINPANELAPIVERSION DROPINPANELAPIVERSION_11 /* current API version */ /* Error codes you return to the IDE */ #define kBadPrefVersion 1000 /* panel doesn't know about this version */ #define kMissingPrefErr 1001 #define kSettingNotFoundErr 1002 #define kSettingTypeMismatchErr 1003 #define kInvalidCallbackErr 1004 #define kSettingOutOfRangeErr 1005 /* * Requests codes - sent by the IDE to your panel * Note: Many of these are Mac-specific but are included for compatability reasons. * Future APIs will reimplement many of them is an OS-neutral way. */ enum { reqInitPanel = -2, /* (called when panel is loaded) */ reqTermPanel = -1, /* (called when panel is unloaded) */ reqInitDialog = 0, /* initialize panel's dialog state */ reqTermDialog, /* clean up panel's dialog state */ reqPutData, /* copy options data to dialog items */ reqGetData, /* copy dialog items to options data */ reqFilter, /* filter a dialog event for the panel (Mac only) */ reqItemHit, /* process an itemHit in the panel */ reqAEGetPref, /* get preference setting for AppleEvent request (Mac only) */ reqAESetPref, /* set preference setting from AppleEvent request (Mac only) */ reqValidate, /* tell if current settings force recompile or relink */ reqGetFactory, /* retrieve factory settings */ reqUpdatePref, /* verify and/or modify prefs to fit current version */ reqUpdateProject, /* (only sent to built-in panels) */ reqSetupDebug, /* change settings to reflect debugging status */ reqRenameProject, /* change settings that depend on project name */ reqPrefsLoaded, /* (only sent to built-in panels) */ reqDrawCustomItem, /* draw a custom item (Mac only) */ reqActivateItem, /* activate a custom item (Mac only) */ reqDeactivateItem, /* deactivate a custom item (Mac only) */ reqHandleClick, /* handle mouse down in an active custom item (Mac only) */ reqHandleKey, /* handle key down in an active custom item (Mac only) */ reqFindStatus, /* enable/disable menu items for a custom item (Mac only) */ reqObeyCommand, /* execute a menu command for a custom item (Mac only) */ reqDragEnter, /* the user is dragging into the given item (Mac only) */ reqDragWithin, /* the user is dragging within the given item (Mac only) */ reqDragExit, /* the user is dragging out of the given item (Mac only) */ reqDragDrop, /* the user dropped onto the given item (Mac only) */ reqByteSwapData, /* byte swap the fields in the prefs data */ reqFirstLoad, /* panel has been loaded for the first time */ reqReadSettings, /* read settings from IDE to construct pref data handle */ reqWriteSettings, /* write the individual settings from pref data handle */ reqItemDoubleClick, /* process an double clicked in the panel, currently implemented for listviews */ reqItemIsCellEditable /* currently implemented for listviews, tells whether or not the listview is editable */ }; /* Layout and bit flags for 'Flag' resource for panels */ /* */ /* For the version 3 of these resource, we renamed the 'apiversion' field to */ /* 'earliestCompatibleAPIVersion' and added the 'newestAPIVersion' field. */ /* This allows plugins to support more than one API version and therefore run */ /* under more than one version of the IDE. */ typedef struct PanelFlags { unsigned short rsrcversion; /* version number of resource */ CWDataType dropintype; /* dropin type ('Comp', 'Link', 'Panl') */ /* earliest API support by this plugin */ unsigned short earliestCompatibleAPIVersion; unsigned long dropinflags; /* capability flags (see enum below) */ CWDataType panelfamily; /* family of panel (linker, codegen, etc) */ unsigned short newestAPIVersion; /* newest API version supported */ unsigned short dataversion; /* version number of prefs data */ unsigned short panelscope; /* scope of panel (see enum below) */ } PanelFlags; /* capability flags, as used in member dropinflags of PanelFlags struct */ enum { usesStrictAPI = 1 << 31, /* this panel is built with the strict API */ supportsByteSwapping = 1 << 30, /* this panel support the byte-swapping request */ supportsTextSettings = 1 << 29, /* this panel supports the read & write settings requests */ usesCrossPlatformAPI = 1 << 28 /* uses the cross-platform API rather than Mac API */ /* remaining flags are reserved for future use and should be zero-initialized */ }; /* panel scopes, as used in member panelscope of PanelFlags struct */ /* */ /* The scope of a panel tells the IDE which settings window to display the panel. */ /* Currently, only panels for debugger plug-ins use panelScopeGlobal and only */ /* panels for VCS plug-ins use panelScopeProject. A panel for a compiler or linker */ /* must use panelScopeTarget. */ enum { panelScopeGlobal, /* this panel is scoped to the global preferences window */ panelScopeProject, /* this panel is scoped to the VCS settings window */ panelScopeTarget /* this panel is scoped to the target settings window */ }; /* pre-defined panel families, used in panelfamily field of PanelFlags struct */ enum { panelFamilyProject = CWFOURCHAR('p', 'r', 'o', 'j'), panelFamilyFrontEnd = CWFOURCHAR('f', 'e', 'n', 'd'), panelFamilyBackEnd = CWFOURCHAR('b', 'e', 'n', 'd'), panelFamilyBrowser = CWFOURCHAR('b', 'r', 'o', 'w'), panelFamilyEditor = CWFOURCHAR('e', 'd', 'i', 't'), panelFamilyDebugger = CWFOURCHAR('d', 'b', 'u', 'g'), panelFamilyLinker = CWFOURCHAR('l', 'i', 'n', 'k'), panelFamilyMisc = CWFOURCHAR('*', '*', '*', '*') }; typedef struct MWSetting* CWSettingID; #define kNoSettingID 0 #endif /* not defined __DROPINPANEL_H__ */ /*------------------------------------------------------------------------------------- Callbacks to the IDE, in addition to those in CWPlugins.h -----------------------------------------------------------------------------------*/ /* Dialog related */ CW_CALLBACK CWPanelAppendItems (CWPluginContext context, short ditlID); CW_CALLBACK CWPanelShowItem (CWPluginContext context, long whichItem, Boolean showIt); CW_CALLBACK CWPanelEnableItem (CWPluginContext context, long whichItem, Boolean enableIt); CW_CALLBACK CWPanelActivateItem (CWPluginContext context, long whichItem); CW_CALLBACK CWPanelGetItemValue (CWPluginContext context, long whichItem, long* value); CW_CALLBACK CWPanelSetItemValue (CWPluginContext context, long whichItem, long value); CW_CALLBACK CWPanelGetItemText (CWPluginContext context, long whichItem, char* str, short maxLen); CW_CALLBACK CWPanelSetItemText (CWPluginContext context, long whichItem, char* str); CW_CALLBACK CWPanelInsertListItem (CWPluginContext context, long dlgItemID, long index, char* str); CW_CALLBACK CWPanelDeleteListItem (CWPluginContext context, long dlgItemID, long index); CW_CALLBACK CWPanelGetListItemSize (CWPluginContext context, long dlgItemID, long* listSize); CW_CALLBACK CWPanelGetListItemText (CWPluginContext context, long dlgItemID, long index, char* str, short maxLen); CW_CALLBACK CWPanelSetListItemText (CWPluginContext context, long dlgItemID, long index, char* str); CW_CALLBACK CWPanelGetPopupItemChecked (CWPluginContext context, long dlgItemID, long index, Boolean* checked); CW_CALLBACK CWPanelSetPopupItemChecked (CWPluginContext context, long dlgItemID, long index, Boolean checked); CW_CALLBACK CWPanelSetPopupItemEnabled (CWPluginContext context, long dlgItemID, long index, Boolean enabled); CW_CALLBACK CWPanelInvalItem (CWPluginContext context, long whichItem); CW_CALLBACK CWPanelValidItem (CWPluginContext context, long whichItem); CW_CALLBACK CWPanelGetNumBaseDialogItems(CWPluginContext context, short* baseItems); CW_CALLBACK CWPanelGetDialogItemHit (CWPluginContext context, short* itemHit); CW_CALLBACK CWPanelGetItemTextHandle (CWPluginContext context, long whichItem, CWMemHandle* text); CW_CALLBACK CWPanelSetItemTextHandle (CWPluginContext context, long whichItem, CWMemHandle text); CW_CALLBACK CWPanelGetItemData (CWPluginContext context, long dlgItemID, void *outData, long *outDataLength); CW_CALLBACK CWPanelSetItemData (CWPluginContext context, long dlgItemID, void *inData, long inDataLength); CW_CALLBACK CWPanelGetItemMaxLength (CWPluginContext context, long dlgItemID, short *outLength); CW_CALLBACK CWPanelSetItemMaxLength (CWPluginContext context, long dlgItemID, short inLength); CW_CALLBACK CWPanelChooseRelativePath (CWPluginContext context, CWRelativePath *ioPath, Boolean isFolder, short filterCount, void *filterList, char *prompt); CW_CALLBACK CWPanelGetRelativePathString(CWPluginContext context, CWRelativePath *inPath, char *pathString, long* maxLength); /* CellView related, with string elements */ // selection CW_CALLBACK CWPanelListViewSelectCell (CWPluginContext context,long dlgItemID,long col,long row,Boolean addToSelection); CW_CALLBACK CWPanelListViewUnselectCell (CWPluginContext context,long dlgItemID,long col,long row,Boolean *result); CW_CALLBACK CWPanelListViewSelectNothing (CWPluginContext context,long dlgItemID); CW_CALLBACK CWPanelListViewGetSelectionCount (CWPluginContext context,long dlgItemID,long *count); CW_CALLBACK CWPanelListViewGetSelection (CWPluginContext context,long dlgItemID,long *col,long *row); // rows CW_CALLBACK CWPanelListViewAddRows (CWPluginContext context,long dlgItemID,long afterRow,long count); CW_CALLBACK CWPanelListViewDeleteRows (CWPluginContext context,long dlgItemID,long firstRow,long count); CW_CALLBACK CWPanelListViewGetRowCount (CWPluginContext context,long dlgItemID,long *count); // refresh CW_CALLBACK CWPanelListViewRefreshRow (CWPluginContext context,long dlgItemID,long row); // columns CW_CALLBACK CWPanelListViewAddCols (CWPluginContext context,long dlgItemID,long afterCol,long count); CW_CALLBACK CWPanelListViewDeleteCols (CWPluginContext context,long dlgItemID,long firstCol,long count); CW_CALLBACK CWPanelListViewGetColCount (CWPluginContext context,long dlgItemID,long *count); CW_CALLBACK CWPanelListViewGetColWidth (CWPluginContext context,long dlgItemID,long col,short *colWidth); CW_CALLBACK CWPanelListViewSetColWidth (CWPluginContext context,long dlgItemID,long col,short colWidth); CW_CALLBACK CWPanelListViewNextCell (CWPluginContext context,long dlgItemID,long *col,long *row,Boolean hNext,Boolean vNext,Boolean selectableOnly,Boolean *result); // col and row is in-> and <-out CW_CALLBACK CWPanelListViewRefreshCell (CWPluginContext context,long dlgItemID,long col,long row); CW_CALLBACK CWPanelListViewScrollToCell (CWPluginContext context,long dlgItemID,long col,long row,Boolean inRefresh); CW_CALLBACK CWPanelListViewGetCellTextValue (CWPluginContext context,long dlgItemID,long col,long row,char* str, short maxLen); CW_CALLBACK CWPanelListViewSetCellTextValue (CWPluginContext context,long dlgItemID,long col,long row,char* str); // utilities for giving a answer to a request CW_CALLBACK CWPanelListViewSetDoubleClickHandled(CWPluginContext context, Boolean value); CW_CALLBACK CWPanelListViewSetEditable (CWPluginContext context, Boolean value); CW_CALLBACK CWPanelListViewGetCell (CWPluginContext context, long *col,long *row); /* Preference data related */ CW_CALLBACK CWPanelGetOriginalPrefs (CWPluginContext context, CWMemHandle* originalPrefs); CW_CALLBACK CWPanelGetCurrentPrefs (CWPluginContext context, CWMemHandle* currentPrefs); CW_CALLBACK CWPanelGetFactoryPrefs (CWPluginContext context, CWMemHandle* factoryPrefs); CW_CALLBACK CWPanelGetDebugFlag (CWPluginContext context, Boolean* debugOn); CW_CALLBACK CWPanelSetRevertFlag (CWPluginContext context, Boolean canRevert); CW_CALLBACK CWPanelSetFactoryFlag (CWPluginContext context, Boolean canFactory); CW_CALLBACK CWPanelSetResetPathsFlag (CWPluginContext context, Boolean resetPaths); CW_CALLBACK CWPanelSetRecompileFlag (CWPluginContext context, Boolean recompile); CW_CALLBACK CWPanelSetRelinkFlag (CWPluginContext context, Boolean relink); CW_CALLBACK CWPanelSetReparseFlag (CWPluginContext context, Boolean reparse); CW_CALLBACK CWPanelGetPanelPrefs (CWPluginContext context, const char* panelName, CWMemHandle *prefs, Boolean* requiresByteSwap); CW_CALLBACK CWPanelGetOldProjectFile (CWPluginContext context, CWFileSpec* projectSpec); CW_CALLBACK CWPanelGetToEndian (CWPluginContext context, short* toEndian); #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS CW_CALLBACK CWPanelGetAEKeyword (CWPluginContext context, AEKeyword* keyword); CW_CALLBACK CWPanelGetAEDesc (CWPluginContext context, AEDesc* desc); CW_CALLBACK CWPanelSetAEDesc (CWPluginContext context, const AEDesc* desc); CW_CALLBACK CWPanelReadRelativePathAEDesc (CWPluginContext context, CWRelativePath* path, const AEDesc* desc); CW_CALLBACK CWPanelWriteRelativePathAEDesc (CWPluginContext context, const CWRelativePath* path, AEDesc* desc); #endif /* Reading and writing scalar settings */ CW_CALLBACK CWReadBooleanSetting (CWPluginContext context, const char* name, Boolean* value); CW_CALLBACK CWReadIntegerSetting (CWPluginContext context, const char* name, long* value); CW_CALLBACK CWReadFloatingPointSetting (CWPluginContext context, const char* name, double* value); CW_CALLBACK CWReadStringSetting (CWPluginContext context, const char* name, const char** value); CW_CALLBACK CWReadRelativePathSetting (CWPluginContext context, const char* name, CWRelativePath* value); CW_CALLBACK CWWriteBooleanSetting (CWPluginContext context, const char* name, Boolean value); CW_CALLBACK CWWriteIntegerSetting (CWPluginContext context, const char* name, long value); CW_CALLBACK CWWriteFloatingPointSetting (CWPluginContext context, const char* name, double value); CW_CALLBACK CWWriteStringSetting (CWPluginContext context, const char* name, const char* value); CW_CALLBACK CWWriteRelativePathSetting (CWPluginContext context, const char* name, const CWRelativePath* value); /* Reading and writing array and structure settings */ CW_CALLBACK CWGetNamedSetting (CWPluginContext context, const char* name, CWSettingID* settingID); CW_CALLBACK CWGetStructureSettingField (CWPluginContext context, CWSettingID settingID, const char* name, CWSettingID* fieldSettingID); CW_CALLBACK CWGetArraySettingSize (CWPluginContext context, CWSettingID settingID, long* size); CW_CALLBACK CWGetArraySettingElement (CWPluginContext context, CWSettingID settingID, long index, CWSettingID* elementSettingID); CW_CALLBACK CWGetBooleanValue (CWPluginContext context, CWSettingID settingID, Boolean* value); CW_CALLBACK CWGetIntegerValue (CWPluginContext context, CWSettingID settingID, long* value); CW_CALLBACK CWGetFloatingPointValue (CWPluginContext context, CWSettingID settingID, double* value); CW_CALLBACK CWGetStringValue (CWPluginContext context, CWSettingID settingID, const char** value); CW_CALLBACK CWGetRelativePathValue (CWPluginContext context, CWSettingID settingID, CWRelativePath* value); CW_CALLBACK CWSetBooleanValue (CWPluginContext context, CWSettingID settingID, Boolean value); CW_CALLBACK CWSetIntegerValue (CWPluginContext context, CWSettingID settingID, long value); CW_CALLBACK CWSetFloatingPointValue (CWPluginContext context, CWSettingID settingID, double value); CW_CALLBACK CWSetStringValue (CWPluginContext context, CWSettingID settingID, const char* value); CW_CALLBACK CWSetRelativePathValue (CWPluginContext context, CWSettingID settingID, const CWRelativePath* value); #ifdef __cplusplus } #endif #ifdef __MWERKS__ #pragma options align=reset #endif #ifdef _MSC_VER #pragma pack(pop) #endif #endif /* __CWDROPINPANEL_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/CWPluginErrors.h b/sdk_hdrs/CWPluginErrors.h
new file mode 100755
index 0000000..74f93c7
--- /dev/null
+++ b/sdk_hdrs/CWPluginErrors.h
@@ -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__ \ No newline at end of file
diff --git a/sdk_hdrs/CWPlugins.h b/sdk_hdrs/CWPlugins.h
new file mode 100755
index 0000000..b3dbd2a
--- /dev/null
+++ b/sdk_hdrs/CWPlugins.h
@@ -0,0 +1 @@
+/* * CWPlugins.h - Common declarations for Metrowerks CodeWarriorª plugins * * Copyright © 1995-1997 Metrowerks, Inc. All rights reserved. * */ #ifndef __CWPlugins_H__ #define __CWPlugins_H__ #ifdef __MWERKS__ # pragma once #endif #define CWPLUGIN_HOST_MACOS 1 #define CWPLUGIN_HOST_WIN32 2 #define CWPLUGIN_HOST_SOLARIS 3 #define CWPLUGIN_HOST_LINUX 4 #ifndef CWPLUGIN_HOST # ifdef WIN32 # define CWPLUGIN_HOST CWPLUGIN_HOST_WIN32 # elif defined(macintosh) # define CWPLUGIN_HOST CWPLUGIN_HOST_MACOS # elif defined(__sun__) # define CWPLUGIN_HOST CWPLUGIN_HOST_SOLARIS # elif defined(__linux__) # define CWPLUGIN_HOST CWPLUGIN_HOST_LINUX # else # error # endif #endif #define CWPLUGIN_API_MACOS 1 #define CWPLUGIN_API_WIN32 2 #define CWPLUGIN_API_UNIX 3 #ifndef CWPLUGIN_API # ifdef WIN32 # define CWPLUGIN_API CWPLUGIN_API_WIN32 # elif defined(macintosh) # define CWPLUGIN_API CWPLUGIN_API_MACOS # elif defined(__sun__) || defined(__linux__) # define CWPLUGIN_API CWPLUGIN_API_UNIX # else # error # endif #endif /* ** Radix 256 notation where a 32-bit integer is created from four ** ASCII characters. A four-character constant of this form, say ** 'ABCD', must always be represented with the same pattern, 0x41424344 ** in this case, regardless of big/little endian issues. */ typedef long CWFourCharType; #define CWFOURCHAR(a, b, c, d) \ (((CWFourCharType) ((a) & 0xff) << 24) \ | ((CWFourCharType) ((b) & 0xff) << 16) \ | ((CWFourCharType) ((c) & 0xff) << 8) \ | ((CWFourCharType) ((d) & 0xff))) #if CWPLUGIN_API == CWPLUGIN_API_UNIX #include <sys/param.h> #endif #ifndef CW_USE_PRAGMA_EXPORT #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS #define CW_USE_PRAGMA_EXPORT 1 #else #define CW_USE_PRAGMA_EXPORT 0 #endif #endif #ifndef CW_USE_PRAGMA_IMPORT #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS #define CW_USE_PRAGMA_IMPORT 1 #else #define CW_USE_PRAGMA_IMPORT 0 #endif #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifdef __cplusplus extern "C" { #endif #if CW_USE_PRAGMA_IMPORT #pragma import on #endif /* These constants specify the action the IDE is asking the plugin to execute */ enum { reqInitialize = -2, /* called when the plugin is loaded */ reqTerminate = -1, /* called when the plugin is unloaded */ reqIdle = -100, /* called periodically to allow for plugin tasks EP 6/24/98 */ reqAbout = -101, /* called to ask plugin to display about dialog EP 6/24/98 */ reqPrefsChange = -102 /* called when an associated pref panel changes EP 6/24/98 */ }; /* Used in CWFileInfo.dependencyType to indicate what type of make */ /* dependency to establish between files */ typedef enum CWDependencyType { cwNoDependency, /* do not establish a dependency */ cwNormalDependency, /* recompile dependent whenever prereq changes */ cwInterfaceDependency /* recompile only if interface to file changes */ } CWDependencyType; /* Used in CWFileInfo.filedatatype to indicate the type of data in a loaded file */ enum { cwFileTypeUnknown, /* unknown binary data */ cwFileTypeText, /* normal text file */ cwFileTypePrecompiledHeader /* cached precompiled header */ }; /* constant for CWFileInfo.isdependentoffile */ #define kCurrentCompiledFile -1L /* constant for CWStorePluginData/CWGetPluginData */ #define kTargetGlobalPluginData -1L /* constant for CWNewProjectEntryInfo link order, segment, and overlay values */ #define kDefaultLinkPosition -1L /* Selectors for CWFindLogicalDirectory */ enum { kIDEDirectorySelector = 1, /* parent directory of IDE application; "bin" folder on Win32 */ kCodeWarriorDirectorySelector, /* root CodeWarrior directory */ kSystemDirectorySelector, /* system directory */ kProjectDirectorySelector, /* parent directory of current project */ kProjectDataDirectorySelector, /* project data directory */ kTargetDataDirectorySelector, /* target data directory (within project data directory) */ kTargetObjectCodeDirectorySelector, /* object code directory (within target data directory) */ kDebuggerCacheDirectorySelector, /* "CW Debugging Cache" directory */ kHelperAppsDirectorySelector, /* "(Helper Apps)" directory */ kPluginsDirectorySelector, /* "CodeWarrior Plugins" (Mac) or "plugins" (Win32) directory */ kPluginParentDirectorySelector, /* parent directory of current plugin */ kStationeryDirectorySelector, /* "(Project Stationery)" directory */ kRADStationeryDirectorySelector, /* "RAD Stationery" directory */ kLocalizedResourcesDirectorySelector /* "resources" directory */ }; /* CWPluginContext is a magic cookie passed to all plugins. It must */ /* be passed back to all IDE callbacks */ typedef struct CWPluginPrivateContext* CWPluginContext; /* CWResult is the error/status result returned by all IDE API routine. */ /* The most common errors are returned directly. For OS-specific errors, the */ /* CWResult is cwErrOSError, and the OS-specific error can be obtained by */ /* calling CWGetOSError() */ typedef long CWResult; /* CWMemHandle is an abstraction for memory used in some parts */ /* of the plugin API. API routines must be used to allocate */ /* and free CWMemHandles, or to convert them to pointers. */ typedef struct CWMemHandlePrivateStruct* CWMemHandle; /* Used to identify custom data associated by a plugin with */ /* a project file or a target as a whole. Must be a four character */ /* constant. All lower case constants are reserved by the IDE */ typedef unsigned long CWDataType; /* Some information used in the compiler/linker API is platform-dependent */ /* We use some typedefs to isolate the differences */ /* CWFileSpec contains the native platform file specifier. */ /* CWFileName contains the string type for a native file name */ /* CWFileTime contains the native platform file timestamp */ /* CWOSResult contains the native platform error return value */ /* CWResult contains an API routine error/status result */ /* CW_CALLBACK is a macro defining the calling convention and return type for */ /* IDE callback routines. */ /* CW_PLUGINENTRY is a macro defining the calling convention and return type for */ /* plugin entry points. */ /* CWSUCCESS is a macro that evaluates to true when given a CWResult indicating an */ /* routine succeeded */ #if CWPLUGIN_API == CWPLUGIN_API_MACOS typedef FSSpec CWFileSpec; typedef char CWFileName[32]; typedef unsigned long CWFileTime; typedef OSErr CWOSResult; #elif CWPLUGIN_API == CWPLUGIN_API_WIN32 typedef unsigned char Boolean; typedef struct CWFileSpec { char path[MAX_PATH]; } CWFileSpec; typedef char CWFileName[65]; typedef FILETIME CWFileTime; typedef DWORD CWOSResult; #elif CWPLUGIN_API == CWPLUGIN_API_UNIX #define MAX_PATH MAXPATHLEN #ifndef __MACTYPES__ typedef unsigned char Boolean; #endif #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE 1 #endif typedef struct CWFileSpec { char path[MAX_PATH]; } CWFileSpec; typedef char CWFileName[65]; typedef time_t CWFileTime; typedef int CWOSResult; #else #error Unknown plugin API! #endif #define CWSUCCESS(result) ((result) == 0) #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS #define CW_CALLBACK pascal CWResult #define CW_CALLBACK_PTR(function_name) pascal CWResult (function_name) #define CWPLUGIN_ENTRY(function_name) pascal short (function_name) #elif CWPLUGIN_HOST == CWPLUGIN_HOST_WIN32 #define CW_CALLBACK CWResult __stdcall #define CW_CALLBACK_PTR(function_name) CWResult (__stdcall function_name) #define CWPLUGIN_ENTRY(function_name) short (__stdcall function_name) #elif CWPLUGIN_HOST==CWPLUGIN_HOST_SOLARIS || CWPLUGIN_HOST==CWPLUGIN_HOST_LINUX #define CW_CALLBACK CWResult #define CW_CALLBACK_PTR(function_name) CWResult (function_name) #define CWPLUGIN_ENTRY(function_name) short (function_name) #else #error Unknown plugin host! #endif /* information returned by CWFindAndLoadFile */ typedef struct CWFileInfo { Boolean fullsearch; /* [<-] do we do a full search of paths for file */ char dependencyType; /* [<-] type CWDependencyType */ long isdependentoffile; /* [<-] this file is a dependent of file id */ /* (zero based) or -1L if of current file */ Boolean suppressload; /* [<-] find but don't load the file */ Boolean padding; /* [**] structure padding */ const char* filedata; /* [->] point to the file text/data, or NULL */ long filedatalength; /* [->] length of filedata */ short filedatatype; /* [->] type of data pointed to by filedata */ /* the remaining members are valid only when called by compilers */ short fileID; /* [->] use in browse records and dependencies */ CWFileSpec filespec; /* [->] specifies the file on disk */ Boolean alreadyincluded; /* [->] TRUE if already included in current compile */ Boolean recordbrowseinfo; /* [->] record browse info for this file? */ } CWFileInfo; /* information maintained by the IDE for each segment in the project */ typedef struct CWProjectSegmentInfo { char name[32]; /* segment name */ short attributes; /* segment attributes */ } CWProjectSegmentInfo; /* 64 bit address */ typedef struct CWAddr64 { long lo; /* low order longword of address */ long hi; /* high order longword of address */ } CWAddr64; /* describes an overlay group, Use CWGetOverlayGroup1Info to iterate over overlay groups */ typedef struct CWOverlay1GroupInfo { char name[256]; /* overlay group name */ CWAddr64 address; /* load address */ long numoverlays; /* number of overlays in this group */ } CWOverlay1GroupInfo; /* describes an overlay, use CWGetOverlay1Info to iterate over overlays */ typedef struct CWOverlay1Info { char name[256]; /* name of this overlay */ long numfiles; /* number of files in the overlay */ } CWOverlay1Info; /* describes a file in an overlay, use CWGetOverlayFile1Info to iterate over files. Use */ /* whichfile in calls taking a file number, e.g. CWLoadObjectData or CWGetFileInfo */ typedef struct CWOverlay1FileInfo { long whichfile; /* flat file number */ } CWOverlay1FileInfo; /* * All compiler errors or warnings which occur at some specific location in some * source file are identified by a CWMessageRef structure. This structure * provides sufficient information for the development environment to locate * and display the exact position associated with a message. For each message, * the compiler provides: * * errorstring: contains a description of the error, e.g. "syntax error" * errorline: contains a subset of the text containing the error * errorlevel: indicates if the "error" is an error, warning, or informational message * CWMessageRef: further info so the IDE can perform two tasks: * - Display a summary of each message, with the "error token" * underlined within the compiler-provided errorline. This * information is provided by the tokenoffset and tokenlength * fields. If tokenLength is zero then no underlining is performed. * * - Open the file containing the error and select the full * text of the error. This information is provided by the * selectionoffset and selectionlength fields. */ typedef struct CWMessageRef { CWFileSpec sourcefile; /* file containing error */ long linenumber; /* error linenumber in file */ short tokenoffset; /* offset into errorline of token underline */ short tokenlength; /* length of error token to be underlined */ long selectionoffset; /* start of error for text selection */ long selectionlength; /* length of error for text selection */ } CWMessageRef; /* message types, used for errorlevel parameter to message routines */ enum { messagetypeInfo, /* informational only */ messagetypeWarning, /* warning message */ messagetypeError /* error message */ }; /* information maintained by the IDE for each file in the project */ typedef struct CWProjectFileInfo { CWFileSpec filespec; /* CW_FileSpec of file in project */ CWFileTime moddate; /* date source file was last modified */ short segment; /* segment number of file */ Boolean hasobjectcode; /* file has object code to be linked */ Boolean hasresources; /* file has resources to be linked */ Boolean isresourcefile; /* file -is- a resource file to be linked */ Boolean weakimport; /* file has "Import Weak" flag set */ Boolean initbefore; /* file has "Init Before" flag set */ Boolean gendebug; /* file has generate debug info on */ CWFileTime objmoddate; /* date object code was last modified */ CWFileName dropinname; /* name of dropin used to process this file */ short fileID; /* fileID to use in browse records */ Boolean recordbrowseinfo; /* record browse info for this file? */ Boolean reserved; /* reserved and used internally */ #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS /* some Macintosh-specific information */ OSType filetype; /* MacOS file type */ OSType filecreator; /* MacOS file creator */ #endif Boolean hasunitdata; /* file has associated unit data (Pascal) */ Boolean mergeintooutput; /* file has "Merge Into Output" flag set */ unsigned long unitdatadependencytag; /* dependency tag (i.e. checksum) of unit data (Pascal) */ } CWProjectFileInfo; typedef struct CWNewTextDocumentInfo { const char* documentname; /* name for new document, can be NULL */ CWMemHandle text; /* initial text for document */ Boolean markDirty; /* mark doc as needing to be saved? */ } CWNewTextDocumentInfo; typedef struct CWNewProjectEntryInfo { /* use kDefaultLinkPosition to get default link order, overlay, or segment */ long position; /* optional link order position */ long segment; /* optional segment number */ long overlayGroup; /* optional overlay group number */ long overlay; /* optional overlay number */ const char* groupPath; /* optional fully qualified path to file group */ Boolean mergeintooutput; /* set merge into output flag? */ Boolean weakimport; /* set weak import flag? */ Boolean initbefore; /* set initbefore flag? */ } CWNewProjectEntryInfo; typedef struct CWIDEInfo { unsigned short majorVersion; unsigned short minorVersion; unsigned short bugFixVersion; unsigned short buildVersion; unsigned short dropinAPIVersion; } CWIDEInfo; /* Structures for getting the list of access paths. */ /* The callback does the filtering on the host flags, so the list returned */ /* will only contain the paths that are enabled for the host platform. */ /* There are separate APIs to get the Mac OS X framework style access paths. */ typedef enum CWAccessPathType { cwSystemPath, cwUserPath } CWAccessPathType; typedef struct CWAccessPathInfo { CWFileSpec pathSpec; Boolean recursive; long subdirectoryCount; } CWAccessPathInfo; typedef struct CWAccessPathListInfo { long systemPathCount; long userPathCount; Boolean alwaysSearchUserPaths; Boolean convertPaths; } CWAccessPathListInfo; /* Structures for getting the list of Mac OS X framework access paths. */ /* The callback does the filtering on the host flags, so the list returned */ /* will only contain the Mac OS X framework style paths that are enabled for */ /* the host platform. */ /* There are separate APIs to get the traditional style access paths. */ typedef struct CWFrameworkAccessPathInfo { CWFileSpec pathSpec; Boolean framework; } CWFrameworkAccessPathInfo; typedef struct CWFrameworkAccessPathListInfo { long systemPathCount; long userPathCount; Boolean alwaysSearchUserPaths; Boolean convertPaths; Boolean requireFrameworkIncludes; } CWFrameworkAccessPathListInfo; /* constants for different types of plugins */ /* Used in the dropintype in the DropInFlags, as well as for the MacOS file type */ enum { CWDROPINLINKERTYPE = CWFOURCHAR('L','i','n','k'), /* type for DropIn linkers */ CWDROPINCOMPILERTYPE= CWFOURCHAR('C','o','m','p'), /* type for DropIn compilers */ CWDROPINPREFSTYPE = CWFOURCHAR('P','a','n','L'), /* type for DropIn panels */ CWDROPINPREFSTYPE_1 = CWFOURCHAR('P','a','n','l'), /* type for 1.x IDE DropIn panels */ CWDROPINVCSTYPE = CWFOURCHAR('V','C','S',' '), /* type for DropIn version control */ CWDROPINCOMTYPE = CWFOURCHAR('C','O','M',' ') /* type for COM-only plugins */ }; typedef long CWPluginType; // one of the above types /* Format of 'Flag' resources, or data returned by dropin's GetDropinFlags entry */ /* point. */ /* */ /* For the version 2 of these resource, we renamed the 'apiversion' field to */ /* 'earliestCompatibleAPIVersion' and added the 'newestAPIVersion' field. */ /* This allows plugins to support more than one API version and therefore run */ /* under more than one version of the IDE. The CWGetAPIVersion call should be used */ /* to determine what API version the IDE is using to talk to a plugin. */ #define kCurrentDropInFlagsVersion 2 typedef struct DropInFlags { short rsrcversion; /* version number of resource */ CWDataType dropintype; /* dropin type (compiler, panel, etc) */ /* earliest API support by this plugin */ unsigned short earliestCompatibleAPIVersion; unsigned long dropinflags; /* capability flags */ CWDataType edit_language; /* language */ unsigned short newestAPIVersion; /* newest API version supported */ } DropInFlags, **DropInFlagsHandle; #define kCurrentCWPanelListVersion 1 typedef struct CWPanelList { short version; short count; const char** names; } CWPanelList; #define kCurrentCWFamilyListVersion 1 #define kCurrentCWFamilyResourceVersion 1 typedef struct CWFamily { CWDataType type; const char* name; } CWFamily; typedef struct CWFamilyList { short version; short count; CWFamily* families; } CWFamilyList; typedef struct CWFamilyResource { short version; CWDataType type; unsigned char name[64]; } CWFamilyResource; #define kCurrentCWHelpInfoVersion 1 typedef struct CWHelpInfo { short version; const char* helpFileName; } CWHelpInfo; #define kCurrentCWRelativePathVersion 1 typedef enum CWRelativePathFormat { format_Generic = 0, // Simple name, not platform-specific format_Mac, // Uses : as separator :: for parent directory format_Win, // Uses \ as separator .. for parent directory format_Unix // Uses / as separator .. for parent directory } CWRelativePathFormat; typedef enum CWRelativePathTypes { type_Absolute = 0, type_Project, type_Compiler, type_System, type_UserDefined } CWRelativePathTypes; typedef struct CWRelativePath { short version; // version number unsigned char pathType; // use CWRelativePathTypes unsigned char pathFormat; // use CWRelativePathFormat char userDefinedTree[256]; // user-defined tree name char pathString[512]; // actual path string } CWRelativePath; /* * */ #define kCurrentCWPluginInfoVersion 1 typedef struct CWPluginInfo { short version; // struct version number const char* companyName; // i.e. Metrowerks const char* pluginName; // Defaults to Dropin->GetName() const char* pluginDisplayName; const char* familyName; // i.e. Java unsigned short majorIDEVersion; // Version of IDE Required unsigned short minorIDEVersion; } CWPluginInfo; /* Declaration of plugin entry points that must be implemented by non-MacOS plugins */ /* It can also be implemented for MacOS plugins instead of having a 'Flag' resource */ CWPLUGIN_ENTRY (CWPlugin_GetDropInFlags)(const DropInFlags**, long* flagsSize); /* Declaration of plugin entry points that may optionally be implemented by plugins */ /* These entry points override the corresponding resources on MacOS */ CWPLUGIN_ENTRY (CWPlugin_GetDropInName)(const char** dropInName); CWPLUGIN_ENTRY (CWPlugin_GetDisplayName)(const char** displayName); CWPLUGIN_ENTRY (CWPlugin_GetPanelList)(const CWPanelList** panelList); CWPLUGIN_ENTRY (CWPlugin_GetFamilyList)(const CWFamilyList** familyList); CWPLUGIN_ENTRY (CWPlugin_GetHelpInfo)(const CWHelpInfo** helpInfo); /* Declaration of info plugin entry point that must be implemented by all COM plugins */ CWPLUGIN_ENTRY (CWPlugin_GetPluginInfo)(const CWPluginInfo** pluginInfo); /* Callback declarations: these callbacks are supported for all CodeWarrior plugins */ /* Get the action the IDE is requesting of the plugin */ CW_CALLBACK CWGetPluginRequest(CWPluginContext context, long* request); /* Call when finished handling a request, just before returning to the shell */ CW_CALLBACK CWDonePluginRequest(CWPluginContext, CWResult resultCode); /* Get the version number of API used by the IDE to talk to the plugin */ CW_CALLBACK CWGetAPIVersion(CWPluginContext context, long* version); /* Get information about the IDE being used */ CW_CALLBACK CWGetIDEInfo(CWPluginContext context, CWIDEInfo* info); /* Get the OS error associated with the last callback */ CW_CALLBACK CWGetCallbackOSError(CWPluginContext context, CWOSResult* error); /* Set the OS error associated with a failed plugin request */ CW_CALLBACK CWSetPluginOSError(CWPluginContext context, CWOSResult); /* Get the file specifier for the current project */ CW_CALLBACK CWGetProjectFile(CWPluginContext context, CWFileSpec* projectSpec); /* Get the directory where the IDE stores target-specific generated data */ CW_CALLBACK CWGetTargetDataDirectory(CWPluginContext context, CWFileSpec* targetDataDirectorySpec); /* Get the name of the current target in the current project */ CW_CALLBACK CWGetTargetName(CWPluginContext context, char* name, short maxLength); /* Get the directory where output files should be stored */ CW_CALLBACK CWGetOutputFileDirectory(CWPluginContext context, CWFileSpec* outputFileDirectory); /* Get the number of files in the current project */ CW_CALLBACK CWGetProjectFileCount(CWPluginContext context, long* count); /* Get information about a particular file in the project */ CW_CALLBACK CWGetFileInfo(CWPluginContext context, long whichfile, Boolean checkFileLocation, CWProjectFileInfo* fileinfo); /* Search for a file by name on the current file's access paths. */ CW_CALLBACK CWFindAndLoadFile(CWPluginContext context, const char* filename, CWFileInfo *fileinfo); /* Get the access paths for the current target */ CW_CALLBACK CWGetAccessPathListInfo(CWPluginContext context, CWAccessPathListInfo* pathListInfo); CW_CALLBACK CWGetAccessPathInfo(CWPluginContext context, CWAccessPathType pathType, long whichPath, CWAccessPathInfo* pathInfo); CW_CALLBACK CWGetAccessPathSubdirectory(CWPluginContext context, CWAccessPathType pathType, long whichPath, long whichSubdirectory, CWFileSpec* subdirectory); CW_CALLBACK CWGetFrameworkAccessPathListInfo(CWPluginContext context, CWFrameworkAccessPathListInfo* pathListInfo); CW_CALLBACK CWGetFrameworkAccessPathInfo(CWPluginContext context, CWAccessPathType pathType, long whichPath, CWFrameworkAccessPathInfo* pathInfo); /* Get file text, from the editor, include file cache, or by reading the file */ CW_CALLBACK CWGetFileText(CWPluginContext context, const CWFileSpec* filespec, const char** text, long* textLength, short* filedatatype); /* Release file text returned by CWFindAndLoadFile and CWGetFileText */ CW_CALLBACK CWReleaseFileText(CWPluginContext context, const char* text); /* Get information about a project segment */ CW_CALLBACK CWGetSegmentInfo(CWPluginContext context, long whichsegment, CWProjectSegmentInfo* segmentinfo); /* Get the number of overlay groups in the target */ CW_CALLBACK CWGetOverlay1GroupsCount(CWPluginContext context, long* count); /* Get information about a project overlay group */ CW_CALLBACK CWGetOverlay1GroupInfo(CWPluginContext context, long whichgroup, CWOverlay1GroupInfo* groupinfo); /* Get information about an overlay within a group */ CW_CALLBACK CWGetOverlay1Info(CWPluginContext context, long whichgroup, long whichoverlay, CWOverlay1Info* overlayinfo); /* Get information about a file in an overlay */ CW_CALLBACK CWGetOverlay1FileInfo(CWPluginContext context, long whichgroup, long whichoverlay, long whichoverlayfile, CWOverlay1FileInfo* fileinfo); /* Report a error, warning, or informational message */ CW_CALLBACK CWReportMessage(CWPluginContext context, const CWMessageRef* msgRef, const char *line1, const char *line2, short errorlevel, long errorNumber); /* Display an alert. May actually be put in a message, depending on the plugin request */ CW_CALLBACK CWAlert(CWPluginContext context, const char* msg1, const char* msg2, const char* msg3, const char* msg4); /* Display one or two status messages to the user */ CW_CALLBACK CWShowStatus(CWPluginContext context, const char *line1, const char *line2); /* Give to the IDE to handle events and check if user has canceled this operation */ CW_CALLBACK CWUserBreak(CWPluginContext context); /* Return stored preference data, referenced by name. Typically used for preference */ /* panel settings. */ CW_CALLBACK CWGetNamedPreferences(CWPluginContext context, const char* prefsname, CWMemHandle* prefsdata); /* Store data referenced by a data type and file number */ CW_CALLBACK CWStorePluginData(CWPluginContext context, long whichfile, CWDataType type, CWMemHandle prefsdata); /* Return stored data referenced by a data type and file number */ CW_CALLBACK CWGetPluginData(CWPluginContext context, long whichfile, CWDataType type, CWMemHandle* prefsdata); /* Inform the IDE that a file modification date has changed. isGenerated is for use */ /* by compiler and linker plugins only */ CW_CALLBACK CWSetModDate(CWPluginContext context, const CWFileSpec* filespec, CWFileTime* moddate, Boolean isGenerated); /* Ask the IDE to add a file to the current target in the current project. isGenerated */ /* is for use by compiler plugins only. */ CW_CALLBACK CWAddProjectEntry(CWPluginContext context, const CWFileSpec* fileSpec, Boolean isGenerated, const CWNewProjectEntryInfo* projectEntryInfo, long* whichfile); /* Ask the IDE to remove a file from the current target (link-order/segment/overlay) in the current project. */ /* If it's the last target that contains the file, it would be removed from the file list. */ CW_CALLBACK CWRemoveProjectEntry(CWPluginContext context, const CWFileSpec* fileSpec); /* Create a new editor window, supplying initial text and an optional document name */ CW_CALLBACK CWCreateNewTextDocument(CWPluginContext, const CWNewTextDocumentInfo* docinfo); /* Allocate memory. Permanent memory is not freed until the plugin is unloaded. */ /* Temporary memory is freed after each plugin request completes. */ CW_CALLBACK CWAllocateMemory(CWPluginContext context, long size, Boolean isPermanent, void** ptr); /* Free memory allocated via CWAllocateMemory */ CW_CALLBACK CWFreeMemory(CWPluginContext context, void* ptr, Boolean isPermanent); /* Allocate a memory handle of the requested size. All handles are automatically */ /* freed at the end of each compiler/linker request. useTempMemory is MacOS-specific*/ CW_CALLBACK CWAllocMemHandle(CWPluginContext context, long size, Boolean useTempMemory, CWMemHandle* handle); /* Free a memory handle */ CW_CALLBACK CWFreeMemHandle(CWPluginContext context, CWMemHandle handle); /* Return the current size of a memory handle */ CW_CALLBACK CWGetMemHandleSize(CWPluginContext context, CWMemHandle handle, long* size); /* Resize an existing memory handle */ CW_CALLBACK CWResizeMemHandle(CWPluginContext context, CWMemHandle handle, long newSize); /* To obtain a pointer to the block, you must lock the handle */ /* moveHi is MacOS-specific */ CW_CALLBACK CWLockMemHandle(CWPluginContext context, CWMemHandle handle, Boolean moveHi, void** ptr); /* Unlock a memory handle, the pointer returned by locking the handle may no */ /* longer be valid */ CW_CALLBACK CWUnlockMemHandle(CWPluginContext context, CWMemHandle handle); #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS /* Utility function to map MacOS error codes to a CWResult code. Plugins */ /* may internally generate OSErrs, but need to return CWResult to the */ /* CodeWarrior IDE */ CW_CALLBACK CWMacOSErrToCWResult(CWPluginContext context, OSErr err); #endif /* Turn off the built in PP window manager while the plugin displays a dialog */ CW_CALLBACK CWPreDialog(CWPluginContext context); /* Turn on the built in PP window manager after the plugin is through with its */ /* dialog */ CW_CALLBACK CWPostDialog(CWPluginContext context); /* Notify the IDE that the plugin will be performing actions on a file */ CW_CALLBACK CWPreFileAction(CWPluginContext context, const CWFileSpec *theFile); /* Notify the IDE that the plugin is finished performing actions on a file */ CW_CALLBACK CWPostFileAction(CWPluginContext context, const CWFileSpec *theFile); CW_CALLBACK CWResolveRelativePath(CWPluginContext context, const CWRelativePath* relativePath, CWFileSpec* fileSpec, Boolean create); CW_CALLBACK CWFindLogicalDirectory(CWPluginContext context, long selector, CWFileSpec *dirSpec); CW_CALLBACK CWOpenFileInEditor(CWPluginContext context, const CWFileSpec *fileSpec); #if CWPLUGIN_HOST==CWPLUGIN_HOST_SOLARIS || CWPLUGIN_HOST==CWPLUGIN_HOST_LINUX /* Forward declarations */ struct ICodeWarriorApp; struct ICodeWarriorProject; struct ICodeWarriorDesign; struct ICodeWarriorTarget; #endif /* CWPLUGIN_HOST==CWPLUGIN_HOST_SOLARIS || CWPLUGIN_HOST==CWPLUGIN_HOST_LINUX */ /* Get the IDE application COM interface. Fails if called from any thread */ /* other than the main IDE thread, e.g. a build thread. */ CW_CALLBACK CWGetCOMApplicationInterface(CWPluginContext context, struct ICodeWarriorApp **app); /* Get the current project COM interface. Adds a reference upon return. */ /* Only succeeds if the plugin is being called in the context of a */ /* particular project. Fails if called from any thread */ /* other than the main IDE thread, e.g. a build thread. */ CW_CALLBACK CWGetCOMProjectInterface(CWPluginContext context, struct ICodeWarriorProject **project); /* Get the current design COM interface. Adds a reference upon return. */ /* Only succeeds if the plugin is being called in the context of a */ /* particular target that is associated with a design. */ /* Fails if called from any thread other than the main IDE thread, */ /* e.g. a build thread. */ CW_CALLBACK CWGetCOMDesignInterface(CWPluginContext context, struct ICodeWarriorDesign **design); /* Get the current target COM interface. Adds a reference upon return. */ /* Only succeeds if the plugin is being called in the context of a */ /* particular target. Fails if called from any thread */ /* other than the main IDE thread, e.g. a build thread. */ CW_CALLBACK CWGetCOMTargetInterface(CWPluginContext context, struct ICodeWarriorTarget **target); #if CW_USE_PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #ifdef _MSC_VER #pragma pack(pop) #endif #ifdef __MWERKS__ #pragma options align=reset #endif #endif /* __CWPlugins_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/CWRuntimeFeatures.h b/sdk_hdrs/CWRuntimeFeatures.h
new file mode 100755
index 0000000..003020c
--- /dev/null
+++ b/sdk_hdrs/CWRuntimeFeatures.h
@@ -0,0 +1 @@
+/*****************************************************************************/ /* Name......: CWRuntimeFeatures.h */ /* Purpose...: Macros to parameterize your runtime environment based on */ /* platform-specific compiler macros. Target/host */ /* configurations to set host/target values as well as */ /* CW_HOST, CW_HOSTOS, CW_HOST_ENDIAN, CW_LINE_ENDING, */ /* and CW_UNIX_TYPE, which is used to discriminate among */ /* the various UNIX versions. */ /* Info......: These settings are common enough to factor into a location */ /* that can be shared by all components, including those */ /* used internally and those shared externally. */ /* Copyright.: ©Copyright 2000 by metrowerks inc. All rights reserved. */ /*****************************************************************************/ #ifndef CW_RuntimeFeatures_H #define CW_RuntimeFeatures_H /************************* * Runtime Definitions * *************************/ /* host / target processors values used to set HOST macro. */ #define CW_MC68K 1 #define CW_POWERPC 2 #define CW_INTEL 3 #define CW_MIPS 4 #define CW_SPARC 5 #define CW_PA_RISC 6 /* host / target operating systems values used to set CW_HOSTOS macro. */ #define CW_MACOS 1 #define CW_BEWORKS 2 #define CW_UNIX 3 #define CW_MSWIN 4 #define CW_MAGIC 5 #define CW_QNX 11 /* UNIX specialization values used to set the CW_UNIX_TYPE macro. */ #define CW_SOLARIS 32 /* Base value to support bit manipulation */ #define CW_LINUX 33 #define CW_RHAPSODY 34 #define CW_HPUX 35 #define CW_IRIX 36 #define CW_AIX 37 #define CW_FREEBSD 38 /* big/little endian values used to set CW_HOST_ENDIAN macro. */ #define CW_ENDIAN_NEUTRAL 0x7fffffff #define CW_BIG_ENDIAN 1 #define CW_LITTLE_ENDIAN 2 #define CW_EITHER_ENDIAN 3 /* ** Detemine run-time environment settings based on clues from the ** compile time settings given by specific compilers. */ #if defined(__MWERKS__) /* Metrowerks Compiler */ #if macintosh && __MC68K__ /* 68K MacOS */ #define CW_HOST CW_MC68K #define CW_HOSTOS CW_MACOS #define CW_HOST_ENDIAN CW_BIG_ENDIAN #define CW_LINE_ENDING "\r" #elif macintosh && __POWERPC__ /* PPC MacOS */ #define CW_HOST CW_POWERPC #define CW_HOSTOS CW_MACOS #define CW_HOST_ENDIAN CW_BIG_ENDIAN #define CW_LINE_ENDING "\r" #elif __INTEL__ && defined(__BEOS__) /* x86 BeOS */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_BEWORKS #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __INTEL__ && defined(__QNX__) /* x86 QNX */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_QNX #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __INTEL__ && __linux__ /* x86 Linux */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_LINUX #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __INTEL__ /* default to Win32 */ /* x86 Assuming Windows */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_MSWIN #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\r\n" #else #error "UNKNOWN CW COMPILER USE" #endif #elif defined(__GNUC__) /* GCC/EGCS Compiler */ #if __i386__ && __linux__ /* x86 Linux */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_LINUX #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __i386__ && __sun__ /* x86 Solaris */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_SOLARIS #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __sparc__ && __linux__ /* SPARC Linux */ #define CW_HOST CW_SPARC #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_LINUX #define CW_HOST_ENDIAN CW_BIG_ENDIAN #define CW_LINE_ENDING "\n" #elif __sparc__ && __sun__ /* SPARC Solaris */ #define CW_HOST CW_SPARC #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_SOLARIS #define CW_HOST_ENDIAN CW_BIG_ENDIAN #define CW_LINE_ENDING "\n" #elif __i386__ && __BEOS__ /* x86 BeOS */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_BEWORKS #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\n" #elif __powerpc__ && __linux__ /* PPC Linux */ #define CW_HOST CW_POWERPC #define CW_HOSTOS CW_UNIX #define CW_UNIX_TYPE CW_LINUX #define CW_HOST_ENDIAN CW_BIG_ENDIAN #define CW_LINE_ENDING "\n" #else #error "UNKNOWN GNU COMPILER USE" #endif #elif defined(_MSC_VER) /* Microsoft VC Compiler */ #if defined(_M_IX86) /* x86 Windows */ #define CW_HOST CW_INTEL #define CW_HOSTOS CW_MSWIN #define CW_HOST_ENDIAN CW_LITTLE_ENDIAN #define CW_LINE_ENDING "\r\n" #else #error "UNKNOWN MSC COMPILER USE" #endif #else #error "UNKNOWN COMPILER" #endif #endif /* CW_RuntimeFeatures_H */ \ No newline at end of file
diff --git a/sdk_hdrs/CWUnixPluginPrefix.h b/sdk_hdrs/CWUnixPluginPrefix.h
new file mode 100755
index 0000000..a261ea3
--- /dev/null
+++ b/sdk_hdrs/CWUnixPluginPrefix.h
@@ -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 */ \ No newline at end of file
diff --git a/sdk_hdrs/CWWinPluginPrefix.h b/sdk_hdrs/CWWinPluginPrefix.h
new file mode 100755
index 0000000..4ad49af
--- /dev/null
+++ b/sdk_hdrs/CWWinPluginPrefix.h
@@ -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 \ No newline at end of file
diff --git a/sdk_hdrs/CatTypes.h b/sdk_hdrs/CatTypes.h
new file mode 100755
index 0000000..421622b
--- /dev/null
+++ b/sdk_hdrs/CatTypes.h
@@ -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__ \ No newline at end of file
diff --git a/sdk_hdrs/CompilerMapping.h b/sdk_hdrs/CompilerMapping.h
new file mode 100755
index 0000000..30ee355
--- /dev/null
+++ b/sdk_hdrs/CompilerMapping.h
@@ -0,0 +1 @@
+/* * CompilerMapping.h - File Type & Extension => Compiler Mapping for Metrowerks CodeWarriorª * * Copyright © 1995 Metrowerks, Inc. All rights reserved. * */ #ifndef __COMPILERMAPPING_H__ #define __COMPILERMAPPING_H__ #ifdef __MWERKS__ # pragma once #endif #ifndef __CWPLUGINS_H__ #include "CWPlugins.h" #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifdef __cplusplus extern "C" { #endif #ifdef __cplusplus const CWDataType Lang_C_CPP = CWFOURCHAR('c','+','+',' '); const CWDataType Lang_Pascal = CWFOURCHAR('p','a','s','c'); const CWDataType Lang_Rez = CWFOURCHAR('r','e','z',' '); const CWDataType Lang_Java = CWFOURCHAR('j','a','v','a'); const CWDataType Lang_MISC = CWFOURCHAR('\?','\?','\?','\?'); #else #define Lang_C_CPP CWFOURCHAR('c','+','+',' ') #define Lang_Pascal CWFOURCHAR('p','a','s','c') #define Lang_Rez CWFOURCHAR('r','e','z',' ') #define Lang_Java CWFOURCHAR('j','a','v','a') #define Lang_MISC CWFOURCHAR('\?','\?','\?','\?') #endif /* Compiler flags, as used in member dropinflags of struct DropInFlags returned by compilers */ enum { kGeneratescode = 1L << 31, /* this compiler generates code */ kGeneratesrsrcs = 1L << 30, /* this compiler generates resources */ kCanpreprocess = 1L << 29, /* this compiler can accept a Preprocess request */ kCanprecompile = 1L << 28, /* this compiler can accept a Precompile request */ kIspascal = 1L << 27, /* this is the pascal compiler */ kCanimport = 1L << 26, /* this compiler needs the "Import Weak" popup */ kCandisassemble = 1L << 25, /* this compiler can disassemble */ kPersistent = 1L << 24, /* keep the compiler resident except on context switches*/ kCompAllowDupFileNames = 1L << 23, /* allow multiple project files with the same name */ kCompMultiTargAware = 1L << 22, /* the compiler can be used with multiple targets */ kIsMPAware = 1L << 21, /* the compiler can be run in an MP thread */ kCompUsesTargetStorage = 1L << 20, /* the compiler keeps storage per target */ kCompEmitsOwnBrSymbols = 1L << 19, /* browser info includes compiler-specific symbols */ kCompAlwaysReload = 1L << 18, /* always reload the compiler before request */ kCompRequiresProjectBuildStartedMsg = 1L << 17, /* Compiler listens for project build started messages */ kCompRequiresTargetBuildStartedMsg = 1L << 16, /* Compiler listens for target build started messages */ kCompRequiresSubProjectBuildStartedMsg = 1L << 15, /* Compiler listens for Sub project build started messages */ kCompRequiresFileListBuildStartedMsg = 1L << 14, /* Compiler listens for filelist build started messages */ kCompReentrant = 1L << 13, /* Compiler can use re-entrant DropIn and is re-entry safe */ kCompSavesDbgPreprocess = 1 << 12, /* Compiler will save preprocessed files for debugging needs */ kCompRequiresTargetCompileStartedMsg = 1 << 11 /* Compiler listens for target compile started/ended messages */ /* remaining flags are reserved for future use and should be zero-initialized */ }; /* Compiler mapping flags, used in CompilerMapping.flags & CWExtensionMapping.flags */ typedef unsigned long CompilerMappingFlags; enum { kPrecompile = 1L << 31, /* should this file type be Precompiled? */ kLaunchable = 1L << 30, /* can this file type be double-clicked on? */ kRsrcfile = 1L << 29, /* does this file type contain resources for linking? */ kIgnored = 1L << 28 /* should files of this type be ignored during Make? */ /* remaining flags are reserved for future use and should be zero-initialized */ }; /* Format of data in 'EMap' resource, or as returned by a compiler's */ /* GetExtensionMapping entry point */ typedef struct CWExtensionMapping { CWDataType type; /* MacOS file type, e.g. 'TEXT' or 0 */ char extension[32]; /* file extension, e.g. .c/.cp/.pch or "" */ CompilerMappingFlags flags; /* see above */ char editlanguage[32]; /* edit language or "" to use default language for plugin */ } CWExtensionMapping; #define kCurrentCWExtMapListVersion 2 #define kCurrentCWExtMapListResourceVersion 2 typedef struct CWExtMapList { short version; short nMappings; CWExtensionMapping* mappings; } CWExtMapList; /* Format of data returned by GetTargetList entry point */ #define kCurrentCWTargetListVersion 1 #define kCurrentCWTargetListResourceVersion 1 typedef struct CWTypeList { short count; CWDataType items[1]; } CW_CPUList, CW_OSList; typedef struct CWTargetList { short version; short cpuCount; CWDataType* cpus; short osCount; CWDataType* oss; } CWTargetList; typedef struct CWTargetListResource { short version; CW_CPUList cpus; CW_OSList oss; } CWTargetListResource; #ifdef __cplusplus } #endif #ifdef _MSC_VER #pragma pack(pop,2) #endif #ifdef __MWERKS__ #pragma options align=reset #endif #endif /* __COMPILERMAPPING_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/DropInCompilerLinker.h b/sdk_hdrs/DropInCompilerLinker.h
new file mode 100755
index 0000000..8551a86
--- /dev/null
+++ b/sdk_hdrs/DropInCompilerLinker.h
@@ -0,0 +1 @@
+/* * DropInCompilerLinker.h - Drop-In Interface for Metrowerks CodeWarriorª Compilers and Linkers * * Copyright © 1996 Metrowerks, Inc. All rights reserved. * */ #ifndef __DROPINCOMPILERLINKER_H__ #define __DROPINCOMPILERLINKER_H__ #ifdef __MWERKS__ # pragma once #endif #ifndef __CWPlugins_H__ #include "CWPlugins.h" #endif #ifndef __COMPILERMAPPING_H__ #include "CompilerMapping.h" #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifdef __cplusplus extern "C" { #endif #if CW_USE_PRAGMA_IMPORT #pragma import on #endif /* this is the current version number of the API documented herein */ #define DROPINCOMPILERLINKERAPIVERSION_4 4 #define DROPINCOMPILERLINKERAPIVERSION_5 5 #define DROPINCOMPILERLINKERAPIVERSION_6 6 #define DROPINCOMPILERLINKERAPIVERSION_7 7 #define DROPINCOMPILERLINKERAPIVERSION_8 8 #define DROPINCOMPILERLINKERAPIVERSION_9 9 #define DROPINCOMPILERLINKERAPIVERSION_10 10 #define DROPINCOMPILERLINKERAPIVERSION_11 11 #define DROPINCOMPILERLINKERAPIVERSION_12 12 #define DROPINCOMPILERLINKERAPIVERSION_13 13 #define DROPINCOMPILERLINKERAPIVERSION DROPINCOMPILERLINKERAPIVERSION_13 /* deprecated request codes */ enum { reqInitCompiler = reqInitialize, /* (called when compiler is loaded) */ reqTermCompiler = reqTerminate, /* (called when compiler is unloaded) */ reqInitLinker = reqInitialize, /* (called when linker is loaded) */ reqTermLinker = reqTerminate /* (called when linker is unloaded) */ }; /* request codes (common) */ enum { reqTargetCompileEnded = -17, /* Sent when target's compile phase ends */ reqTargetCompileStarted = -16, /* Sent when target's compile phase starts */ reqTargetLinkEnded = -15, /* Sent when the link has ended */ reqTargetLinkStarted = -14, /* Sent when the link starts */ reqFileListBuildEnded = -13, /* Sent when the group file build ends */ reqFileListBuildStarted = -12, /* Sent when the group file build starts */ reqSubProjectBuildEnded = -11, /* Sent when subproject's build ends */ reqSubProjectBuildStarted = -10, /* Sent when subproject's build starts */ reqTargetBuildEnded = -9, /* Sent when target's build ends */ reqTargetBuildStarted = -8, /* Sent when target's build starts */ reqProjectBuildEnded = -7, /* Sent when project build ends */ reqProjectBuildStarted = -6, /* Sent when project build starts */ reqTargetLoaded = -5, /* called when the "keeps target info" flag is set */ reqTargetPrefsChanged = -4, /* called when the "keeps target info" flag is set */ reqTargetUnloaded = -3 /* called when the "keeps target info" flag is set */ }; /* requests codes (compilers) */ enum { reqCompile = 0, /* compile/precompile/preprocess source file */ /* and return results */ reqMakeParse, /* used internally by Metrowerks */ reqCompDisassemble, /* disassemble a specific file in the project */ reqCheckSyntax, /* check syntax, but don't generate code */ reqPreprocessForDebugger /* when preprocess, don't open window w/results */ }; /* requests codes (linkers) */ enum { reqLink = 0, /* link project and generate executable or library */ reqDisassemble, /* disassemble a specific file in the project */ reqTargetInfo, /* get info about the generated executable */ reqPreRun /* give linker a last chance to modify target info */ }; /* Returned as part of CWFileInfo to indicate the */ /* type of data pointed to by the filedata pointer */ enum { filetypeText, /* data is text */ filetypeUnknown /* unknown type, could be precompiled header */ }; /* executable linkage types, used in CWTargetInfo.linkType */ enum { exelinkageFlat, /* flat executable */ exelinkageSegmented, /* uses 68K code segments */ exelinkageOverlay1 /* uses overlay groups and overlays */ }; /* output file type, used in CWTargetInfo.outputType */ enum { linkOutputNone, /* linker produces no output */ linkOutputFile, /* linker produces a file */ linkOutputDirectory /* linker produces a directory */ }; /* Constants for the targetCPU field of the CWTargetInfo struct */ enum { targetCPU68K = CWFOURCHAR('6','8','k',' '), targetCPUPowerPC = CWFOURCHAR('p','p','c',' '), targetCPUi80x86 = CWFOURCHAR('8','0','8','6'), targetCPUMips = CWFOURCHAR('m','i','p','s'), targetCPUNECv800 = CWFOURCHAR('v','8','0','0'), targetCPUEmbeddedPowerPC = CWFOURCHAR('e','P','P','C'), targetCPUARM = CWFOURCHAR('a','r','m',' '), targetCPUSparc = CWFOURCHAR('s','p','r','c'), targetCPUIA64 = CWFOURCHAR('I','A','6','4'), targetCPUAny = CWFOURCHAR('*','*','*','*'), targetCPUMCORE = CWFOURCHAR('m','c','o','r'), targetCPU_Intent = CWFOURCHAR('n','t','n','t') }; /* Constants for the targetOS field of the CWTargetInfo struct */ enum { targetOSMacintosh = CWFOURCHAR('m','a','c',' '), targetOSWindows = CWFOURCHAR('w','i','n','t'), targetOSNetware = CWFOURCHAR('n','l','m',' '), targetOSMagicCap = CWFOURCHAR('m','c','a','p'), targetOSOS9 = CWFOURCHAR('o','s','9',' '), targetOSEmbeddedABI = CWFOURCHAR('E','A','B','I'), targetOSJava = CWFOURCHAR('j','a','v','a'), /* java (no VM specification) */ targetOSJavaMS = CWFOURCHAR('j','v','m','s'), /* Microsoft VM */ targetOSJavaSun = CWFOURCHAR('j','v','s','n'), /* Sun VM */ targetOSJavaMRJ = CWFOURCHAR('j','v','m','r'), /* MRJ VM */ targetOSJavaMW = CWFOURCHAR('j','v','m','w'), /* Metrowerks VM */ targetOSPalm = CWFOURCHAR('p','a','l','m'), targetOSGTD5 = CWFOURCHAR('g','t','d','5'), targetOSSolaris = CWFOURCHAR('s','l','r','s'), targetOSLinux = CWFOURCHAR('l','n','u','x'), targetOSAny = CWFOURCHAR('*','*','*','*'), targetOS_Intent = CWFOURCHAR('n','t','n','t') }; /* linker flags, as used in member dropinflags of DropInFlags struct returned by linkers */ enum { cantDisassemble = 1L << 31, /* this linker doesn't support 'Disassemble' */ isPostLinker = 1L << 30, /* this is a post linker */ linkAllowDupFileNames = 1L << 29, /* allow multiple project files with the same name */ linkMultiTargAware = 1L << 28, /* the linker can be used with multiple targets */ isPreLinker = 1L << 27, /* this is a pre linker */ linkerUsesTargetStorage = 1L << 26, /* the linker keeps storage per target */ linkerUnmangles = 1L << 25, /* The linker supports unmangling. */ magicCapLinker = 1L << 24, /* Pre- or post-linker is used for MagicCap */ linkAlwaysReload = 1L << 23, /* Always reload the linker before request */ linkRequiresProjectBuildStartedMsg = 1L << 22, /* Linker listens for a Project Build Started/Ended message */ linkRequiresTargetBuildStartedMsg = 1L << 21, /* Linker listens for a Target Build Started/Ended message */ linkRequiresSubProjectBuildStartedMsg = 1L << 20, /* Linker listens for a Sub Project Build Started/Ended message */ linkRequiresFileListBuildStartedMsg = 1L << 19, /* Linker listens for a File List Build Started/Ended message */ linkRequiresTargetLinkStartedMsg = 1L << 18, /* Linker listens for a Target Link Started/Ended message */ linkerWantsPreRunRequest = 1L << 17, /* Linker wants to be sent the pre-run request */ linkerGetTargetInfoThreadSafe = 1L << 16, /* GetTargetInfo call doesn't use any globals, etc. */ linkerUsesCaseInsensitiveSymbols = 1L << 15, /* All languages used by linker contain case insensitive browser symbols */ linkerDisasmRequiresPreprocess = 1L << 14, /* (obsolete) file must be preprocesed before being passed to linker for disasm */ linkerUsesFrameworks = 1L << 13, /* target uses frameworks; enables framework-style file searching */ linkerInitializeOnMainThread = 1L << 12 /* The Linker needs to be intialized on the main thread. */ /* remaining flags are reserved for future use and should be zero-initialized */ }; /* ways to store dependency returned as CWFileSpec in StoreObjectData */ enum { cwAccessAbsolute, cwAccessPathRelative, cwAccessFileName, cwAccessFileRelative }; /* specifies what browser information compilers should generate */ /* they should always generate records for globals and functions */ typedef struct CWBrowseOptions { Boolean recordClasses; /* [<-] do we record info for classes */ Boolean recordEnums; /* [<-] do we record info for enums */ Boolean recordMacros; /* [<-] do we record info for macros */ Boolean recordTypedefs; /* [<-] do we record info for typedefs */ Boolean recordConstants; /* [<-] do we record info for constants */ Boolean recordTemplates; /* [<-] do we record info for templates */ Boolean recordUndefinedFunctions; /* [<-] do we record info for undefined functions */ long reserved1; /* reserved space */ long reserved2; /* reserved space */ } CWBrowseOptions; /* A dependency tag is associated with unit data in the StoreUnitData callback. It should */ /* change whenever unit data has changed in a way that forces its dependents to be rebuilt. */ /* Typically, it is just a checksum on the unit data. */ typedef unsigned long CWDependencyTag; /* dependency information passed back in StoreObjectData */ typedef struct CWDependencyInfo { long fileIndex; /* Another project entry. -1 => use fileSpec */ CWFileSpec fileSpec; /* location of file. Only used if fileIndex < 0 */ short fileSpecAccessType; /* One of cwAccessAbsolute, etc. above. Only */ /* used is specifying via fileSpec. */ short dependencyType; /* cwNormalDependency or cwInterfaceDependency. */ /* Values defined in CWPlugins.h */ } CWDependencyInfo; /* information used when calling StoreObjectData */ typedef struct CWObjectData { CWMemHandle objectdata; /* Handle to generated object code, */ /* resource data, or preprocessed text */ CWMemHandle browsedata; /* Handle to generated browse data */ long reserved1; /* reserved for future use, set to zero */ long codesize; /* size of generated code */ long udatasize; /* size of uninitialized data */ long idatasize; /* size of initialized data */ long compiledlines; /* number of lines of source compiled */ Boolean interfaceChanged; /* recompile interface dependents? */ long reserved2; /* reserved for future use, set to zero */ void* compilecontext; /* used internally by Metrowerks */ CWDependencyInfo* dependencies; /* optional array of dependencies */ short dependencyCount; /* overrides those collected by IDE */ CWFileSpec* objectfile; /* external object code file (i.e. .o file) */ } CWObjectData; /* characteristics of a link target */ typedef struct CWTargetInfo { short outputType; /* outputs file, directory, or nothing */ CWFileSpec outfile; /* generated executable file/folder spec */ CWFileSpec symfile; /* generated debug file spec */ CWFileSpec runfile; /* file to run, can be same or different from outfile */ short linkType; /* flat, segmented, or overlays */ Boolean canRun; /* "Run" can be performed on this target */ Boolean canDebug; /* "Run with Debugger" can be performed on this target */ CWDataType targetCPU; /* target CPU architecture (e.g. 68K, PowerPC, x86, MIPS)*/ CWDataType targetOS; /* target OS (e.g. MacOS, Windows, Unix) */ #if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS OSType outfileCreator; /* file creator, if outputType == linkOutputFile */ OSType outfileType; /* file type, if outputType == linkOutputFile */ OSType debuggerCreator; /* file creator of debugger for this target */ OSType runHelperCreator; /* creator of helper app to use when running this file. */ #endif #if CWPLUGIN_HOST == CWPLUGIN_HOST_WIN32 Boolean runHelperIsRegKey; /* true if runHelperName is a registry key */ Boolean debugHelperIsRegKey;/* true if debugHelperName is a registry key */ char args[512]; /* command line arguments */ char runHelperName[512]; /* full path to the run helper executable or a reg key */ Boolean runHelperRequiresURL;/* Indicates whether the outfile must be converted to */ /* a file scheme URL before being passed to the run */ /* helper app */ char reserved2; char debugHelperName[512];/* full path to the debug helper executable or a reg key*/ #endif // We need the args for Solaris #if (CWPLUGIN_HOST == CWPLUGIN_HOST_SOLARIS || CWPLUGIN_HOST == CWPLUGIN_HOST_LINUX) char args[512]; /* command line arguments */ char runHelperName[512]; /* Relative path name from (Helper Apps) to run helper program */ Boolean runHelperRequiresURL; /* Indicates whether the outfile must be converted to */ /* a file scheme URL before being passed to the run */ /* helper app */ char reserved2[3]; char debugHelperName[512]; /* Relative path name from (Helper Apps) to debug helper */ #endif CWFileSpec linkAgainstFile; /* file parent targets link against (e.g. lib file) */ } CWTargetInfo; typedef struct CWUnmangleInfo { void* targetStorage; const char* mangledName; char* unmangleBuff; long unmangleBuffSize; unsigned short browserClassID; unsigned char browserLang; unsigned char filler1; } CWUnmangleInfo; /* Types used to get compiler-specific browser symbol information. */ typedef struct CWCompilerBrSymbol { char symName[32]; char symUIName[32]; } CWCompilerBrSymbol; typedef struct CWCompilerBrSymbolList { short count; CWCompilerBrSymbol items[1]; } CWCompilerBrSymbolList; typedef struct CWCompilerBrSymbolInfo { void* targetStorage; CWCompilerBrSymbolList* symList; /* [<-] Compiler should put a pointer to the read-only list here.*/ } CWCompilerBrSymbolInfo; typedef struct CWFrameworkInfo { CWFileSpec fileSpec; /* location of ".framework" directory */ char version[256]; /* which version directory to use; if empty use "Current" sym link */ } CWFrameworkInfo; /*** Declaration of plugin entry points that must be implemented by non-MacOS plugins ***/ /*** It can also be implemented by a MacOS plugin to override the 'Targ' resource ***/ CWPLUGIN_ENTRY (CWPlugin_GetTargetList)(const struct CWTargetList**); /*** Optional entry points ***/ CWPLUGIN_ENTRY (CWPlugin_GetDefaultMappingList)(const struct CWExtMapList**); CWPLUGIN_ENTRY (Helper_Unmangle)(CWUnmangleInfo*); CWPLUGIN_ENTRY (Helper_GetCompilerBrSymbols)(CWCompilerBrSymbolInfo*); /*** callbacks to the IDE, in addition to those in CWPlugins.h ***/ CW_CALLBACK CWIsPrecompiling(CWPluginContext context, Boolean* isPrecompiling); CW_CALLBACK CWIsAutoPrecompiling(CWPluginContext context, Boolean* isAutoPrecompiling); CW_CALLBACK CWIsPreprocessing(CWPluginContext context, Boolean* isPreprocessing); CW_CALLBACK CWIsGeneratingDebugInfo(CWPluginContext context, Boolean* isGenerating); CW_CALLBACK CWIsCachingPrecompiledHeaders(CWPluginContext context, Boolean* isCaching); CW_CALLBACK CWGetBrowseOptions(CWPluginContext context, CWBrowseOptions* browseOptions); CW_CALLBACK CWGetBuildSequenceNumber(CWPluginContext context, long* sequenceNumber); CW_CALLBACK CWGetTargetInfo(CWPluginContext context, CWTargetInfo* targetInfo); CW_CALLBACK CWSetTargetInfo(CWPluginContext context, CWTargetInfo* targetInfo); CW_CALLBACK CWGetTargetStorage(CWPluginContext context, void** storage); CW_CALLBACK CWSetTargetStorage(CWPluginContext context, void* storage); CW_CALLBACK CWGetMainFileNumber(CWPluginContext context, long* fileNumber); CW_CALLBACK CWGetMainFileID(CWPluginContext context, short* fileID); CW_CALLBACK CWGetMainFileSpec(CWPluginContext context, CWFileSpec* fileSpec); CW_CALLBACK CWGetMainFileText(CWPluginContext context, const char** text, long* textLength); CW_CALLBACK CWCachePrecompiledHeader(CWPluginContext context, const CWFileSpec* filespec, CWMemHandle pchhandle); CW_CALLBACK CWLoadObjectData(CWPluginContext context, long whichfile, CWMemHandle* objectdata); CW_CALLBACK CWFreeObjectData(CWPluginContext context, long whichfile, CWMemHandle objectdata); CW_CALLBACK CWStoreObjectData(CWPluginContext context, long whichfile, CWObjectData* object); CW_CALLBACK CWGetSuggestedObjectFileSpec(CWPluginContext context, long whichfile, CWFileSpec* fileSpec); CW_CALLBACK CWGetStoredObjectFileSpec(CWPluginContext context, long whichfile, CWFileSpec* fileSpec); CW_CALLBACK CWDisplayLines(CWPluginContext context, long nlines); CW_CALLBACK CWBeginSubCompile(CWPluginContext context, long whichfile, CWPluginContext* subContext); CW_CALLBACK CWEndSubCompile(CWPluginContext subContext); CW_CALLBACK CWGetPrecompiledHeaderSpec(CWPluginContext context, CWFileSpec *pchspec, const char *target); CW_CALLBACK CWGetResourceFile(CWPluginContext context, CWFileSpec* filespec); CW_CALLBACK CWPutResourceFile(CWPluginContext context, const char* prompt, const char* name, CWFileSpec* filespec); /* Metrowerks Pascal support */ CW_CALLBACK CWLookUpUnit(CWPluginContext context, const char* name, Boolean isdependency, const void** unitdata, long* unitdatalength); CW_CALLBACK CWSBMfiles(CWPluginContext context, short libref); CW_CALLBACK CWStoreUnit(CWPluginContext context, const char* unitname, CWMemHandle unitdata, CWDependencyTag dependencytag); CW_CALLBACK CWReleaseUnit(CWPluginContext context, void* unitdata); CW_CALLBACK CWUnitNameToFileName(CWPluginContext context, const char* unitname, char* filename); /* obsolete, for MacOS backward compatibility only */ #if CWPLUGIN_API == CWPLUGIN_API_MACOS CW_CALLBACK CWOSAlert(CWPluginContext context, const char* message, OSErr errorcode); CW_CALLBACK CWOSErrorMessage(CWPluginContext context, const char *msg, OSErr errorcode); #endif CW_CALLBACK CWGetModifiedFiles(CWPluginContext context, long* modifiedFileCount, const long** modifiedFiles); /* Get information from the "Runtime Settings" panel */ CW_CALLBACK CWGetCommandLineArgs(CWPluginContext context, const char** commandLineArgs); CW_CALLBACK CWGetWorkingDirectory(CWPluginContext context, CWFileSpec* workingDirectorySpec); CW_CALLBACK CWGetEnvironmentVariableCount(CWPluginContext context, long* count); CW_CALLBACK CWGetEnvironmentVariable(CWPluginContext context, long index, const char** name, const char** value); CW_CALLBACK CWGetFrameworkCount(CWPluginContext context, long* frameworkCount); CW_CALLBACK CWGetFrameworkInfo(CWPluginContext context, long whichFramework, CWFrameworkInfo* frameworkInfo); CW_CALLBACK CWGetFrameworkSharedLibrary(CWPluginContext context, long whichFramework, CWFileSpec* frameworkSharedLibrary); #if CW_USE_PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #ifdef _MSC_VER #pragma pack(pop,2) #endif #ifdef __MWERKS__ #pragma options align=reset #endif #endif /* __DROPINCOMPILERLINKER_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/DropInPanel.h b/sdk_hdrs/DropInPanel.h
new file mode 100755
index 0000000..edee6e2
--- /dev/null
+++ b/sdk_hdrs/DropInPanel.h
@@ -0,0 +1 @@
+/* * DropInPanel.h - Drop-In Preferences Panel Interface for Metrowerks CodeWarriorª * * Copyright © 1995 Metrowerks, Inc. All rights reserved. * */ #ifndef __DROPINPANEL_H__ #define __DROPINPANEL_H__ #ifdef __MWERKS__ # pragma once #endif #ifndef CW_STRICT_DIALOGS # define CW_STRICT_DIALOGS 0 #endif #if macintosh #ifndef F_PASCAL # define F_PASCAL(x) pascal x #endif #elif __sun__ || __linux__ #ifndef F_PASCAL # define F_PASCAL(x) x #endif #endif /* system headers */ #ifndef __APPLEEVENTS__ # include <AppleEvents.h> #endif #ifndef __CONTROLS__ # include <Controls.h> #endif #ifndef __DIALOGS__ # include <Dialogs.h> #endif #ifndef __DRAG__ # include <Drag.h> #endif #ifndef __CWPlugins_H__ # include "CWPlugins.h" #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifdef __cplusplus extern "C" { #endif #if CW_USE_PRAGMA_IMPORT #pragma import on #endif /* this is the current version number of the API documented herein */ #define DROPINPANELAPIVERSION_1 1 /* CW7 API version */ #define DROPINPANELAPIVERSION_2 2 /* intermediate version */ #define DROPINPANELAPIVERSION_3 3 /* CW8 API version */ #define DROPINPANELAPIVERSION_4 4 /* CW9 API version */ #define DROPINPANELAPIVERSION_5 5 /* CW10-CW Pro 1 version */ #define DROPINPANELAPIVERSION_6 6 /* CW Pro 2 version */ #define DROPINPANELAPIVERSION_7 7 /* CW Pro 3 version */ #define DROPINPANELAPIVERSION_8 8 /* CW Pro 4 version */ #define DROPINPANELAPIVERSION_9 9 /* CW Pro 5 version */ #define DROPINPANELAPIVERSION_10 10 /* CW Pro 6 version */ #define DROPINPANELAPIVERSION_11 11 /* CW Pro 7 version (listView Support) */ #define DROPINPANELAPIVERSION DROPINPANELAPIVERSION_11 /* current API version */ /* error codes */ #define kBadPrefVersion 1000 #define kMissingPrefErr 1001 #define kSettingNotFoundErr 1002 #define kSettingTypeMismatchErr 1003 #define kInvalidCallbackErr 1004 #define kSettingOutOfRangeErr 1005 /* requests codes */ enum { reqInitPanel = -2, /* (called when panel is loaded) */ reqTermPanel = -1, /* (called when panel is unloaded) */ reqInitDialog = 0, /* initialize panel's dialog state */ reqTermDialog, /* clean up panel's dialog state */ reqPutData, /* copy options data to dialog items */ reqGetData, /* copy dialog items to options data */ reqFilter, /* filter a dialog event for the panel */ reqItemHit, /* process an itemHit in the panel */ reqAEGetPref, /* get preference setting for AppleEvent request */ reqAESetPref, /* set preference setting from AppleEvent request */ reqValidate, /* tell if current settings force recompile or relink */ reqGetFactory, /* retrieve factory settings */ reqUpdatePref, /* verify and/or modify prefs to fit current version */ reqUpdateProject, /* (only sent to built-in panels) */ reqSetupDebug, /* change settings to reflect debugging status */ reqRenameProject, /* change settings that depend on project name */ reqPrefsLoaded, /* (only sent to built-in panels) */ reqDrawCustomItem, /* draw a custom item */ reqActivateItem, /* activate a custom item */ reqDeactivateItem, /* deactivate a custom item */ reqHandleClick, /* handle mouse down in an active custom item */ reqHandleKey, /* handle key down in an active custom item */ reqFindStatus, /* enable/disable menu items for a custom item */ reqObeyCommand, /* execute a menu command for a custom item */ reqDragEnter, /* the user is dragging into the given item */ reqDragWithin, /* the user is dragging within the given item */ reqDragExit, /* the user is dragging out of the given item */ reqDragDrop, /* the user dropped onto the given item */ reqByteSwapData, /* byte swap the fields in the prefs data */ reqFirstLoad, /* panel has been loaded for the first time */ reqReadSettings, /* read settings from IDE to construct pref data handle */ reqWriteSettings, /* write the individual settings from pref data handle */ reqItemDoubleClick, /* process an double clicked in the panel, currently implemented for listviews */ reqItemIsCellEditable /* currently implemented for listviews, tells whether or not the listview is editable */ }; /* menu command codes */ enum { menu_Cut = 1, menu_Copy, menu_Paste, menu_Clear, menu_SelectAll }; /* Layout and bit flags for 'Flag' resource for panels */ /* */ /* For the version 3 of these resource, we renamed the 'apiversion' field to */ /* 'earliestCompatibleAPIVersion' and added the 'newestAPIVersion' field. */ /* This allows plugins to support more than one API version and therefore run */ /* under more than one version of the IDE. */ typedef struct PanelFlags { unsigned short rsrcversion; /* version number of resource */ CWDataType dropintype; /* dropin type ('Comp', 'Link', 'Panl') */ /* earliest API support by this plugin */ unsigned short earliestCompatibleAPIVersion; unsigned long dropinflags; /* capability flags (see enum below) */ CWDataType panelfamily; /* family of panel (linker, codegen, etc) */ unsigned short newestAPIVersion; /* newest API version supported */ unsigned short dataversion; /* version number of prefs data */ unsigned short panelscope; /* scope of panel (see enum below) */ } PanelFlags; /* capability flags, as used in member dropinflags of PanelFlags struct */ enum { usesStrictAPI = 1 << 31, /* this panel is built with the strict API */ supportsByteSwapping = 1 << 30, /* this panel support the byte-swapping request */ supportsTextSettings = 1 << 29, /* this panel supports the read & write settings requests */ usesCrossPlatformAPI = 1 << 28 /* uses the cross-platform API rather than Mac API */ /* remaining flags are reserved for future use and should be zero-initialized */ }; /* panel scopes, as used in member panelscope of PanelFlags struct */ /* */ /* The scope of a panel tells the IDE which settings window to display the panel. */ /* Currently, only panels for debugger plug-ins use panelScopeGlobal and only */ /* panels for VCS plug-ins use panelScopeProject. A panel for a compiler or linker */ /* must use panelScopeTarget. */ enum { panelScopeGlobal, /* this panel is scoped to the global preferences window */ panelScopeProject, /* this panel is scoped to the VCS settings window */ panelScopeTarget, /* this panel is scoped to the target settings window */ panelScopeRConn /* this panel is scoped to configure remote debugging connections */ }; /* pre-defined panel families, used in panelfamily field of PanelFlags struct */ enum { panelFamilyProject = CWFOURCHAR('p', 'r', 'o', 'j'), panelFamilyFrontEnd = CWFOURCHAR('f', 'e', 'n', 'd'), panelFamilyBackEnd = CWFOURCHAR('b', 'e', 'n', 'd'), panelFamilyBrowser = CWFOURCHAR('b', 'r', 'o', 'w'), panelFamilyEditor = CWFOURCHAR('e', 'd', 'i', 't'), panelFamilyDebugger = CWFOURCHAR('d', 'b', 'u', 'g'), panelFamilyLinker = CWFOURCHAR('l', 'i', 'n', 'k'), panelFamilyMisc = CWFOURCHAR('*', '*', '*', '*') }; typedef struct MWSetting* CWSettingID; #define kNoSettingID 0 /* alias types */ #if CW_STRICT_DIALOGS typedef struct DummyDialog* CWDialog; #else typedef DialogPtr CWDialog; #endif /* forward declarations */ typedef struct CWPanelCallbacks CWPanelCallbacks; /* parameter block -- this is passed to the dropin at each request */ typedef struct PanelParameterBlock { /* common to all dropins */ long request; /* [->] requested action (see below) */ long version; /* [->] version # of shell's API */ void *context; /* [->] reserved for use by shell */ void *storage; /* [<->] reserved for use by the dropin */ FSSpec targetfile; /* [->] FSSpec of current project */ /* specific to panels */ CWDialog dialog; /* [->] pointer to PreferencesÉ dialog */ Handle originalPrefs; /* [->] panel's original options data */ Handle currentPrefs; /* [<->] panel's current options data */ Handle factoryPrefs; /* [<->] panel's "factory" options data */ EventRecord *event; /* [->] dialog event (for reqFilterEvent) */ short baseItems; /* [->] # of items in dialog shell */ short itemHit; /* [<->] for reqFilterEvent and reqItemHit */ Boolean canRevert; /* [<-] enable Revert button */ Boolean canFactory; /* [<-] enable Factory button */ Boolean reset; /* [<-] access paths must be reset */ Boolean recompile; /* [<-] files must be recompiled */ Boolean relink; /* [<-] project must be relinked */ AEKeyword prefsKeyword; /* [->] for reqAEGetPref and reqAESetPref */ AEDesc prefsDesc; /* [->] for reqAESetPref */ Boolean debugOn; /* [->] turning on debugging? */ FSSpec oldtargfile; /* [->] previous project file FSSpec */ /* version 2 API */ CWPanelCallbacks* callbacks; /* version 3 API */ Boolean reparse; /* [<-] project must be reparsed */ /* version 4 API */ DragReference dragref; /* [->] for drag-related requests */ Rect dragrect; /* [<-] rect to track mouse in */ Point dragmouse; /* [->] mouse location during drag */ /* version 5 API */ unsigned char toEndian; /* [->] for reqByteSwapData, the endian we are swapping to */ /* CWPro 3 temporary placeholders for opaque references to prefs data. These will be removed in Pro 4. */ CWMemHandle originalPrefsMemHandle; CWMemHandle currentPrefsMemHandle; CWMemHandle factoryPrefsMemHandle; CWMemHandle panelPrefsMemHandle; /* version 11 api */ long listViewCellRow; /* [->] the cell row of the listView */ long listViewCellCol; /* [->] the cell row of the listView */ } PanelParameterBlock, *PanelParameterBlockPtr; typedef PanelParameterBlock PanelParamBlk; typedef PanelParameterBlockPtr PanelParamBlkPtr; /* callbacks to the IDE */ extern F_PASCAL(OSErr) CWPanlAppendItems(PanelParamBlkPtr ppb, short ditlID); extern F_PASCAL(OSErr) CWPanlDrawPanelBox(PanelParamBlkPtr ppb, long whichItem, ConstStr255Param title); extern F_PASCAL(OSErr) CWPanlShowItem(PanelParamBlkPtr ppb, long whichItem, Boolean showIt); extern F_PASCAL(OSErr) CWPanlEnableItem(PanelParamBlkPtr ppb, long whichItem, Boolean enableIt); extern F_PASCAL(OSErr) CWPanlActivateItem(PanelParamBlkPtr ppb, long whichItem); extern F_PASCAL(OSErr) CWPanlGetItemValue(PanelParamBlkPtr ppb, long whichItem, long* value); extern F_PASCAL(OSErr) CWPanlSetItemValue(PanelParamBlkPtr ppb, long whichItem, long value); extern F_PASCAL(OSErr) CWPanlGetItemText(PanelParamBlkPtr ppb, long whichItem, StringPtr str, short maxLen); extern F_PASCAL(OSErr) CWPanlSetItemText(PanelParamBlkPtr ppb, long whichItem, ConstStr255Param str); extern F_PASCAL(OSErr) CWPanlGetPanelPrefs(PanelParamBlkPtr ppb, StringPtr inPanelName, Handle *prefs, Boolean* requiresByteSwap); extern F_PASCAL(OSErr) CWPanlGetItemRect(PanelParamBlkPtr ppb, long whichItem, Rect* rect); extern F_PASCAL(OSErr) CWPanlGetItemControl(PanelParamBlkPtr ppb, long whichItem, ControlRef* control); extern F_PASCAL(OSErr) CWPanlInvalItem(PanelParamBlkPtr ppb, long whichItem); extern F_PASCAL(OSErr) CWPanlValidItem(PanelParamBlkPtr ppb, long whichItem); extern F_PASCAL(OSErr) CWPanlGetMacPort(PanelParamBlkPtr ppb, GrafPtr* port); extern F_PASCAL(OSErr) CWPanlGetItemTextHandle(PanelParamBlkPtr ppb, long whichItem, Handle *text); extern F_PASCAL(OSErr) CWPanlSetItemTextHandle(PanelParamBlkPtr ppb, long whichItem, Handle text); extern F_PASCAL(OSErr) CWPanlGetItemData(PanelParamBlkPtr ppb, long whichItem, void *outData, long *outDataLength); extern F_PASCAL(OSErr) CWPanlSetItemData(PanelParamBlkPtr ppb, long whichItem, void *inData, long inDataLength); extern F_PASCAL(OSErr) CWPanlGetItemMaxLength(PanelParamBlkPtr ppb, long whichItem, short *outLength); extern F_PASCAL(OSErr) CWPanlSetItemMaxLength(PanelParamBlkPtr ppb, long whichItem, short inLength); extern F_PASCAL(OSErr) CWPanlChooseRelativePath(PanelParamBlkPtr ppb, CWRelativePath* path, Boolean isFolder, short filterCount, void* filterList, char* prompt); extern F_PASCAL(OSErr) CWPanlGetRelativePathString(PanelParamBlkPtr ppb, CWRelativePath* path, char* pathString, long* maxLength); #if macintosh extern F_PASCAL(OSErr) CWPanlReadRelativePathAEDesc(PanelParamBlkPtr ppb, CWRelativePath* path, const AEDesc* desc); extern F_PASCAL(OSErr) CWPanlWriteRelativePathAEDesc(PanelParamBlkPtr ppb, const CWRelativePath* path, AEDesc* desc); #endif /* utility routines */ extern F_PASCAL(OSErr) CWPanlDrawUserItemBox(DialogPtr dialog, short whichItem, ConstStr255Param title); extern F_PASCAL(OSErr) CWPanlInstallUserItem(PanelParamBlkPtr ppb, short whichItem, UserItemProcPtr proc); extern F_PASCAL(OSErr) CWPanlRemoveUserItem(PanelParamBlkPtr ppb, short whichItem); /* reading and writing scalar settings */ extern F_PASCAL(OSErr) CWPanlReadBooleanSetting(PanelParamBlkPtr ppb, const char* name, Boolean* value); extern F_PASCAL(OSErr) CWPanlReadIntegerSetting(PanelParamBlkPtr ppb, const char* name, long* value); extern F_PASCAL(OSErr) CWPanlReadFloatingPointSetting(PanelParamBlkPtr ppb, const char* name, double* value); extern F_PASCAL(OSErr) CWPanlReadStringSetting(PanelParamBlkPtr ppb, const char* name, const char** value); extern F_PASCAL(OSErr) CWPanlReadRelativePathSetting(PanelParamBlkPtr ppb, const char* name, CWRelativePath* value); extern F_PASCAL(OSErr) CWPanlWriteBooleanSetting(PanelParamBlkPtr ppb, const char* name, Boolean value); extern F_PASCAL(OSErr) CWPanlWriteIntegerSetting(PanelParamBlkPtr ppb, const char* name, long value); extern F_PASCAL(OSErr) CWPanlWriteFloatingPointSetting(PanelParamBlkPtr ppb, const char* name, double value); extern F_PASCAL(OSErr) CWPanlWriteStringSetting(PanelParamBlkPtr ppb, const char* name, const char* value); extern F_PASCAL(OSErr) CWPanlWriteRelativePathSetting(PanelParamBlkPtr ppb, const char* name, const CWRelativePath* value); /* reading and writing array and structure settings */ extern F_PASCAL(OSErr) CWPanlGetNamedSetting(PanelParamBlkPtr ppb, const char* name, CWSettingID* settingID); extern F_PASCAL(OSErr) CWPanlGetStructureSettingField(PanelParamBlkPtr ppb, CWSettingID settingID, const char* name, CWSettingID* fieldSettingID); extern F_PASCAL(OSErr) CWPanlGetArraySettingSize(PanelParamBlkPtr ppb, CWSettingID settingID, long* size); extern F_PASCAL(OSErr) CWPanlGetArraySettingElement(PanelParamBlkPtr ppb, CWSettingID settingID, long index, CWSettingID* elementSettingID); extern F_PASCAL(OSErr) CWPanlGetBooleanValue(PanelParamBlkPtr ppb, CWSettingID settingID, Boolean* value); extern F_PASCAL(OSErr) CWPanlGetIntegerValue(PanelParamBlkPtr ppb, CWSettingID settingID, long* value); extern F_PASCAL(OSErr) CWPanlGetFloatingPointValue(PanelParamBlkPtr ppb, CWSettingID settingID, double* value); extern F_PASCAL(OSErr) CWPanlGetStringValue(PanelParamBlkPtr ppb, CWSettingID settingID, const char** value); extern F_PASCAL(OSErr) CWPanlGetRelativePathValue(PanelParamBlkPtr ppb, CWSettingID settingID, CWRelativePath* value); extern F_PASCAL(OSErr) CWPanlSetBooleanValue(PanelParamBlkPtr ppb, CWSettingID settingID, Boolean value); extern F_PASCAL(OSErr) CWPanlSetIntegerValue(PanelParamBlkPtr ppb, CWSettingID settingID, long value); extern F_PASCAL(OSErr) CWPanlSetFloatingPointValue(PanelParamBlkPtr ppb, CWSettingID settingID, double value); extern F_PASCAL(OSErr) CWPanlSetStringValue(PanelParamBlkPtr ppb, CWSettingID settingID, const char* value); extern F_PASCAL(OSErr) CWPanlSetRelativePathValue(PanelParamBlkPtr ppb, CWSettingID settingID, const CWRelativePath* value); #if CW_USE_PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #ifdef __MWERKS__ #pragma options align=reset #endif #ifdef _MSC_VER #pragma pack(pop) #endif #endif /* __DROPINPANEL_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/DropInPanelWin32.h b/sdk_hdrs/DropInPanelWin32.h
new file mode 100755
index 0000000..98d0c8a
--- /dev/null
+++ b/sdk_hdrs/DropInPanelWin32.h
@@ -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 \ No newline at end of file
diff --git a/sdk_hdrs/DropInVCS.h b/sdk_hdrs/DropInVCS.h
new file mode 100755
index 0000000..6124933
--- /dev/null
+++ b/sdk_hdrs/DropInVCS.h
@@ -0,0 +1 @@
+/* DropInVCS.h Copyright (c) 1996-8, Metrowerks Corporation. All rights reserved. This include contains the declarations needed to interface a version control system to the CodeWarrior integrated development environment. */ #ifndef __DROPINVCS_H__ #define __DROPINVCS_H__ #ifdef macintosh #include <OSUtils.h> #include <Files.h> #endif #define VCS_API_VERSION_1 1 // 1.7 IDE through Pro 3 #define VCS_API_VERSION_7 7 // Pro 4 #define VCS_API_VERSION_8 8 // Pro 5 #define VCS_API_VERSION_9 9 // Pro 6 #define VCS_API_CURRENT_VERSION VCS_API_VERSION_9 #ifndef __CWPlugins_H__ #include "CWPlugins.h" #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif #ifdef _MSC_VER #pragma pack(push,2) #endif #ifndef __CWPluginErrors_H__ #include "CWPluginErrors.h" #endif #ifdef MW_USES_PRAGMA_ONCE #pragma once #endif #ifdef __cplusplus extern "C" { #endif #if CW_USE_PRAGMA_IMPORT #pragma import on #endif // The following constants are to be used when specifying the flags through a // flags callback. For version 3 flags. enum { vcsDoesntPrePostSingleFile = 1L << 31, /* this VCS plugin does NOT call Pre/PostFileAction routines for calls dealing with a single file (file must be accessible before call) */ vcsDoesntPrePostRecursive = 1L << 30, /* this VCS plugin does NOT call Pre/PostFileAction routines for files during recursive calls (files must be accessible before call) */ vcsRequiresEvents = 1L << 29, /* this flag specifies that the VCS is responding to either AppleEvents or other highLevelEvents and the IDE should not try to handle events during callbacks */ vcsWantsIdle = 1L << 28, /* this flag is turned on when the VCS plugin wants to receive idle events */ vcsSupportsPrefsChanged = 1L << 27, /* this flag is turned on when the VCS plugin supports the reqPrefsChanged request */ vcsDoesntUseLoginSettings = 1L << 26, /* this VCS plugin does not use the login settings in the VCS Setup panel */ vcsDoesntUseDatabaseSetting = 1L << 25, /* this VCS plugin does not use the database path setting in the VCS Setup panel */ vcsDoesntUseLocalRootSetting = 1L << 24 /* this VCS plugin does not use the local root setting in the VCS Setup panel */ }; enum { reqDatabaseConnect = 1, // connect to database reqDatabaseDisconnect, // disconnect from database reqDatabaseVariables, // database variables list reqFileAdd, // add file reqFileCheckin, // checkin file reqFileCheckout, // checkout file reqFileComment, // set file comment reqFileDelete, // delete file reqFileDestroy, // destroy file reqFileDifference, // difference file reqFileGet, // get file reqFileHistory, // get file history reqFileLabel, // label file reqFileProperties, // get file properties reqFilePurge, // purge file reqFileRename, // rename file reqFileRollback, // rollback file reqFileStatus, // get file status reqFileUndoCheckout, // cancel file checkout reqFileVersion, // get file version reqFileBranch, // branch a shared file reqFileShare, // share a file reqFileView // view a file }; typedef long CWVCSCommand; enum { cwCommandStatusCommandUnknown = -4, // command unknown cwCommandStatusUnknown = -3, // status unknown cwCommandStatusUnsupported = -2, // command unsupported cwCommandStatusSupported = -1, // command supported cwCommandStatusSucceeded = cwNoErr, // successful cwCommandStatusFailed = 1, // failed cwCommandStatusPartial = 2, // partially successful cwCommandStatusCancelled = 3, // user cancelled cwCommandStatusConnectionLost = 4, // connection lost cwCommandStatusInvalidLogin = 5 // invalid username or password }; typedef long CWVCSCommandStatus; enum { cwItemStatusUnprocessed = -2, // item yet unprocessed cwItemStatusUnknown = -1, // status unknown cwItemStatusSucceeded = 0, // operation succeeded cwItemStatusFailed = 1, // operation failed cwItemStatusCancelled = 2 // operation cancelled }; typedef long CWVCSItemStatus; enum { cwCheckoutStateUnknown = 0xFFFFFFFF, // unknown cwCheckoutStateNotInDatabase = 0x00000002, // not in database cwCheckoutStateNotCheckedOut = 0x00000000, // not checked out cwCheckoutStateCheckedOut = 0x00000001, // checked out cwCheckoutStateMultiplyCheckedOut = 0x00000101, // multiply checked out cwCheckoutStateNotCheckedOutShared = 0x00010000, // not checked out and shared cwCheckoutStateCheckedOutShared = 0x00010001, // checked out and shared cwCheckoutStateMultiplyCheckedOutShared = 0x00010101, // multiply checked out and shared cwCheckoutStateNotCheckedOutBranched = 0x00020000, // not checked out and branched cwCheckoutStateCheckedOutBranched = 0x00020001, // checked out and branched cwCheckoutStateMultiplyCheckedOutBranched = 0x00020101, // checked out and branched cwCheckoutStateNotCheckedOutSharedBranched = 0x00030000, // not checked out, shared and branched cwCheckoutStateCheckedOutSharedBranched = 0x00030001, // checked out, shared and branched cwCheckoutStateMultiplyCheckedSharedOutBranched = 0x00030101, // checked out, shared and branched cwCheckoutStateCheckedOutExclusive = 0x00040001, // exclusively checked out cwCheckoutStateCheckedOutExclusiveShared = 0x00050001, // exclusively checked out and shared cwCheckoutStateCheckedOutExclusiveBranched = 0x00060001, // exclusively checked out and branched cwCheckoutStateCheckedOutExclusiveSharedBranched = 0x00070001, // exclusively checked out, shared and branched cwCheckoutStateCheckedOutMask = 0x00000001, // checked out mask cwCheckoutStateMultiplyCheckedOutMask = 0x00000100, // multiply checked out mask cwCheckoutStateSharedMask = 0x00010000, // shared mask cwCheckoutStateBranchedMask = 0x00020000, // branched mask cwCheckoutStateExclusiveMask = 0x00040000 // exclusive mask }; typedef long CWVCSCheckoutState; enum { cwVersionFormNone = 0, // no record cwVersionFormNumeric = 1, // intergral numeric cwVersionFormAlpha = 2, // alphabetic cwVersionFormLabel = 4, // label cwVersionFormDate = 5 // date / time }; typedef long CWVCSVersionForm; enum { cwCommandDescriptionVersion = 1 }; typedef struct CWVCSCommandDescription { long version; char menuItem[40]; char progressMessage[200]; } CWVCSCommandDescription; typedef union CWVCSVersionData { unsigned long numeric; // integral numeric char* pAlpha; // alphabetic CWFileTime date; // date / time char* pLabel; // label } CWVCSVersionData, *p_CWVCSVersionData, **h_CWVCSVersionData; typedef struct CWVCSVersion { CWVCSVersionForm eVersionForm; // version form CWVCSVersionData sVersionData; // version data } CWVCSVersion, *p_CWVCSVersion, **h_CWVCSVersion; typedef struct CWVCSItem { CWFileSpec fsItem; // item file specification CWVCSItemStatus eItemStatus; // item status code CWVCSVersion version; // item version CWVCSCheckoutState eCheckoutState; // item checkout state } CWVCSItem, *p_CWVCSItem, **h_CWVCSItem; typedef struct CWVCSDatabaseConnection { CWFileSpec sDatabasePath; // path to the database directory CWFileSpec sProjectRoot; // path to the local database directory char* pUsername; // user name char* pPassword; // user password } CWVCSDatabaseConnection, *p_CWVCSDatabaseConnection, **h_CWVCSDatabaseConnection; /* The following callback mechanisms are available for VCS plugins for VCS performing VCS specific * functions and retrieving VCS specific data from the context passed to the main entry point by the * IDE. You may also use any of the callbacks for generic plugins. * * These callbacks are available only to plugins using version 2 of the API or greater. */ /* Call this function as the first thing you do in your main entry point. Check its result. If you pass in * true, then if the v2 plugin is running under a pre-Pro4 IDE it will set up the compatibillity libraries and * return cwNoErr. If you pass in false and your v2 plugin is running uner a pre-Pro4 IDE it will return * cwCommandStatusFailed, at which point you should return this error to the IDE and not process the request * sent to you. * * Note that if you allow v1 compatibility and the result of isV1 is true, your plugin will not receive the V2 * idle requests or preferences changed requests and you must work around accordingly. */ CW_CALLBACK CWAllowV1Compatibility(CWPluginContext context, Boolean canHandleV1Mode, Boolean *isV1); /* Get a comment from the user */ CW_CALLBACK CWGetComment(CWPluginContext context, const char* pPrompt, char* pComment, const long lBufferSize); /* Notify IDE if any changes occur to a file's information or checkout state */ CW_CALLBACK CWVCSStateChanged(CWPluginContext context, const CWFileSpec* file, CWVCSCheckoutState eCheckoutState, const CWVCSVersion* version); /* Display a IDE visual difference window for the passed files. The first file passed in * should be an unchangable file and the second file should be the local file. Instead of passing * a CWFileSpec it is possible to pass in a pointer to text (null terminated) and a title. * If the file spec is used, set both the title and text pointers to NULL */ CW_CALLBACK CWDoVisualDifference(CWPluginContext context, const CWFileSpec* file1, const char* pTitle1, const char* pText1, unsigned long lengthText1, const CWFileSpec* file2, const char* pTitle2, const char* pText2, unsigned long lengthText2); /* Tell the IDE the current ratio of how many items are completed. If you are able to correctly * give a completion ratio, the IDE will display a progress bar indicating how far along the * VCS action has progressed instead of displaying a busy indicator. If you pass -1 as the * total number of items, the busy indicator will replace any progress bar that you have * displayed with a prior call to completion ratio during the handling of a single request */ CW_CALLBACK CWCompletionRatio(CWPluginContext context, int totalItems, int completedItems); /* Get the project file specifier */ CW_CALLBACK CWGetProjectFileSpecifier(CWPluginContext context, CWFileSpec* projectFileSpec); /* Is the command passed an advanced command? */ CW_CALLBACK CWIsAdvancedRequest(CWPluginContext context, Boolean* isAdvanced); /* Is the command passed a recursive command? */ CW_CALLBACK CWIsRecursiveRequest(CWPluginContext context, Boolean* isRecursive); /* Is the command passed simply to check if it is supported? */ CW_CALLBACK CWIsCommandSupportedRequest(CWPluginContext context, Boolean* isCommandSupported); /* Set the pointer to a new overriding menu title string */ CW_CALLBACK CWSetCommandDescription(CWPluginContext context, CWVCSCommandDescription* descr); /* Get the pointer to the database connection structure */ CW_CALLBACK CWGetDatabaseConnectionInfo(CWPluginContext context, CWVCSDatabaseConnection* dbConnection); /* Get the command status code */ CW_CALLBACK CWGetCommandStatus(CWPluginContext context, CWVCSCommandStatus* status); /* Set the command status code */ CW_CALLBACK CWSetCommandStatus(CWPluginContext context, CWVCSCommandStatus status); /* Get the number of VCS items passed to the plugin */ CW_CALLBACK CWGetVCSItemCount(CWPluginContext context, unsigned long* count); /* Get a pointer to the ith entry of the item array, 0 indexed */ CW_CALLBACK CWGetVCSItem(CWPluginContext context, long index, CWVCSItem* item); /* Change the data for a VCS Item in the item array */ CW_CALLBACK CWSetVCSItem(CWPluginContext context, long index, CWVCSItem* item); /* Get what's stored in the VCS pointer storage area */ CW_CALLBACK CWGetVCSPointerStorage(CWPluginContext context, void** storage); /* Store a pointer that will be maintained across calls to the main entry point */ CW_CALLBACK CWSetVCSPointerStorage(CWPluginContext context, void* storage); #if CW_USE_PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #ifdef _MSC_VER #pragma pack(pop,2) #endif #ifdef __MWERKS__ #pragma options align=reset #endif #endif /* __DROPINVCS_H__ */ \ No newline at end of file
diff --git a/sdk_hdrs/MWBrowse.h b/sdk_hdrs/MWBrowse.h
new file mode 100755
index 0000000..310a5d0
--- /dev/null
+++ b/sdk_hdrs/MWBrowse.h
@@ -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__ \ No newline at end of file
diff --git a/sdk_hdrs/MWLangDefs.h b/sdk_hdrs/MWLangDefs.h
new file mode 100755
index 0000000..6a6a650
--- /dev/null
+++ b/sdk_hdrs/MWLangDefs.h
@@ -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 \ No newline at end of file
diff --git a/setup.sh b/setup.sh
new file mode 100644
index 0000000..83038c4
--- /dev/null
+++ b/setup.sh
@@ -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
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 20:16:22 +0000