first very unfinished commit lol

1 files changed, 319 insertions, 0 deletions

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) {
+
+}