From 97f6a2438df1eaeb4128ce36f29346ea38a3db4a Mon Sep 17 00:00:00 2001 From: Ash Wolf Date: Fri, 7 Oct 2022 20:02:27 +0100 Subject: [PATCH] first very unfinished commit lol --- Arguments.c | 604 ++++++++++ CError.c | 319 +++++ CInt64.c | 893 ++++++++++++++ CInt64.h | 85 ++ CompilerTools.c | 1230 ++++++++++++++++++++ CompilerTools.h | 134 +++ Help.c | 564 +++++++++ Option.c | 630 ++++++++++ PCode.c | 286 +++++ PCode.h | 110 ++ PCodeInfo.c | 55 + PCodeInfo.h | 462 ++++++++ ParserFace.c | 226 ++++ UCLTMain.c | 384 +++++++ UMain.c | 110 ++ mwcc_decomp.h | 1918 +++++++++++++++++++++++++++++++ sdk_hdrs/CWDropInPanel.h | 1 + sdk_hdrs/CWPluginErrors.h | 1 + sdk_hdrs/CWPlugins.h | 1 + sdk_hdrs/CWRuntimeFeatures.h | 1 + sdk_hdrs/CWUnixPluginPrefix.h | 1 + sdk_hdrs/CWWinPluginPrefix.h | 1 + sdk_hdrs/CatTypes.h | 1 + sdk_hdrs/CompilerMapping.h | 1 + sdk_hdrs/DropInCompilerLinker.h | 1 + sdk_hdrs/DropInPanel.h | 1 + sdk_hdrs/DropInPanelWin32.h | 1 + sdk_hdrs/DropInVCS.h | 1 + sdk_hdrs/MWBrowse.h | 1 + sdk_hdrs/MWLangDefs.h | 1 + setup.sh | 3 + 31 files changed, 8027 insertions(+) create mode 100644 Arguments.c create mode 100644 CError.c create mode 100644 CInt64.c create mode 100644 CInt64.h create mode 100644 CompilerTools.c create mode 100644 CompilerTools.h create mode 100644 Help.c create mode 100644 Option.c create mode 100644 PCode.c create mode 100644 PCode.h create mode 100644 PCodeInfo.c create mode 100644 PCodeInfo.h create mode 100644 ParserFace.c create mode 100644 UCLTMain.c create mode 100644 UMain.c create mode 100644 mwcc_decomp.h create mode 100755 sdk_hdrs/CWDropInPanel.h create mode 100755 sdk_hdrs/CWPluginErrors.h create mode 100755 sdk_hdrs/CWPlugins.h create mode 100755 sdk_hdrs/CWRuntimeFeatures.h create mode 100755 sdk_hdrs/CWUnixPluginPrefix.h create mode 100755 sdk_hdrs/CWWinPluginPrefix.h create mode 100755 sdk_hdrs/CatTypes.h create mode 100755 sdk_hdrs/CompilerMapping.h create mode 100755 sdk_hdrs/DropInCompilerLinker.h create mode 100755 sdk_hdrs/DropInPanel.h create mode 100755 sdk_hdrs/DropInPanelWin32.h create mode 100755 sdk_hdrs/DropInVCS.h create mode 100755 sdk_hdrs/MWBrowse.h create mode 100755 sdk_hdrs/MWLangDefs.h create mode 100644 setup.sh 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 : ""); + + 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" : + ""; +} + +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 +#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 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 +#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 #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 #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 #endif #ifndef __CONTROLS__ # include #endif #ifndef __DIALOGS__ # include #endif #ifndef __DRAG__ # include #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 #include #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