commit 97f6a2438df1eaeb4128ce36f29346ea38a3db4a Author: Ash Wolf Date: Fri Oct 7 20:02:27 2022 +0100 first very unfinished commit lol 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