move lots of source files around to match their actual placement in the original treemain

1 files changed, 676 insertions, 0 deletions

diff --git a/compiler_and_linker/FrontEnd/C/CPreprocess.c b/compiler_and_linker/FrontEnd/C/CPreprocess.c
new file mode 100644
index 0000000..4e6b3c0
--- /dev/null
+++ b/compiler_and_linker/FrontEnd/C/CPreprocess.c
@@ -0,0 +1,676 @@
+#include "compiler/CPreprocess.h"
+#include "compiler/CError.h"
+#include "compiler/CMachine.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CompilerTools.h"
+#include "cos.h"
+
+void CPrep_PreprocessDumpNewLine(void) {
+    if (copts.line_prepdump && pplist.data && filesp >= 0)
+        AppendGListData(&pplist, "\r", 1);
+}
+
+void CPrep_PreprocessDumpFileInfo(Boolean flag) {
+    char linebuf[512];
+    int size;
+    SInt16 tmp16;
+    SInt32 tmp32;
+    Str255 filename;
+
+    if (pplist.data && filesp >= 0) {
+        if (nlflag && flag && pplist.size > 0)
+            AppendGListName(&pplist, "\r");
+
+        if (copts.line_prepdump)
+            size = sprintf(linebuf, "#line % " PRId32 "\t\"", linenumber);
+        else
+            size = sprintf(linebuf, "/* #line % " PRId32 "\t\"", linenumber);
+        AppendGListData(&pplist, linebuf, size);
+
+        if (copts.fullpath_prepdump) {
+            if (prep_file->nameNode) {
+                AppendGListData(&pplist, prep_file->nameNode->name, strlen(prep_file->nameNode->name));
+            } else {
+                COS_FileGetPathName(linebuf, &prep_file->textfile, &tmp32);
+                AppendGListData(&pplist, linebuf, strlen(linebuf));
+            }
+        } else {
+            if (prep_file->nameNode) {
+                char *work = prep_file->nameNode->name + strlen(prep_file->nameNode->name);
+                while (work > prep_file->nameNode->name && !strchr("/\\:", work[-1]))
+                    work--;
+
+                AppendGListData(&pplist, work, strlen(work));
+            } else {
+                COS_FileGetFSSpecInfo(&prep_file->textfile, &tmp16, &tmp32, filename);
+                AppendGListData(&pplist, &filename[1], filename[0]);
+            }
+        }
+
+        size = sprintf(linebuf, "\"\t/* stack depth % " PRId32 " */", filesp);
+        AppendGListData(&pplist, linebuf, size);
+
+        if (copts.line_prepdump && flag)
+            CPrep_PreprocessDumpNewLine();
+
+        nlflag = 1;
+    }
+}
+
+static void CPrep_DumpWString(UInt16 *str, short len) {
+    int divisor;
+    int i;
+
+    while (len--) {
+        if (*str < 32) {
+            AppendGListByte(&pplist, '\\');
+            switch (*str) {
+                case 7:
+                    AppendGListByte(&pplist, 'a');
+                    break;
+                case 8:
+                    AppendGListByte(&pplist, 'b');
+                    break;
+                case 27:
+                    AppendGListByte(&pplist, 'e');
+                    break;
+                case 12:
+                    AppendGListByte(&pplist, 'f');
+                    break;
+                case 10:
+                    AppendGListByte(&pplist, 'n');
+                    break;
+                case 13:
+                    AppendGListByte(&pplist, 'r');
+                    break;
+                case 9:
+                    AppendGListByte(&pplist, 't');
+                    break;
+                case 11:
+                    AppendGListByte(&pplist, 'v');
+                    break;
+                default:
+                    if (*str >= 8)
+                        AppendGListByte(&pplist, '0' + (*str / 8));
+                    AppendGListByte(&pplist, '0' + (*str % 8));
+            }
+        } else if (*str > 255) {
+            AppendGListByte(&pplist, '\\');
+            AppendGListByte(&pplist, 'x');
+
+            divisor = 0x1000;
+            for (i = 0; i < 4; i++) {
+                AppendGListByte(&pplist, "0123456789ABCDEF"[(*str / divisor) % 16]);
+                divisor /= 16;
+            }
+        } else {
+            switch (*str) {
+                case '"':
+                case '\\':
+                    AppendGListByte(&pplist, '\\');
+                default:
+                    AppendGListByte(&pplist, *str);
+            }
+        }
+        str++;
+    }
+}
+
+static void CPrep_DumpString(UInt8 *str, short len) {
+    while (len--) {
+        if (*str < 32) {
+            AppendGListByte(&pplist, '\\');
+            switch (*str) {
+                case 7:
+                    AppendGListByte(&pplist, 'a');
+                    break;
+                case 8:
+                    AppendGListByte(&pplist, 'b');
+                    break;
+                case 12:
+                    AppendGListByte(&pplist, 'f');
+                    break;
+                case 10:
+                    AppendGListByte(&pplist, 'n');
+                    break;
+                case 13:
+                    AppendGListByte(&pplist, 'r');
+                    break;
+                case 9:
+                    AppendGListByte(&pplist, 't');
+                    break;
+                case 11:
+                    AppendGListByte(&pplist, 'v');
+                    break;
+                default:
+                    if (*str >= 8)
+                        AppendGListByte(&pplist, '0' + (*str / 8));
+                    AppendGListByte(&pplist, '0' + (*str % 8));
+            }
+        } else {
+            switch (*str) {
+                case '"':
+                case '\\':
+                    AppendGListByte(&pplist, '\\');
+                default:
+                    AppendGListByte(&pplist, *str);
+            }
+        }
+        str++;
+    }
+}
+
+void CPrep_Preprocess(void) {
+    short innertoken;
+    short token;
+    char startToken;
+    char endToken;
+    int depth;
+    Boolean save_asmpoundcomment; // r16
+    Boolean save_cplusplus; // r15
+    char *p;
+
+    startToken = 0;
+    depth = 0;
+
+    if (InitGList(&pplist, 10000))
+        CError_NoMem();
+
+    nlflag = 0;
+    spaceskip = 0;
+
+    if ((token = lex())) {
+        do {
+            if (nlflag) {
+                if (!copts.line_prepdump)
+                    AppendGListData(&pplist, "\r", 1);
+            } else {
+                if (spaceskip)
+                    AppendGListByte(&pplist, ' ');
+            }
+
+            while (1) {
+                switch ((innertoken = token)) {
+                    case '(':
+                    case ')':
+                    case '{':
+                    case '}':
+                        AppendGListByte(&pplist, token);
+                        if (cprep_nostring) {
+                            if (innertoken == startToken) {
+                                depth++;
+                            } else if (innertoken == endToken) {
+                                if (--depth == 0) {
+                                    cprep_nostring = 0;
+                                    in_assembler = 0;
+                                    copts.cplusplus = save_cplusplus;
+                                    copts.asmpoundcomment = save_asmpoundcomment;
+                                }
+                            }
+                        }
+                        break;
+
+                    case TK_INTCONST:
+                    case TK_FLOATCONST:
+                        if (tokenstacklevel > 0)
+                            p = macropos;
+                        else
+                            p = prep_file_start + ts_current[-1].tokenoffset;
+                        AppendGListData(&pplist, p, pos - p);
+                        break;
+
+                    case TK_IDENTIFIER:
+                        AppendGListData(&pplist, tkidentifier->name, strlen(tkidentifier->name));
+                        break;
+
+                    case TK_AUTO:
+                        AppendGListData(&pplist, "auto", 4);
+                        break;
+                    case TK_REGISTER:
+                        AppendGListData(&pplist, "register", 8);
+                        break;
+                    case TK_STATIC:
+                        AppendGListData(&pplist, "static", 6);
+                        break;
+                    case TK_EXTERN:
+                        AppendGListData(&pplist, "extern", 6);
+                        break;
+                    case TK_TYPEDEF:
+                        AppendGListData(&pplist, "typedef", 7);
+                        break;
+                    case TK_INLINE:
+                        AppendGListData(&pplist, "inline", 6);
+                        break;
+                    case TK_VOID:
+                        AppendGListData(&pplist, "void", 4);
+                        break;
+                    case TK_CHAR:
+                        AppendGListData(&pplist, "char", 4);
+                        break;
+                    case TK_SHORT:
+                        AppendGListData(&pplist, "short", 5);
+                        break;
+                    case TK_INT:
+                        AppendGListData(&pplist, "int", 3);
+                        break;
+                    case TK_LONG:
+                        AppendGListData(&pplist, "long", 4);
+                        break;
+                    case TK_FLOAT:
+                        AppendGListData(&pplist, "float", 5);
+                        break;
+                    case TK_DOUBLE:
+                        AppendGListData(&pplist, "double", 6);
+                        break;
+                    case TK_SIGNED:
+                        AppendGListData(&pplist, "signed", 6);
+                        break;
+                    case TK_UNSIGNED:
+                        AppendGListData(&pplist, "unsigned", 8);
+                        break;
+                    case TK_STRUCT:
+                        AppendGListData(&pplist, "struct", 6);
+                        break;
+                    case TK_UNION:
+                        AppendGListData(&pplist, "union", 5);
+                        break;
+                    case TK_ENUM:
+                        AppendGListData(&pplist, "enum", 4);
+                        break;
+                    case TK_CLASS:
+                        AppendGListData(&pplist, "class", 5);
+                        break;
+                    case TK_CONST:
+                        AppendGListData(&pplist, "const", 5);
+                        break;
+                    case TK_VOLATILE:
+                        AppendGListData(&pplist, "volatile", 8);
+                        break;
+                    case TK_PASCAL:
+                        AppendGListData(&pplist, "pascal", 6);
+                        break;
+                    case TK_UU_FAR:
+                        AppendGListData(&pplist, "__far", 5);
+                        break;
+                    case TK_ONEWAY:
+                        AppendGListData(&pplist, "oneway", 6);
+                        break;
+                    case TK_IN:
+                        AppendGListData(&pplist, "in", 2);
+                        break;
+                    case TK_OUT:
+                        AppendGListData(&pplist, "out", 3);
+                        break;
+                    case TK_INOUT:
+                        AppendGListData(&pplist, "inout", 5);
+                        break;
+                    case TK_BYCOPY:
+                        AppendGListData(&pplist, "bycopy", 6);
+                        break;
+                    case TK_BYREF:
+                        AppendGListData(&pplist, "byref", 5);
+                        break;
+                    case TK_ASM:
+                        AppendGListData(&pplist, "asm", 3);
+                        endToken = 0;
+                        startToken = 0;
+                        AppendGListByte(&pplist, ' ');
+                        token = lex();
+                        if (token == TK_VOLATILE || (token == TK_IDENTIFIER && !strcmp(tkidentifier->name, "__volatile__"))) {
+                            AppendGListData(&pplist, "volatile", 8);
+                            token = lex();
+                        }
+                        if (token) {
+                            if (token < ' ' || token > 255)
+                                continue;
+                            AppendGListByte(&pplist, token);
+
+                            if (token == '(') {
+                                startToken = '(';
+                                endToken = ')';
+                            } else if (token == '{') {
+                                startToken = '{';
+                                endToken = '}';
+                            } else {
+                                continue;
+                            }
+
+                            cprep_nostring = 1;
+                            in_assembler = 1;
+                            depth = 1;
+                            save_asmpoundcomment = copts.asmpoundcomment;
+                            save_cplusplus = copts.cplusplus;
+
+                            token = lex();
+                            if (token == '"') {
+                                AppendGListByte(&pplist, token);
+                                copts.cplusplus = 0;
+                                copts.asmpoundcomment = 1;
+                                break;
+                            } else if (token == 0) {
+                                break;
+                            }
+                            continue;
+                        }
+                        break;
+
+                    case TK_CASE:
+                        AppendGListData(&pplist, "case", 4);
+                        break;
+                    case TK_DEFAULT:
+                        AppendGListData(&pplist, "default", 7);
+                        break;
+                    case TK_IF:
+                        AppendGListData(&pplist, "if", 2);
+                        break;
+                    case TK_ELSE:
+                        AppendGListData(&pplist, "else", 4);
+                        break;
+                    case TK_SWITCH:
+                        AppendGListData(&pplist, "switch", 6);
+                        break;
+                    case TK_WHILE:
+                        AppendGListData(&pplist, "while", 5);
+                        break;
+                    case TK_DO:
+                        AppendGListData(&pplist, "do", 2);
+                        break;
+                    case TK_FOR:
+                        AppendGListData(&pplist, "for", 3);
+                        break;
+                    case TK_GOTO:
+                        AppendGListData(&pplist, "goto", 4);
+                        break;
+                    case TK_CONTINUE:
+                        AppendGListData(&pplist, "continue", 8);
+                        break;
+                    case TK_BREAK:
+                        AppendGListData(&pplist, "break", 5);
+                        break;
+                    case TK_RETURN:
+                        AppendGListData(&pplist, "return", 6);
+                        break;
+                    case TK_SIZEOF:
+                        AppendGListData(&pplist, "sizeof", 6);
+                        break;
+                    case TK_CATCH:
+                        AppendGListData(&pplist, "catch", 5);
+                        break;
+                    case TK_DELETE:
+                        AppendGListData(&pplist, "delete", 6);
+                        break;
+                    case TK_FRIEND:
+                        AppendGListData(&pplist, "friend", 6);
+                        break;
+                    case TK_NEW:
+                        AppendGListData(&pplist, "new", 3);
+                        break;
+                    case TK_OPERATOR:
+                        AppendGListData(&pplist, "operator", 8);
+                        break;
+                    case TK_PRIVATE:
+                        AppendGListData(&pplist, "private", 7);
+                        break;
+                    case TK_PROTECTED:
+                        AppendGListData(&pplist, "protected", 9);
+                        break;
+                    case TK_PUBLIC:
+                        AppendGListData(&pplist, "public", 6);
+                        break;
+                    case TK_TEMPLATE:
+                        AppendGListData(&pplist, "template", 8);
+                        break;
+                    case TK_THIS:
+                        AppendGListData(&pplist, "this", 4);
+                        break;
+                    case TK_THROW:
+                        AppendGListData(&pplist, "throw", 5);
+                        break;
+                    case TK_TRY:
+                        AppendGListData(&pplist, "try", 3);
+                        break;
+                    case TK_VIRTUAL:
+                        AppendGListData(&pplist, "virtual", 7);
+                        break;
+                    case TK_INHERITED:
+                        AppendGListData(&pplist, "inherited", 9);
+                        break;
+                    case TK_CONST_CAST:
+                        AppendGListData(&pplist, "const_cast", 10);
+                        break;
+                    case TK_DYNAMIC_CAST:
+                        AppendGListData(&pplist, "dynamic_cast", 12);
+                        break;
+                    case TK_EXPLICIT:
+                        AppendGListData(&pplist, "explicit", 8);
+                        break;
+                    case TK_MUTABLE:
+                        AppendGListData(&pplist, "mutable", 7);
+                        break;
+                    case TK_NAMESPACE:
+                        AppendGListData(&pplist, "namespace", 9);
+                        break;
+                    case TK_REINTERPRET_CAST:
+                        AppendGListData(&pplist, "reinterpret_cast", 16);
+                        break;
+                    case TK_STATIC_CAST:
+                        AppendGListData(&pplist, "static_cast", 11);
+                        break;
+                    case TK_USING:
+                        AppendGListData(&pplist, "using", 5);
+                        break;
+                    case TK_WCHAR_T:
+                        AppendGListData(&pplist, "wchar_t", 7);
+                        break;
+                    case TK_TYPENAME:
+                        AppendGListData(&pplist, "typename", 8);
+                        break;
+                    case TK_TRUE:
+                        AppendGListData(&pplist, "true", 4);
+                        break;
+                    case TK_FALSE:
+                        AppendGListData(&pplist, "false", 5);
+                        break;
+                    case TK_TYPEID:
+                        AppendGListData(&pplist, "typeid", 6);
+                        break;
+                    case TK_EXPORT:
+                        AppendGListData(&pplist, "export", 6);
+                        break;
+                    case TK_UU_STDCALL:
+                        AppendGListData(&pplist, "__stdcall", 9);
+                        break;
+                    case TK_UU_CDECL:
+                        AppendGListData(&pplist, "__cdecl", 7);
+                        break;
+                    case TK_UU_FASTCALL:
+                        AppendGListData(&pplist, "__fastcall", 10);
+                        break;
+                    case TK_UU_DECLSPEC:
+                        AppendGListData(&pplist, "__declspec", 10);
+                        break;
+                    case TK_MULT_ASSIGN:
+                        AppendGListData(&pplist, "*=", 2);
+                        break;
+                    case TK_DIV_ASSIGN:
+                        AppendGListData(&pplist, "/=", 2);
+                        break;
+                    case TK_MOD_ASSIGN:
+                        AppendGListData(&pplist, "%=", 2);
+                        break;
+                    case TK_ADD_ASSIGN:
+                        AppendGListData(&pplist, "+=", 2);
+                        break;
+                    case TK_SUB_ASSIGN:
+                        AppendGListData(&pplist, "-=", 2);
+                        break;
+                    case TK_SHL_ASSIGN:
+                        AppendGListData(&pplist, "<<=", 3);
+                        break;
+                    case TK_SHR_ASSIGN:
+                        AppendGListData(&pplist, ">>=", 3);
+                        break;
+                    case TK_AND_ASSIGN:
+                        AppendGListData(&pplist, "&=", 2);
+                        break;
+                    case TK_XOR_ASSIGN:
+                        AppendGListData(&pplist, "^=", 2);
+                        break;
+                    case TK_OR_ASSIGN:
+                        AppendGListData(&pplist, "|=", 2);
+                        break;
+                    case TK_LOGICAL_OR:
+                        AppendGListData(&pplist, "||", 2);
+                        break;
+                    case TK_LOGICAL_AND:
+                        AppendGListData(&pplist, "&&", 2);
+                        break;
+                    case TK_LOGICAL_EQ:
+                        AppendGListData(&pplist, "==", 2);
+                        break;
+                    case TK_LOGICAL_NE:
+                        AppendGListData(&pplist, "!=", 2);
+                        break;
+                    case TK_LESS_EQUAL:
+                        AppendGListData(&pplist, "<=", 2);
+                        break;
+                    case TK_GREATER_EQUAL:
+                        AppendGListData(&pplist, ">=", 2);
+                        break;
+                    case TK_SHL:
+                        AppendGListData(&pplist, "<<", 2);
+                        break;
+                    case TK_SHR:
+                        AppendGListData(&pplist, ">>", 2);
+                        break;
+                    case TK_INCREMENT:
+                        AppendGListData(&pplist, "++", 2);
+                        break;
+                    case TK_DECREMENT:
+                        AppendGListData(&pplist, "--", 2);
+                        break;
+                    case TK_ARROW:
+                        AppendGListData(&pplist, "->", 2);
+                        break;
+                    case TK_ELLIPSIS:
+                        AppendGListData(&pplist, "...", 3);
+                        break;
+                    case TK_DOT_STAR:
+                        AppendGListData(&pplist, ".*", 2);
+                        break;
+                    case TK_ARROW_STAR:
+                        AppendGListData(&pplist, "->*", 3);
+                        break;
+                    case TK_COLON_COLON:
+                        AppendGListData(&pplist, "::", 2);
+                        break;
+                    case TK_AT_INTERFACE:
+                        AppendGListData(&pplist, "@interface", 10);
+                        break;
+                    case TK_AT_IMPLEMENTATION:
+                        AppendGListData(&pplist, "@implementation", 15);
+                        break;
+                    case TK_AT_PROTOCOL:
+                        AppendGListData(&pplist, "@protocol", 9);
+                        break;
+                    case TK_AT_END:
+                        AppendGListData(&pplist, "@end", 4);
+                        break;
+                    case TK_AT_PRIVATE:
+                        AppendGListData(&pplist, "@private", 8);
+                        break;
+                    case TK_AT_PROTECTED:
+                        AppendGListData(&pplist, "@protected", 10);
+                        break;
+                    case TK_AT_PUBLIC:
+                        AppendGListData(&pplist, "@public", 7);
+                        break;
+                    case TK_AT_CLASS:
+                        AppendGListData(&pplist, "@class", 6);
+                        break;
+                    case TK_AT_SELECTOR:
+                        AppendGListData(&pplist, "@selector", 9);
+                        break;
+                    case TK_AT_ENCODE:
+                        AppendGListData(&pplist, "@encode", 7);
+                        break;
+                    case TK_AT_DEFS:
+                        AppendGListData(&pplist, "@defs", 5);
+                        break;
+                    case TK_SELF:
+                        AppendGListData(&pplist, "self", 4);
+                        break;
+                    case TK_SUPER:
+                        AppendGListData(&pplist, "super", 5);
+                        break;
+                    case TK_BOOL:
+                        if (!copts.cplusplus && copts.c9x)
+                            AppendGListData(&pplist, "_Bool", 5);
+                        else
+                            AppendGListData(&pplist, "bool", 4);
+                        break;
+                    case TK_RESTRICT:
+                        if (copts.c9x)
+                            AppendGListData(&pplist, "restrict", 8);
+                        else
+                            AppendGListData(&pplist, "__restrict", 10);
+                        break;
+                    case TK_UU_VECTOR:
+                        AppendGListData(&pplist, "__vector", 8);
+                        break;
+                    case TK_UU_TYPEOF_UU:
+                        AppendGListData(&pplist, "__typeof__", 10);
+                        break;
+                    case TK_UU_ATTRIBUTE_UU:
+                        AppendGListData(&pplist, "__attribute__", 13);
+                        break;
+                    case TK_UU_ALIGNOF_UU:
+                        AppendGListData(&pplist, "__alignof__", 11);
+                        break;
+                    case TK_UU_UUIDOF:
+                        AppendGListData(&pplist, "__uuidof", 8);
+                        break;
+                    case TK_U_COMPLEX:
+                        AppendGListData(&pplist, "_Complex", 8);
+                        break;
+                    case TK_U_IMAGINARY:
+                        AppendGListData(&pplist, "_Imaginary", 10);
+                        break;
+
+                    case TK_STRING:
+                        if (ispascalstring) {
+                            AppendGListData(&pplist, "\"\\p", 3);
+                            CPrep_DumpString((UInt8 *) tkstring + 1, tksize - 1);
+                        } else {
+                            AppendGListByte(&pplist, '"');
+                            CPrep_DumpString((UInt8 *) tkstring, tksize - 1);
+                        }
+                        AppendGListByte(&pplist, '"');
+                        break;
+
+                    case TK_STRING_WIDE:
+                        AppendGListData(&pplist, "L\"", 2);
+                        CPrep_DumpWString((UInt16 *) tkstring, (tksize / stwchar.size) - 1);
+                        AppendGListByte(&pplist, '"');
+                        break;
+
+                    default:
+                        if (token >= 32 && token <= 255)
+                            AppendGListByte(&pplist, token);
+                        else
+                            CError_FATAL(563);
+                }
+                break;
+            }
+
+            CPrep_TokenStreamFlush();
+            nlflag = 0;
+            spaceskip = 0;
+        } while ((token = lex()));
+    }
+
+    AppendGListByte(&pplist, 0);
+    COS_ResizeHandle(pplist.data, pplist.size);
+}