a bunch of compiler stuff

12 files changed, 2239 insertions, 0 deletions

diff --git a/includes/compiler/CError.h b/includes/compiler/CError.h
new file mode 100644
index 0000000..89f67e4
--- /dev/null
+++ b/includes/compiler/CError.h
@@ -0,0 +1,364 @@
+#ifndef COMPILER_CERROR_H
+#define COMPILER_CERROR_H
+
+#include "compiler/common.h"
+
+#define CError_ASSERT(cond) if (!(cond)) { CError_Internal(__FILE__, __LINE__); }
+#define CError_FAIL(cond) if (cond) { CError_Internal(__FILE__, __LINE__); }
+#define CError_FATAL() do { CError_Internal(__FILE__, __LINE__); } while (0)
+
+enum {
+    CErrorStr100 = 100,
+    CErrorStr101 = 101,
+    CErrorStr102 = 102,
+    CErrorStr103 = 103,
+    CErrorStr104 = 104,
+    CErrorStr105 = 105,
+    CErrorStr106 = 106,
+    CErrorStr107 = 107,
+    CErrorStr108 = 108,
+    CErrorStr109 = 109,
+    CErrorStr110 = 110,
+    CErrorStr111 = 111,
+    CErrorStr112 = 112,
+    CErrorStr113 = 113,
+    CErrorStr114 = 114,
+    CErrorStr115 = 115,
+    CErrorStr116 = 116,
+    CErrorStr117 = 117,
+    CErrorStr118 = 118,
+    CErrorStr119 = 119,
+    CErrorStr120 = 120,
+    CErrorStr121 = 121,
+    CErrorStr122 = 122,
+    CErrorStr123 = 123,
+    CErrorStr124 = 124,
+    CErrorStr125 = 125,
+    CErrorStr126 = 126,
+    CErrorStr127 = 127,
+    CErrorStr128 = 128,
+    CErrorStr129 = 129,
+    CErrorStr130 = 130,
+    CErrorStr131 = 131,
+    CErrorStr132 = 132,
+    CErrorStr133 = 133,
+    CErrorStr134 = 134,
+    CErrorStr135 = 135,
+    CErrorStr136 = 136,
+    CErrorStr137 = 137,
+    CErrorStr138 = 138,
+    CErrorStr139 = 139,
+    CErrorStr140 = 140,
+    CErrorStr141 = 141,
+    CErrorStr142 = 142,
+    CErrorStr143 = 143,
+    CErrorStr144 = 144,
+    CErrorStr145 = 145,
+    CErrorStr146 = 146,
+    CErrorStr147 = 147,
+    CErrorStr148 = 148,
+    CErrorStr149 = 149,
+    CErrorStr150 = 150,
+    CErrorStr151 = 151,
+    CErrorStr152 = 152,
+    CErrorStr153 = 153,
+    CErrorStr154 = 154,
+    CErrorStr155 = 155,
+    CErrorStr156 = 156,
+    CErrorStr157 = 157,
+    CErrorStr158 = 158,
+    CErrorStr159 = 159,
+    CErrorStr160 = 160,
+    CErrorStr161 = 161,
+    CErrorStr162 = 162,
+    CErrorStr163 = 163,
+    CErrorStr164 = 164,
+    CErrorStr165 = 165,
+    CErrorStr166 = 166,
+    CErrorStr167 = 167,
+    CErrorStr168 = 168,
+    CErrorStr169 = 169,
+    CErrorStr170 = 170,
+    CErrorStr171 = 171,
+    CErrorStr172 = 172,
+    CErrorStr173 = 173,
+    CErrorStr174 = 174,
+    CErrorStr175 = 175,
+    CErrorStr176 = 176,
+    CErrorStr177 = 177,
+    CErrorStr178 = 178,
+    CErrorStr179 = 179,
+    CErrorStr180 = 180,
+    CErrorStr181 = 181,
+    CErrorStr182 = 182,
+    CErrorStr183 = 183,
+    CErrorStr184 = 184,
+    CErrorStr185 = 185,
+    CErrorStr186 = 186,
+    CErrorStr187 = 187,
+    CErrorStr188 = 188,
+    CErrorStr189 = 189,
+    CErrorStr190 = 190,
+    CErrorStr191 = 191,
+    CErrorStr192 = 192,
+    CErrorStr193 = 193,
+    CErrorStr194 = 194,
+    CErrorStr195 = 195,
+    CErrorStr196 = 196,
+    CErrorStr197 = 197,
+    CErrorStr198 = 198,
+    CErrorStr199 = 199,
+    CErrorStr200 = 200,
+    CErrorStr201 = 201,
+    CErrorStr202 = 202,
+    CErrorStr203 = 203,
+    CErrorStr204 = 204,
+    CErrorStr205 = 205,
+    CErrorStr206 = 206,
+    CErrorStr207 = 207,
+    CErrorStr208 = 208,
+    CErrorStr209 = 209,
+    CErrorStr210 = 210,
+    CErrorStr211 = 211,
+    CErrorStr212 = 212,
+    CErrorStr213 = 213,
+    CErrorStr214 = 214,
+    CErrorStr215 = 215,
+    CErrorStr216 = 216,
+    CErrorStr217 = 217,
+    CErrorStr218 = 218,
+    CErrorStr219 = 219,
+    CErrorStr220 = 220,
+    CErrorStr221 = 221,
+    CErrorStr222 = 222,
+    CErrorStr223 = 223,
+    CErrorStr224 = 224,
+    CErrorStr225 = 225,
+    CErrorStr226 = 226,
+    CErrorStr227 = 227,
+    CErrorStr228 = 228,
+    CErrorStr229 = 229,
+    CErrorStr230 = 230,
+    CErrorStr231 = 231,
+    CErrorStr232 = 232,
+    CErrorStr233 = 233,
+    CErrorStr234 = 234,
+    CErrorStr235 = 235,
+    CErrorStr236 = 236,
+    CErrorStr237 = 237,
+    CErrorStr238 = 238,
+    CErrorStr239 = 239,
+    CErrorStr240 = 240,
+    CErrorStr241 = 241,
+    CErrorStr242 = 242,
+    CErrorStr243 = 243,
+    CErrorStr244 = 244,
+    CErrorStr245 = 245,
+    CErrorStr246 = 246,
+    CErrorStr247 = 247,
+    CErrorStr248 = 248,
+    CErrorStr249 = 249,
+    CErrorStr250 = 250,
+    CErrorStr251 = 251,
+    CErrorStr252 = 252,
+    CErrorStr253 = 253,
+    CErrorStr254 = 254,
+    CErrorStr255 = 255,
+    CErrorStr256 = 256,
+    CErrorStr257 = 257,
+    CErrorStr258 = 258,
+    CErrorStr259 = 259,
+    CErrorStr260 = 260,
+    CErrorStr261 = 261,
+    CErrorStr262 = 262,
+    CErrorStr263 = 263,
+    CErrorStr264 = 264,
+    CErrorStr265 = 265,
+    CErrorStr266 = 266,
+    CErrorStr267 = 267,
+    CErrorStr268 = 268,
+    CErrorStr269 = 269,
+    CErrorStr270 = 270,
+    CErrorStr271 = 271,
+    CErrorStr272 = 272,
+    CErrorStr273 = 273,
+    CErrorStr274 = 274,
+    CErrorStr275 = 275,
+    CErrorStr276 = 276,
+    CErrorStr277 = 277,
+    CErrorStr278 = 278,
+    CErrorStr279 = 279,
+    CErrorStr280 = 280,
+    CErrorStr281 = 281,
+    CErrorStr282 = 282,
+    CErrorStr283 = 283,
+    CErrorStr284 = 284,
+    CErrorStr285 = 285,
+    CErrorStr286 = 286,
+    CErrorStr287 = 287,
+    CErrorStr288 = 288,
+    CErrorStr289 = 289,
+    CErrorStr290 = 290,
+    CErrorStr291 = 291,
+    CErrorStr292 = 292,
+    CErrorStr293 = 293,
+    CErrorStr294 = 294,
+    CErrorStr295 = 295,
+    CErrorStr296 = 296,
+    CErrorStr297 = 297,
+    CErrorStr298 = 298,
+    CErrorStr299 = 299,
+    CErrorStr300 = 300,
+    CErrorStr301 = 301,
+    CErrorStr302 = 302,
+    CErrorStr303 = 303,
+    CErrorStr304 = 304,
+    CErrorStr305 = 305,
+    CErrorStr306 = 306,
+    CErrorStr307 = 307,
+    CErrorStr308 = 308,
+    CErrorStr309 = 309,
+    CErrorStr310 = 310,
+    CErrorStr311 = 311,
+    CErrorStr312 = 312,
+    CErrorStr313 = 313,
+    CErrorStr314 = 314,
+    CErrorStr315 = 315,
+    CErrorStr316 = 316,
+    CErrorStr317 = 317,
+    CErrorStr318 = 318,
+    CErrorStr319 = 319,
+    CErrorStr320 = 320,
+    CErrorStr321 = 321,
+    CErrorStr322 = 322,
+    CErrorStr323 = 323,
+    CErrorStr324 = 324,
+    CErrorStr325 = 325,
+    CErrorStr326 = 326,
+    CErrorStr327 = 327,
+    CErrorStr328 = 328,
+    CErrorStr329 = 329,
+    CErrorStr330 = 330,
+    CErrorStr331 = 331,
+    CErrorStr332 = 332,
+    CErrorStr333 = 333,
+    CErrorStr334 = 334,
+    CErrorStr335 = 335,
+    CErrorStr336 = 336,
+    CErrorStr337 = 337,
+    CErrorStr338 = 338,
+    CErrorStr339 = 339,
+    CErrorStr340 = 340,
+    CErrorStr341 = 341,
+    CErrorStr342 = 342,
+    CErrorStr343 = 343,
+    CErrorStr344 = 344,
+    CErrorStr345 = 345,
+    CErrorStr346 = 346,
+    CErrorStr347 = 347,
+    CErrorStr348 = 348,
+    CErrorStr349 = 349,
+    CErrorStr350 = 350,
+    CErrorStr351 = 351,
+    CErrorStr352 = 352,
+    CErrorStr353 = 353,
+    CErrorStr354 = 354,
+    CErrorStr355 = 355,
+    CErrorStr356 = 356,
+    CErrorStr357 = 357,
+    CErrorStr358 = 358,
+    CErrorStr359 = 359,
+    CErrorStr360 = 360,
+    CErrorStr361 = 361,
+    CErrorStr362 = 362,
+    CErrorStr363 = 363,
+    CErrorStr364 = 364,
+    CErrorStr365 = 365,
+    CErrorStr366 = 366,
+    CErrorStr367 = 367,
+    CErrorStr368 = 368,
+    CErrorStr369 = 369,
+    CErrorStr370 = 370,
+    CErrorStr371 = 371,
+    CErrorStr372 = 372,
+    CErrorStr373 = 373,
+    CErrorStr374 = 374,
+    CErrorStr375 = 375,
+    CErrorStr376 = 376,
+    CErrorStr377 = 377,
+    CErrorStr378 = 378,
+    CErrorStr379 = 379,
+    CErrorStr380 = 380,
+    CErrorStr381 = 381,
+    CErrorStr382 = 382,
+    CErrorStr383 = 383,
+    CErrorStr384 = 384,
+    CErrorStr385 = 385,
+    CErrorStr386 = 386,
+    CErrorStr387 = 387,
+    CErrorStr388 = 388,
+    CErrorStr389 = 389,
+    CErrorStr390 = 390,
+    CErrorStr391 = 391,
+    CErrorStr392 = 392,
+    CErrorStrMAX = 393
+};
+
+typedef struct _CErrorBuffer {
+    char *start;
+    char *end;
+    UInt32 size;
+    UInt32 remaining;
+} CErrorBuffer;
+
+extern void CError_Init();
+extern void CError_SetErrorToken(TStreamElement *token);
+extern void CError_SetNullErrorToken();
+extern void CError_LockErrorPos(TStreamElement *token, TStreamElement **saved);
+extern void CError_UnlockErrorPos(TStreamElement **saved);
+extern void CError_ResetErrorSkip();
+extern void CError_GetErrorString(char *buf, short code);
+extern void CError_BufferInit(CErrorBuffer *eb, char *buf, SInt32 bufSize);
+extern void CError_BufferGrow(CErrorBuffer *eb, SInt32 amount);
+extern void CError_BufferAppendChar(CErrorBuffer *eb, char ch);
+extern void CError_BufferAppendString(CErrorBuffer *eb, const char *str);
+extern void CError_BufferTerminate(CErrorBuffer *eb);
+extern void CError_BufferAppendQualifier(CErrorBuffer *eb, UInt32 qual);
+extern void CError_BufferAppendTemplArgExpr(CErrorBuffer *eb, ENode *node);
+extern void CError_BufferAppendTemplArg(CErrorBuffer *eb, TemplArg *targ);
+extern void CError_BufferAppendTemplArgs(CErrorBuffer *eb, TemplArg *targs);
+extern void CError_BufferAppendNameSpace(CErrorBuffer *eb, NameSpace *nspace);
+extern void CError_BufferAppendPType(CErrorBuffer *eb, Type *ty);
+extern void CError_BufferAppendTemplDepType(CErrorBuffer *eb, TypeTemplDep *type);
+extern void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMethod);
+extern void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual);
+extern char *CError_GetTypeName(Type *ty, UInt32 qual, Boolean useGlobalHeap);
+extern void CError_AppendUnqualFunctionName(CErrorBuffer *eb, NameSpace *nspace, HashNameNode *name, TypeFunc *tfunc);
+extern void CError_AppendFunctionName(CErrorBuffer *eb, NameSpace *nspace, HashNameNode *name, TemplArg *templargs, TypeFunc *tfunc);
+extern void CError_AppendObjectName(CErrorBuffer *eb, Object *obj);
+extern void CError_AppendMethodName(CErrorBuffer *eb, ObjCMethod *meth);
+extern char *CError_GetQualifiedName(NameSpace *nspace, HashNameNode *name);
+extern char *CError_GetFunctionName(NameSpace *nspace, HashNameNode *name, TypeFunc *tfunc);
+extern char *CError_GetObjectName(Object *obj);
+extern char *CError_GetNameString(NameSpace *nspace, HashNameNode *operatorName);
+extern void CError_ErrorMessage(int errTable, char *buf, Boolean flag1, Boolean flag2);
+extern void CError_BufferAppendTemplateStack(CErrorBuffer *eb);
+extern void CError_ErrorMessageVA(int code, const char *format, va_list list, Boolean flag1, Boolean flag2);
+extern void CError_VAErrorMessage(int code, va_list list, Boolean flag1, Boolean flag2);
+extern void CError_Error(int code, ...);
+extern void CError_ErrorTerm(short code);
+extern void CError_ErrorSkip(int code, ...);
+extern void CError_ErrorFuncCall(short code, NameSpaceObjectList *args, ENodeList *argNodes);
+extern void CError_OverloadedFunctionError2(Object *obj, ObjectList *olst, ENodeList *argNodes);
+extern void CError_OverloadedFunctionError(Object *obj, ObjectList *olst);
+extern void CError_AbstractClassError(TypeClass *tclass);
+extern void CError_Warning(int code, ...);
+extern void CError_BreakPoint(const char *a, const char *b);
+extern void CError_Internal();
+extern void CError_ExpressionTooComplex();
+extern void CError_NoMem();
+extern void CError_UserBreak();
+extern void CError_CannotOpen();
+extern void CError_QualifierCheck(UInt32 qual);
+
+#endif
diff --git a/includes/compiler/CInt64.h b/includes/compiler/CInt64.h
new file mode 100644
index 0000000..455bf3f
--- /dev/null
+++ b/includes/compiler/CInt64.h
@@ -0,0 +1,88 @@
+#ifndef COMPILER_CINT64_H
+#define COMPILER_CINT64_H
+
+#include "compiler/common.h"
+
+// 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->hi & 0x80000000) != 0;
+}
+inline void CInt64_SetLong(CInt64 *pN, SInt32 n) {
+    pN->lo = n;
+    pN->hi = (n < 0) ? 0xFFFFFFFF : 0;
+}
+inline void CInt64_SetULong(CInt64 *pN, UInt32 n) {
+    pN->lo = n;
+    pN->hi = 0;
+}
+
+inline int CInt64_IsZero(CInt64 *n) {
+    //if (n->hi == 0 && n->lo == 0)
+    //    return 1;
+    //else
+    //    return 0;
+    return n->hi == 0 && n->lo == 0;
+}
+inline void CInt64_Extend32(CInt64 *n) { // assumed name
+    n->hi = (n->lo >> 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 Boolean CInt64_Less(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_LessU(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_Greater(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_GreaterU(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_LessEqual(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_LessEqualU(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_GreaterEqual(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_GreaterEqualU(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_Equal(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_NotEqual(CInt64 lhs, CInt64 rhs);
+extern Boolean CInt64_IsInRange(CInt64 value, short len);
+extern Boolean 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, Boolean *pFail);
+extern char *CInt64_ScanDecString(CInt64 *pResult, char *str, Boolean *pFail);
+extern char *CInt64_ScanHexString(CInt64 *pResult, char *str, Boolean *pFail);
+extern char *CInt64_ScanBinString(CInt64 *pResult, char *str, Boolean *pFail);
+extern char *CInt64_ScanAsmNumber(CInt64 *pResult, char *str, Boolean *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);
+
+#endif
diff --git a/includes/compiler/CompilerTools.h b/includes/compiler/CompilerTools.h
new file mode 100644
index 0000000..50581b0
--- /dev/null
+++ b/includes/compiler/CompilerTools.h
@@ -0,0 +1,129 @@
+#ifndef COMPILER_COMPILERTOOLS_H
+#define COMPILER_COMPILERTOOLS_H
+
+#include "compiler/common.h"
+
+extern void CompilerGetPString(short index, unsigned char *string);
+extern void CompilerGetCString(short index, char *string);
+extern unsigned char *CTool_CtoPstr(char *cstr);
+
+typedef struct HeapBlock {
+	struct HeapBlock *next;
+	Handle blockhandle;
+	SInt32 blocksize;
+	SInt32 blockfree;
+} HeapBlock;
+
+typedef struct HeapMem {
+	HeapBlock *blocks;
+    /// The minimum size for a new block
+	SInt32 allocsize;
+	HeapBlock *curblock;
+	char *curfreep;
+	SInt32 curfree;
+} HeapMem;
+
+typedef struct _HeapInfo {
+    /// The amount of blocks in this heap
+    SInt32 blocks;
+    /// The value of allocsize for the heap
+    SInt32 allocsize;
+    /// The total amount of bytes across all blocks
+    SInt32 total_size;
+    /// The amount of free bytes across all blocks
+    SInt32 total_free;
+    /// The average size of a block
+    SInt32 average_block_size;
+    /// The average amount of free space in a block
+    SInt32 average_block_free;
+    /// The amount of bytes in the largest contiguous section of free space
+    SInt32 largest_free_block;
+} HeapInfo;
+
+typedef struct GList {
+	char **data;
+	SInt32 size;
+	SInt32 hndlsize;
+	SInt32 growsize;
+} GList;
+
+extern long hash_name_id;
+extern HashNameNode **name_hash_nodes;
+extern void (*GListErrorProc)();
+
+extern short InitGList(GList *gl, SInt32 size);
+extern void FreeGList(GList *gl);
+extern void LockGList(GList *gl);
+extern void UnlockGList(GList *gl);
+extern void ShrinkGList(GList *gl);
+extern void AppendGListData(GList *gl, const void *data, SInt32 size);
+extern void AppendGListNoData(GList *gl, SInt32 size);
+extern void AppendGListByte(GList *gl, SInt8 thebyte);
+extern void AppendGListWord(GList *gl, SInt16 theword);
+extern void AppendGListTargetEndianWord(GList *gl, SInt16 theword);
+extern void AppendGListLong(GList *gl, SInt32 theword);
+extern void AppendGListTargetEndianLong(GList *gl, SInt32 theword);
+extern void AppendGListID(GList *gl, const char *name);
+extern void AppendGListName(GList *gl, const char *name);
+extern void RemoveGListData(GList *gl, SInt32 size);
+extern SInt16 GetGListByte(GList *gl);
+extern SInt16 GetGListWord(GList *gl);
+extern SInt32 GetGListLong(GList *gl);
+extern short GetGListID(GList *gl, char *name);
+extern void GetGListData(GList *gl, char *where, SInt32 size);
+
+extern SInt16 CHash(const char *string);
+extern HashNameNode *GetHashNameNode(const char *name);
+extern HashNameNode *GetHashNameNodeHash(const char *name, SInt16 hashval);
+extern HashNameNode *GetHashNameNodeHash2(const char *name, SInt16 hashval);
+extern HashNameNode *GetHashNameNodeExport(const char *name);
+extern SInt32 GetHashNameNodeExportID(HashNameNode *node);
+extern HashNameNode *GetHashNameNodeByID(SInt32 id);
+extern void NameHashExportReset();
+extern void NameHashWriteNameTable(GList *glist);
+extern void NameHashWriteTargetEndianNameTable(GList *glist);
+extern void InitNameHash();
+
+typedef void (*heaperror_t)();
+
+extern SInt32 CTool_TotalHeapSize();
+extern void CTool_GetHeapInfo(HeapInfo *result, unsigned char heapID);
+extern short initheaps(heaperror_t heaperrorproc);
+extern short initgheap(heaperror_t heaperrorproc);
+extern heaperror_t getheaperror();
+extern void setheaperror(heaperror_t heaperrorproc);
+extern void releaseheaps();
+extern void releasegheap();
+extern void releaseoheap();
+extern void *galloc(SInt32 s);
+extern void *lalloc(SInt32 s);
+extern void *aalloc(SInt32 s);
+extern void *oalloc(SInt32 s);
+extern void *balloc(SInt32 s);
+
+extern void locklheap();
+extern void unlocklheap();
+extern void freelheap();
+extern void freeaheap();
+extern void freeoheap();
+extern void freebheap();
+
+extern char *ScanHex(char *string, UInt32 *result, Boolean *overflow);
+extern char *ScanOct(char *string, UInt32 *result, Boolean *overflow);
+extern char *ScanDec(char *string, UInt32 *result, Boolean *overflow);
+
+extern void OldUnmangle(char *name, char *out, Boolean full);
+
+extern short hash(char *a);
+extern void memclr(void *ptr, SInt32 size);
+extern void memclrw(void *ptr, SInt32 size);
+extern void CToLowercase(char *a, char *b);
+extern short getbit(SInt32 l);
+extern void CTool_EndianConvertWord64(CInt64 ci, char *result);
+extern UInt16 CTool_EndianConvertInPlaceWord16Ptr(UInt16 *x);
+extern UInt32 CTool_EndianConvertInPlaceWord32Ptr(UInt32 *x);
+extern void CTool_EndianConvertVector128(); // not correct but idc
+extern HashNameNode *CTool_GetPathName(const FSSpec *fss, SInt32 *moddateptr);
+extern int strcat_safe(char *dest, const char *src, SInt32 len);
+
+#endif
diff --git a/includes/compiler/common.h b/includes/compiler/common.h
new file mode 100644
index 0000000..b5909e2
--- /dev/null
+++ b/includes/compiler/common.h
@@ -0,0 +1,283 @@
+#ifndef COMPILER_COMMON_H
+#define COMPILER_COMMON_H
+
+#include "cw_common.h"
+
+typedef struct HashNameNode {
+    struct HashNameNode *next;
+    SInt32 id;
+    SInt16 hashval;
+    char name[1];
+} HashNameNode;
+
+typedef struct CPrepFileInfo CPrepFileInfo;
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+// TODO move me into CPrep.h or something?
+struct CPrepFileInfo {
+    FSSpec textfile;
+    HashNameNode *nameNode;
+    SInt32 fileModDate;
+    char *textbuffer;
+    SInt32 textlength;
+    SInt32 linenumber;
+    SInt32 pos;
+    Boolean hasprepline;
+    SInt16 fileID;
+    Boolean recordbrowseinfo;
+    Boolean unkfield123;
+    Boolean unkfield124;
+    Boolean unkfield125;
+    Boolean unkfield126;
+};
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+typedef struct CInt64 {
+    SInt32 hi;
+    UInt32 lo;
+} CInt64;
+
+typedef struct Float {
+    double value;
+} Float;
+
+typedef union MWVector128 {
+    UInt8 uc[16];
+    UInt16 us[8];
+    UInt32 ul[4];
+    float f[4];
+} MWVector128;
+
+typedef enum AccessType {
+    ACCESSPUBLIC,
+    ACCESSPRIVATE,
+    ACCESSPROTECTED,
+    ACCESSNONE
+} AccessType;
+
+typedef enum Section {
+    SECT_DEFAULT = 0,
+    SECT_TEXT = 1,
+    SECT_DATA = 2,
+    SECT_UDATA = 3,
+    SECT_DATA_FAR = 4,
+    SECT_DATA_NEAR = 5,
+    SECT_INIT = 6,
+    SECT_OBJC_CAT_CLS_METH = 7,
+    SECT_OBJC_CAT_INST_METH = 8,
+    SECT_OBJC_STRING_OBJECT = 9,
+    SECT_OBJC_CSTRING_OBJECT = 10,
+    SECT_OBJC_MESSAGE_REFS = 11,
+    SECT_OBJC_SEL_FIXUP = 12,
+    SECT_OBJC_CLS_REFS = 13,
+    SECT_OBJC_CLASS = 14,
+    SECT_OBJC_META_CLASS = 15,
+    SECT_OBJC_CLS_METH = 16,
+    SECT_OBJC_INST_METH = 17,
+    SECT_OBJC_PROTOCOL = 18,
+    SECT_OBJC_CLASS_NAMES = 19,
+    SECT_OBJC_METH_VAR_TYPES = 20,
+    SECT_OBJC_METH_VAR_NAMES = 21,
+    SECT_OBJC_CATEGORY = 22,
+    SECT_OBJC_CLASS_VARS = 23,
+    SECT_OBJC_INSTANCE_VARS = 24,
+    SECT_OBJC_MODULE_INFO = 25,
+    SECT_OBJC_MSYMBOLS = 26,
+    SECT_TEXT_CSTRING = 27,
+    SECT_BACKEND_SPECIFIC = 28,
+    SECT_MW_EX_TABLE = 28,
+    SECT_MW_EX_TABLE_INDEX = 29,
+    SECT_MW_SWITCH = 30,
+    SECT_8BYTE_LITERALS = 31,
+    SECT_4BYTE_LITERALS = 32,
+    SECT_MOD_INIT_FUNC = 33,
+    SECT_MOD_TERM_FUNC = 34,
+    SECT_CONST = 35,
+    SECT_CONST_PTR = 36,
+    SECT_NONLAZY_PTRS = 37,
+    SECT_COMMON_VARS = 38,
+    SECT_16BYTE_LITERALS = 39,
+    SECT_TEXT_COALESCE = 40,
+    SECT_DATA_COALESCE = 41,
+    SECT_UDATA_COALESCE = 42,
+    SECT_CONST_COALESCE = 43,
+    SECT_CONST_PTR_COALESCE = 44,
+    SECT_CSTR_COALESCE = 45,
+    N_SECTIONS = 46
+} Section;
+
+typedef struct BClassList BClassList;
+typedef struct CI_FuncData CI_FuncData;
+typedef struct CLabel CLabel;
+typedef struct DefArgCtorInfo DefArgCtorInfo;
+typedef struct DepName DepName;
+typedef struct ENode ENode;
+typedef struct ENodeList ENodeList;
+typedef struct ExceptionAction ExceptionAction;
+typedef struct ExtendedParam ExtendedParam;
+typedef struct FuncArg FuncArg;
+typedef struct Initializer Initializer;
+typedef struct InlineXRef InlineXRef;
+typedef struct MemInitializer MemInitializer;
+typedef struct NameSpace NameSpace;
+typedef struct NameSpaceName NameSpaceName;
+typedef struct NameSpaceList NameSpaceList;
+typedef struct NameSpaceLookupList NameSpaceLookupList;
+typedef struct NameSpaceObjectList NameSpaceObjectList;
+typedef struct ObjBase ObjBase;
+typedef struct ObjEnumConst ObjEnumConst;
+typedef struct ObjMemberVar ObjMemberVar;
+typedef struct ObjMemberVarPath ObjMemberVarPath;
+typedef struct ObjNameSpace ObjNameSpace;
+typedef struct ObjType ObjType;
+typedef struct ObjTypeTag ObjTypeTag;
+typedef struct Object Object;
+typedef struct ObjectList ObjectList;
+typedef struct ObjCInfo ObjCInfo;
+typedef struct ObjCMethod ObjCMethod;
+typedef struct PCodeLabel PCodeLabel;
+typedef struct PointsToFunction PointsToFunction;
+typedef struct PTFList PTFList;
+typedef struct SOMInfo SOMInfo;
+typedef struct Statement Statement;
+typedef struct StructMember StructMember;
+typedef struct Template Template;
+typedef struct TemplateAction TemplateAction;
+typedef struct TemplateFriend TemplateFriend;
+typedef struct TemplateMember TemplateMember;
+typedef struct TemplArg TemplArg;
+typedef struct TemplClass TemplClass;
+typedef struct TemplClassInst TemplClassInst;
+typedef struct TemplateFunction TemplateFunction;
+typedef struct TemplFuncInstance TemplFuncInstance;
+typedef struct TemplInstance TemplInstance;
+typedef struct TemplParam TemplParam;
+typedef struct TemplPartialSpec TemplPartialSpec;
+typedef struct TemplStack TemplStack;
+typedef struct TStream TStream;
+typedef struct TStreamElement TStreamElement;
+typedef struct Type Type;
+typedef struct TypeBitfield TypeBitfield;
+typedef struct TypeClass TypeClass;
+typedef struct TypeEnum TypeEnum;
+typedef struct TypeFunc TypeFunc;
+typedef struct TypeIntegral TypeIntegral;
+typedef struct TypeMemberPointer TypeMemberPointer;
+typedef struct TypeMethod TypeMethod;
+typedef struct TypePointer TypePointer;
+typedef struct TypeStruct TypeStruct;
+typedef struct TypeTemplDep TypeTemplDep;
+typedef struct VarInfo VarInfo;
+typedef struct VarRecord VarRecord;
+
+// Common bits for templates
+typedef enum TemplParamType {
+    TPT_TYPE = 0,
+    TPT_NONTYPE,
+    TPT_TEMPLATE
+} TemplParamType;
+
+typedef struct TemplParamID {
+    UInt16 index;
+    UInt8 nindex;
+    TemplParamType type;
+} TemplParamID;
+
+typedef enum TemplDepSubType {
+    TDE_PARAM,
+    TDE_TYPEEXPR,
+    TDE_CAST,
+    TDE_QUALNAME,
+    TDE_QUALTEMPL,
+    TDE_OBJACCESS,
+    TDE_SOURCEREF,
+    TDE_FUNCCALL,
+    TDE_LOCAL,
+    TDE_MONAND,
+    TDE_MONPLUS,
+    TDE_MONMUL,
+    TDE_NEW,
+    TDE_DELETE,
+    TDE_ARRAY,
+    TDE_DYNAMIC_CAST,
+    TDE_STATIC_CAST,
+    TDE_REINTERPRET_CAST,
+    TDE_CONST_CAST,
+    TDE_TYPEID,
+    TDE_MEMBERACCESS,
+    TDE_THROW,
+    TDE_EXCEPTIONINIT,
+    TDE_LOCALINIT,
+    TDE_STATICINIT,
+    TDE_LOCALDESTROY,
+    TDE_ILLEGAL
+} TemplDepSubType;
+
+/// Things that can be applied to a type expression
+typedef enum TEFuncSel {
+    TEFS_SIZEOF,
+    TEFS_ALIGNOF,
+    TEFS_UUIDOF,
+    TEFS_BI_ALIGN,
+    TEFS_BI_TYPE,
+    TEFS_BI_VTYPE,
+    TEFS_BI_CTYPE
+} TEFuncSel;
+
+/// How to access an object
+/// this might not actually be in Pro7 lol
+typedef struct ObjAccess {
+    NameSpaceObjectList *list;
+    TypeClass *naming;
+    TypeClass *member;
+    TemplArg *targs;
+    HashNameNode *name;
+    ENode *expr;
+    Boolean is_qualified;
+    Boolean is_member;
+    Boolean is_ambig : 1;
+    Boolean is_ptm : 1;
+    Boolean ext_only : 1;
+} ObjAccess;
+
+/// Qualifiers
+enum {
+    Q_CONST = 1,
+    Q_VOLATILE = 2,
+    Q_ASM = 4,
+    Q_PASCAL = 8,
+    Q_INLINE = 0x10,
+    Q_REFERENCE = 0x20,
+    Q_EXPLICIT = 0x40,
+    Q_MUTABLE = 0x80,
+    Q_VIRTUAL = 0x100,
+    Q_FRIEND = 0x200,
+    Q_IN = 0x400,
+    Q_OUT = 0x800,
+    Q_INOUT = 0x1000,
+    Q_BYCOPY = 0x2000,
+    Q_BYREF = 0x4000,
+    Q_ONEWAY = 0x8000,
+    Q_RESTRICT = 0x200000,
+    Q_ALIGNED_1 = 0x2000000,
+    Q_ALIGNED_2 = 0x4000000,
+    Q_ALIGNED_4 = 0x6000000,
+    Q_ALIGNED_8 = 0x8000000,
+    Q_ALIGNED_16 = 0xA000000,
+    Q_ALIGNED_32 = 0xC000000,
+    Q_ALIGNED_64 = 0x10000000,
+    Q_ALIGNED_128 = 0x12000000,
+    Q_ALIGNED_256 = 0x14000000,
+    Q_ALIGNED_512 = 0x16000000,
+    Q_ALIGNED_1024 = 0x18000000,
+    Q_ALIGNED_2048 = 0x1A000000,
+    Q_ALIGNED_4096 = 0x1C000000,
+    Q_ALIGNED_8192 = 0x1E000000,
+    Q_ALIGNED_MASK = 0x1E000000
+};
+
+#endif
diff --git a/includes/compiler/enode.h b/includes/compiler/enode.h
new file mode 100644
index 0000000..6e0ab2c
--- /dev/null
+++ b/includes/compiler/enode.h
@@ -0,0 +1,264 @@
+#ifndef COMPILER_ENODE_H
+#define COMPILER_ENODE_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef enum ENodeType {
+    EPOSTINC,
+    EPOSTDEC,
+    EPREINC,
+    EPREDEC,
+    EINDIRECT,
+    EMONMIN,
+    EBINNOT,
+    ELOGNOT,
+    EFORCELOAD,
+    EMUL,
+    EMULV,
+    EDIV,
+    EMODULO,
+    EADDV,
+    ESUBV,
+    EADD,
+    ESUB,
+    ESHL,
+    ESHR,
+    ELESS,
+    EGREATER,
+    ELESSEQU,
+    EGREATEREQU,
+    EEQU,
+    ENOTEQU,
+    EAND,
+    EXOR,
+    EOR,
+    ELAND,
+    ELOR,
+    EASS,
+    EMULASS,
+    EDIVASS,
+    EMODASS,
+    EADDASS,
+    ESUBASS,
+    ESHLASS,
+    ESHRASS,
+    EANDASS,
+    EXORASS,
+    EORASS,
+    ECOMMA,
+    EPMODULO,
+    EROTL,
+    EROTR,
+    EBCLR,
+    EBTST,
+    EBSET,
+    ETYPCON,
+    EBITFIELD,
+    EINTCONST,
+    EFLOATCONST,
+    ESTRINGCONST,
+    ECOND,
+    EFUNCCALL,
+    EFUNCCALLP,
+    EOBJREF,
+    EMFPOINTER,
+    ENULLCHECK,
+    EPRECOMP,
+    ETEMP,
+    EARGOBJ,
+    ELOCOBJ,
+    ELABEL,
+    ESETCONST,
+    ENEWEXCEPTION,
+    ENEWEXCEPTIONARRAY,
+    EOBJLIST,
+    EMEMBER,
+    ETEMPLDEP,
+    EINSTRUCTION,
+    EDEFINE,
+    EREUSE,
+    EASSBLK,
+    EVECTOR128CONST,
+    ECONDASS,
+    MAXEXPR
+} ENodeType;
+
+
+struct ENodeList {
+    ENodeList *next;
+    ENode *node;
+};
+
+
+typedef union ENodeUnion {
+    CInt64 intval;
+    Float floatval;
+    SInt32 longval;
+    ENode *monadic;
+    Object *objref;
+    CLabel *label;
+    MWVector128 vector128val;
+    struct {
+        ENode *left;
+        ENode *right;
+    } diadic;
+    struct {
+        ENode *cond;
+        ENode *expr1;
+        ENode *expr2;
+    } cond;
+    struct {
+        ENode *funcref;
+        ENodeList *args;
+        TypeFunc *functype;
+    } funccall;
+    ObjAccess objaccess;
+    struct {
+        ENode *accessnode;
+        ENode *mfpointer;
+    } mfpointer;
+    struct {
+        ENode *nullcheckexpr;
+        ENode *condexpr;
+        SInt32 precompid;
+    } nullcheck;
+    SInt32 precompid;
+    struct {
+        Type *type;
+        SInt32 uniqueid;
+        Boolean needs_dtor;
+    } temp;
+    struct {
+        SInt32 size;
+        char *data;
+        SInt32 segnum;
+        char ispascal;
+        char ispacked;
+    } string;
+    struct {
+        SInt32 size;
+        char *data;
+    } set;
+    struct {
+        ENode *initexpr;
+        ENode *tryexpr;
+        Object *pointertemp;
+        Object *deletefunc;
+    } newexception;
+    struct {
+        ENode *initexpr;
+        ENode *tryexpr;
+        ENode *catchexpr;
+        ENode *result;
+    } itc;
+    struct {
+        Object *objref;
+        SInt32 offset;
+    } addr;
+    void *inst;
+    MemInitializer *ctorinit;
+    Statement *stmt;
+    struct {
+        union {
+            TemplParamID pid;
+            struct {
+                union {
+                    Type *type;
+                    ENode *expr;
+                } u;
+                TEFuncSel sel;
+                Boolean is_expr;
+            } typeexpr;
+            struct {
+                ENodeList *args;
+                Type *type;
+                UInt32 qual;
+            } cast;
+            struct {
+                TypeTemplDep *type;
+                HashNameNode *name;
+            } qual;
+            struct {
+                TypeTemplDep *type;
+                HashNameNode *name;
+                TemplArg *args;
+            } qualtempl;
+            ObjAccess objaccess;
+            struct {
+                ENode *expr;
+                TStreamElement *token;
+            } sourceref;
+            ENode *monadic;
+            struct {
+                ENode *expr;
+                ENodeList *args;
+            } funccall;
+            struct {
+                Type *type;
+                UInt32 qual;
+                ENode *arraydim;
+                ENodeList *placement;
+                ENodeList *initlist;
+                Boolean is_global;
+                Boolean has_init;
+            } nw;
+            struct {
+                ENode *expr;
+                Boolean is_global;
+                Boolean is_array;
+            } del;
+            struct {
+                ENode *left;
+                ENode *right;
+            } dyadic;
+            struct {
+                ENode *expr;
+                Type *type;
+                UInt32 qual;
+            } newcast;
+            struct {
+                ENode *expr;
+                DepName *dname;
+                Boolean is_pointer;
+            } member;
+            struct {
+                Object *object;
+                Object *info;
+            } exinit;
+            struct {
+                Object *obj;
+                Initializer *init;
+            } varinit;
+            Object *obj;
+        } u;
+        TemplDepSubType subtype;
+    } templdep;
+} ENodeUnion;
+
+struct ENode {
+    ENodeType type;
+    UInt8 cost;
+    UInt16 flags; // &1, &2 correspond to quals
+    Boolean ignored;
+    Boolean hascall;
+    // void *loc; - might not be in pro7?
+    Type *rtype;
+    PointsToFunction *pointsTo;
+    ENodeUnion data;
+};
+
+enum {
+    ENODE_FLAG_CONST = Q_CONST,
+    ENODE_FLAG_VOLATILE = Q_VOLATILE,
+    ENODE_FLAG_QUALS = Q_CONST | Q_VOLATILE
+};
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/objc.h b/includes/compiler/objc.h
new file mode 100644
index 0000000..ce3ebe4
--- /dev/null
+++ b/includes/compiler/objc.h
@@ -0,0 +1,80 @@
+#ifndef COMPILER_OBJC_H
+#define COMPILER_OBJC_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct ObjCMethodArg { // bigger in v7 (0x20 vs 0x14)
+    struct ObjCMethodArg *next;
+    HashNameNode *selector;
+    HashNameNode *name;
+    Type *type;
+    UInt32 qual;
+    UInt32 unk14;
+    UInt32 unk18;
+    UInt32 unk1C;
+} ObjCMethodArg;
+
+typedef struct ObjCMethodList { // verified via CPrec
+    struct ObjCMethodList *next;
+    struct ObjCMethod *method;
+} ObjCMethodList;
+
+typedef struct ObjCSelector { // verified via CPrec
+    struct ObjCSelector *next;
+    Object *selobject;
+    HashNameNode *name;
+    struct ObjCMethodList *methods;
+} ObjCSelector;
+
+typedef struct ObjCMethod { // verified via CPrec
+    struct ObjCMethod *next;
+    Object *object;
+    TypeFunc *functype;
+    ObjCSelector *selector;
+    Type *return_type;
+    UInt32 return_qual;
+    ObjCMethodArg *selector_args;
+    Boolean has_valist;
+    Boolean is_class_method;
+    Boolean is_defined;
+} ObjCMethod;
+
+typedef struct ObjCProtocol { // verified via CPrec
+    struct ObjCProtocol *next;
+    HashNameNode *name;
+    struct ObjCProtocolList *protocols;
+    ObjCMethod *methods;
+    Object *object;
+} ObjCProtocol;
+
+typedef struct ObjCProtocolList { // verified via CPrec
+    struct ObjCProtocolList *next;
+    ObjCProtocol *protocol;
+} ObjCProtocolList;
+
+typedef struct ObjCCategory { // verified via CPrec
+    struct ObjCCategory *next;
+    HashNameNode *name;
+    ObjCProtocolList *protocols;
+    ObjCMethod *methods;
+} ObjCCategory;
+
+struct ObjCInfo { // verified via CPrec
+    Object *classobject;
+    Object *metaobject;
+    Object *classrefobj;
+    ObjCMethod *methods;
+    ObjCProtocolList *protocols;
+    ObjCCategory *categories;
+    Boolean is_implemented;
+};
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/objects.h b/includes/compiler/objects.h
new file mode 100644
index 0000000..32552ec
--- /dev/null
+++ b/includes/compiler/objects.h
@@ -0,0 +1,200 @@
+#ifndef COMPILER_OBJECTS_H
+#define COMPILER_OBJECTS_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef enum ObjectType {
+    OT_ENUMCONST,
+    OT_TYPE,
+    OT_TYPETAG,
+    OT_NAMESPACE,
+    OT_MEMBERVAR,
+    OT_OBJECT,
+    OT_ILLEGAL
+} ObjectType;
+
+
+struct ObjectList {
+    ObjectList *next;
+    Object *object;
+};
+
+
+/// General structure with all shared fields for all kinds of objects
+struct ObjBase {
+    ObjectType otype;
+    AccessType access;
+};
+
+
+/// Type 0 (OT_ENUMCONST)
+struct ObjEnumConst {
+    ObjectType otype;
+    AccessType access;
+    ObjEnumConst *next;
+    HashNameNode *name;
+    Type *type;
+    CInt64 val;
+};
+
+
+/// Type 1 (OT_TYPE)
+struct ObjType {
+    ObjectType otype;
+    AccessType access;
+    Type *type;
+    void *unk6;
+};
+
+
+/// Type 2 (OT_TYPETAG)
+struct ObjTypeTag {
+    ObjectType otype;
+    AccessType access;
+    Type *type;
+};
+
+
+/// Type 3 (OT_NAMESPACE)
+struct ObjNameSpace {
+    ObjectType otype;
+    AccessType access;
+    NameSpace *nspace;
+};
+
+
+/// Type 4 (OT_MEMBERVAR)
+struct ObjMemberVar {
+    ObjectType otype;
+    AccessType access;
+    Boolean anonunion;
+    Boolean has_path;
+    struct ObjMemberVar *next;
+    HashNameNode *name;
+    Type *type;
+    UInt32 qual;
+    UInt32 offset;
+};
+struct ObjMemberVarPath {
+    ObjectType otype;
+    AccessType access;
+    Boolean anonunion;
+    Boolean has_path;
+    struct ObjMemberVar *next;
+    HashNameNode *name;
+    Type *type;
+    UInt32 qual;
+    UInt32 offset;
+    BClassList *path;
+};
+
+
+typedef enum DataType {
+    DDATA,
+    DLOCAL,
+    DABSOLUTE,
+    DFUNC,
+    DVFUNC,
+    DINLINEFUNC,
+    DALIAS,
+    DEXPR,
+    DNONLAZYPTR,
+    DLABEL,
+    DUNUSED
+} DataType;
+
+/// Type 5 (OT_OBJECT)
+struct Object {
+    ObjectType otype;
+    AccessType access;
+    DataType datatype;
+    Section section;
+    NameSpace *nspace;
+    HashNameNode *name;
+    Type *type;
+    UInt32 qual;
+    SInt16 sclass;
+    UInt8 flags;
+    ExtendedParam *extParam;
+    Object *toc;
+    void *any;
+    //char reg; // notsure?
+    //VarRecord *varptr; // notsure?
+    // union starts at 0x24 in v7
+    union {
+        struct {
+            union {
+                CInt64 intconst;
+                Float *floatconst;
+                MWVector128 *vector128const;
+                char *string;
+                struct {
+                    char *data;
+                    SInt32 size;
+                } switchtable;
+            } u;
+            VarInfo *info;
+            HashNameNode *linkname;
+            Boolean islocalstatic;
+        } data;
+        UInt32 address;
+        struct {
+            VarInfo *info;
+            HashNameNode *linkname;
+            Object *over_load;
+        } toc;
+        struct {
+            union {
+                TemplateFunction *templ;
+                CI_FuncData *ifuncdata;
+                SInt32 intrinsicid;
+            } u;
+            DefArgCtorInfo *defargdata;
+            HashNameNode *linkname;
+            TemplFuncInstance *inst;
+            PTFList *ptfList;
+            ObjectList *argList;
+        } func;
+        struct {
+            char *data;
+            SInt32 size;
+            InlineXRef *xrefs;
+        } ifunc;
+        struct {
+            VarInfo *info;
+            SInt32 uid;
+            SInt32 offset;
+            Object *realObj;
+        } var;
+        struct {
+            Object *object;
+            //TypeClass *member;
+            BClassList *member; // ???
+            SInt32 offset;
+        } alias;
+        struct {
+            Object *function;
+            HashNameNode *labelname;
+        } label;
+        ENode *expr;
+    } u;
+};
+
+#define OBJ_BASE(obj) ((ObjBase *) (obj))
+#define OBJ_ENUM_CONST(obj) ((ObjEnumConst *) (obj))
+#define OBJ_TYPE(obj) ((ObjType *) (obj))
+#define OBJ_TYPE_TAG(obj) ((ObjTypeTag *) (obj))
+#define OBJ_NAMESPACE(obj) ((ObjNameSpace *) (obj))
+#define OBJ_MEMBER_VAR(obj) ((ObjMemberVar *) (obj))
+#define OBJ_MEMBER_VAR_PATH(obj) ((ObjMemberVarPath *) (obj))
+#define OBJECT(obj) ((Object *) (obj))
+
+#endif
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
diff --git a/includes/compiler/scopes.h b/includes/compiler/scopes.h
new file mode 100644
index 0000000..ea2ae98
--- /dev/null
+++ b/includes/compiler/scopes.h
@@ -0,0 +1,53 @@
+#ifndef COMPILER_SCOPES_H
+#define COMPILER_SCOPES_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+struct NameSpace {
+    NameSpace *parent;
+    HashNameNode *name;
+    NameSpaceList *usings;
+    TypeClass *theclass;
+    NameSpaceName *tparams;
+    union {
+        NameSpaceName **hash;
+        NameSpaceName *list;
+    } data;
+    UInt32 names;
+    Boolean is_hash;
+    Boolean is_global;
+    Boolean is_unnamed;
+    Boolean is_templ;
+};
+
+struct NameSpaceList {
+    NameSpaceList *next;
+    NameSpace *nspace;
+};
+
+struct NameSpaceObjectList {
+    NameSpaceObjectList *next;
+    ObjBase *object;
+};
+
+struct NameSpaceName {
+    NameSpaceName *next;
+    HashNameNode *name;
+    NameSpaceObjectList first;
+};
+
+struct NameSpaceLookupList { // assumed name
+    NameSpaceLookupList *next;
+    NameSpace *nspace;
+    NameSpaceList *namespaces;
+};
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/som.h b/includes/compiler/som.h
new file mode 100644
index 0000000..ab541ef
--- /dev/null
+++ b/includes/compiler/som.h
@@ -0,0 +1,35 @@
+#ifndef COMPILER_SOM_H
+#define COMPILER_SOM_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef enum SOMMethodState {
+    SOMMS_Deleted,
+    SOMMS_Method,
+    SOMMS_Migrated
+} SOMMethodState;
+
+typedef struct SOMReleaseOrder { // checked via CPrec
+    struct SOMReleaseOrder *next;
+    HashNameNode *name;
+    SOMMethodState state;
+} SOMReleaseOrder;
+
+struct SOMInfo { // checked via CPrec
+    TypeClass *metaclass;
+    Object *classdataobject;
+    SOMReleaseOrder *order;
+    UInt32 majorversion;
+    UInt32 minorversion;
+    UInt8 oidl_callstyle;
+};
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/templates.h b/includes/compiler/templates.h
new file mode 100644
index 0000000..f188e0d
--- /dev/null
+++ b/includes/compiler/templates.h
@@ -0,0 +1,237 @@
+#ifndef COMPILER_TEMPLATES_H
+#define COMPILER_TEMPLATES_H
+
+#include "compiler/common.h"
+#include "compiler/types.h"
+#include "compiler/tokens.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct PackedDeclInfo { // ok
+    Type *thetype;
+    UInt32 qual;
+    NameSpace *nspace;
+    HashNameNode *name;
+    TemplArg *expltargs;
+    SInt16 storageclass;
+    Section section;
+    UInt8 exportflags;
+    Boolean has_expltargs;
+} PackedDeclInfo;
+
+struct Template {
+    Template *parent;
+    TemplInstance *parentinst;
+    TemplParam *params;
+    Boolean is_class;
+};
+
+struct TemplateFriend { // verified via CPrec
+    PackedDeclInfo decl;
+    FileOffsetInfo fileoffset;
+    TStream stream;
+};
+
+struct TemplateMember { // verified via CPrec
+    struct TemplateMember *next;
+    TemplParam *params;
+    Object *object;
+    FileOffsetInfo fileoffset;
+    TStream stream;
+    CPrepFileInfo *srcfile;
+    SInt32 startoffset;
+    SInt32 endoffset;
+};
+
+struct TemplInstance {
+    // Template *templ;
+    TemplInstance *parent;
+    TemplArg *args;
+    Boolean is_instantiated;
+    Boolean is_specialized;
+    Boolean is_extern;
+    Boolean static_instantiated;
+};
+/*
+struct __attribute__((packed)) TemplInstance
+{
+  Template *templ;
+  TemplInstance *parent;
+  TemplArg *args;
+  unsigned __int8 is_instantiated;
+  unsigned __int8 is_specialized;
+  unsigned __int8 is_extern;
+  unsigned __int8 static_instantiated;
+};
+
+ */
+
+struct TemplParam { // verified via CPrec
+    TemplParam *next;
+    HashNameNode *name;
+    TemplParamID pid;
+    union {
+        struct {
+            Type *type;
+            UInt32 qual;
+        } typeparam;
+        struct {
+            Type *type;
+            UInt32 qual;
+            ENode *defaultarg;
+        } paramdecl;
+        struct {
+            TemplParam *plist;
+            Type *defaultarg;
+        } templparam;
+    } data;
+};
+
+struct TemplArg { // verified by CPrec
+    TemplArg *next;
+    TemplParamID pid;
+    union {
+        struct {
+            Type *type;
+            UInt32 qual;
+        } typeparam;
+        struct {
+            ENode *expr;
+            Boolean is_ref;
+        } paramdecl;
+        Type *ttargtype;
+    } data;
+    Boolean is_deduced;
+};
+
+struct TemplPartialSpec { // confirmed via CPrec (but templ might be a different type?)
+    TemplPartialSpec *next;
+    TemplClass *templ;
+    TemplArg *args;
+};
+
+struct TemplStack {
+    TemplStack *next;
+    union {
+        Object *func;
+        TypeClass *theclass;
+    } u;
+    Boolean is_func;
+    Boolean is_poi;
+};
+
+/***********/
+/* Classes */
+/***********/
+
+struct TemplClass {
+    TypeClass theclass;
+    TemplClass *next;
+    TemplClass *templ__parent;
+    Type *x3A_maybe_parentinst;
+    TemplParam *templ__params;
+    TemplateMember *members;
+    TemplClassInst *instances;
+    TemplClass *pspec_owner;
+    TemplPartialSpec *pspecs;
+    TemplateAction *actions;
+    // not confirmed these last 3 fields yet but there is space for them
+    UInt16 lex_order_count;
+    SInt8 align;
+    UInt8 flags;
+};
+
+struct TemplClassInst {
+    TypeClass theclass;
+    TemplClassInst *next;
+    Type *x36; // not sure what this represents
+    TemplClass *templ;
+    TemplArg *inst_args;
+    TemplArg *oargs;
+    void *x46;
+};
+
+#define TEMPL_CLASS(ty) ( (TemplClass *) (ty) )
+#define TEMPL_CLASS_INST(ty) ( (TemplClassInst *) (ty) )
+
+/*************/
+/* Functions */
+/*************/
+
+struct TemplateFunction { // verified via CPrec
+    TemplateFunction *next;
+    TemplateFunction *unk4; // parent?
+    HashNameNode *name;
+    TemplParam *params;
+    TStream stream;
+    TStreamElement deftoken;
+    Object *tfunc;
+    TemplFuncInstance *instances;
+    CPrepFileInfo *srcfile;
+    SInt32 startoffset;
+    SInt32 endoffset;
+};
+
+struct TemplFuncInstance { // verified via CPrec
+    TemplFuncInstance *next;
+    Object *object;
+    TemplArg *args;
+    Boolean is_instantiated;
+    Boolean is_specialized;
+    Boolean is_extern;
+    Boolean static_instantiated;
+};
+
+/***********/
+/* Actions */
+/***********/
+
+typedef enum TemplateActionType {
+    TAT_NESTEDCLASS,
+    TAT_ENUMTYPE,
+    TAT_FRIEND,
+    TAT_ENUMERATOR, // in pro7 but not pro8
+    TAT_BASE,
+    TAT_OBJECTINIT,
+    TAT_USINGDECL,
+    TAT_OBJECTDEF,
+    TAT_ILLEGAL
+} TemplateActionType;
+
+struct TemplateAction { // verified via CPrec
+    TemplateAction *next;
+    TStreamElement source_ref;
+    union {
+        TemplClass *tclasstype;
+        TypeEnum *enumtype;
+        TemplateFriend *tfriend;
+        struct {
+            ObjEnumConst *objenumconst;
+            ENode *initexpr;
+        } enumerator;
+        struct {
+            Type *type;
+            ClassList *insert_after;
+            AccessType access;
+            Boolean is_virtual;
+        } base;
+        struct {
+            Object *object;
+            ENode *initexpr;
+        } objectinit;
+        struct {
+            TypeTemplDep *type;
+            AccessType access;
+        } usingdecl;
+        ObjBase *refobj;
+    } u;
+    TemplateActionType type;
+};
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/tokens.h b/includes/compiler/tokens.h
new file mode 100644
index 0000000..b574a81
--- /dev/null
+++ b/includes/compiler/tokens.h
@@ -0,0 +1,182 @@
+#ifndef COMPILER_TOKENS_H
+#define COMPILER_TOKENS_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+#define TKD_OPERATOR 328
+#define TKD_TEMPLATE 332
+#define TKD_IDENTIFIER -3
+#define TKD_COLON_COLON 372
+
+typedef enum EToken {
+    TK_INTCONST = -1,
+    TK_FLOATCONST = -2,
+    TK_IDENTIFIER = -3,
+    TK_STRING = -4,
+    TK_STRING_WIDE = -5,
+    TK_NEG6 = -6,
+    TK_NEG7 = -7,
+    TK_AUTO = 256,
+    TK_REGISTER,
+    TK_STATIC,
+    TK_EXTERN,
+    TK_TYPEDEF,
+    TK_INLINE,
+    TK_VOID,
+    TK_CHAR,
+    TK_SHORT,
+    TK_INT,
+    TK_LONG,
+    TK_FLOAT,
+    TK_DOUBLE,
+    TK_SIGNED,
+    TK_UNSIGNED,
+    TK_STRUCT,
+    TK_UNION,
+    TK_ENUM,
+    TK_CLASS,
+    TK_UU_VECTOR = 283,
+    TK_UU_TYPEOF_UU,
+    TK_BOOL,
+    TK_WCHAR_T,
+    TK_U_COMPLEX,
+    TK_U_IMAGINARY,
+    TK_TYPENAME,
+    TK_CONST,
+    TK_VOLATILE,
+    TK_PASCAL,
+    TK_UU_DECLSPEC,
+    TK_UU_STDCALL,
+    TK_UU_CDECL,
+    TK_UU_FASTCALL,
+    TK_UU_FAR,
+    TK_EXPLICIT,
+    TK_MUTABLE,
+    TK_ONEWAY,
+    TK_IN,
+    TK_INOUT,
+    TK_OUT,
+    TK_BYCOPY,
+    TK_BYREF,
+    TK_ASM = 310,
+    TK_CASE,
+    TK_DEFAULT,
+    TK_IF,
+    TK_ELSE,
+    TK_SWITCH,
+    TK_WHILE,
+    TK_DO,
+    TK_FOR,
+    TK_GOTO,
+    TK_CONTINUE,
+    TK_BREAK,
+    TK_RETURN,
+    TK_SIZEOF,
+    TK_CATCH,
+    TK_DELETE,
+    TK_FRIEND,
+    TK_NEW,
+    TK_OPERATOR,
+    TK_PRIVATE,
+    TK_PROTECTED,
+    TK_PUBLIC,
+    TK_TEMPLATE,
+    TK_THIS,
+    TK_THROW,
+    TK_TRY,
+    TK_VIRTUAL,
+    TK_INHERITED,
+    TK_CONST_CAST,
+    TK_DYNAMIC_CAST,
+    TK_NAMESPACE,
+    TK_REINTERPRET_CAST,
+    TK_STATIC_CAST,
+    TK_USING,
+    TK_TRUE,
+    TK_FALSE,
+    TK_TYPEID,
+    TK_EXPORT,
+    TK_MULT_ASSIGN,
+    TK_DIV_ASSIGN,
+    TK_MOD_ASSIGN,
+    TK_ADD_ASSIGN,
+    TK_SUB_ASSIGN,
+    TK_SHL_ASSIGN,
+    TK_SHR_ASSIGN,
+    TK_AND_ASSIGN,
+    TK_XOR_ASSIGN,
+    TK_OR_ASSIGN,
+    TK_LOGICAL_OR,
+    TK_LOGICAL_AND,
+    TK_LOGICAL_EQ,
+    TK_LOGICAL_NE,
+    TK_LESS_EQUAL,
+    TK_GREATER_EQUAL,
+    TK_SHL,
+    TK_SHR,
+    TK_INCREMENT,
+    TK_DECREMENT,
+    TK_ARROW,
+    TK_ELLIPSIS,
+    TK_DOT_STAR,
+    TK_ARROW_STAR,
+    TK_COLON_COLON,
+    TK_AT_INTERFACE,
+    TK_AT_IMPLEMENTATION,
+    TK_AT_PROTOCOL,
+    TK_AT_END,
+    TK_AT_PRIVATE,
+    TK_AT_PROTECTED,
+    TK_AT_PUBLIC,
+    TK_AT_CLASS,
+    TK_AT_SELECTOR,
+    TK_AT_ENCODE,
+    TK_AT_DEFS,
+    TK_SELF,
+    TK_SUPER,
+    TK_UU_ALIGNOF_UU = 388,
+    TK_RESTRICT,
+    TK_UU_ATTRIBUTE_UU,
+    TK_UU_UUIDOF
+} EToken;
+
+typedef struct FileOffsetInfo {
+    CPrepFileInfo *file;
+    SInt32 offset;
+    SInt32 tokenoffset;
+    Boolean is_inline;
+} FileOffsetInfo;
+
+typedef union TData {
+    HashNameNode *tkidentifier;
+    CInt64 tkintconst;
+    Float tkfloatconst;
+    struct {
+        char *data;
+        SInt32 size;
+    } tkstring;
+} TData;
+
+struct TStreamElement {
+    SInt16 tokentype;
+    SInt16 subtype;
+    CPrepFileInfo *tokenfile;
+    SInt32 tokenoffset;
+    SInt32 tokenline;
+    TData data;
+};
+
+struct TStream {
+    SInt32 tokens;
+    TStreamElement *firsttoken;
+};
+
+#endif
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
diff --git a/includes/compiler/types.h b/includes/compiler/types.h
new file mode 100644
index 0000000..9b07590
--- /dev/null
+++ b/includes/compiler/types.h
@@ -0,0 +1,324 @@
+#ifndef COMPILER_TYPES_H
+#define COMPILER_TYPES_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef enum TypeType {
+    TYPEVOID = 0,
+    TYPEINT,
+    TYPEFLOAT,
+    TYPEENUM,
+    TYPESTRUCT,
+    TYPECLASS,
+    TYPEFUNC,
+    TYPEBITFIELD,
+    TYPELABEL,
+    TYPETEMPLATE,
+    TYPEMEMBERPOINTER,
+    TYPEPOINTER,
+    TYPEARRAY,
+    TYPEOBJCID,
+    TYPETEMPLDEPEXPR,
+    TYPEILLEGAL = -1
+} TypeType;
+
+
+/// Common fields across all kinds of types
+struct Type {
+    TypeType type;
+    SInt32 size;
+};
+
+
+typedef enum IntegralType {
+    IT_BOOL = 0,
+    IT_CHAR = 1,
+    IT_SCHAR = 2,
+    IT_UCHAR = 3,
+    IT_WCHAR_T = 4,
+    IT_SHORT = 5,
+    IT_USHORT = 6,
+    IT_INT = 7,
+    IT_UINT = 8,
+    IT_LONG = 9,
+    IT_ULONG = 10,
+    IT_LONGLONG = 11,
+    IT_ULONGLONG = 12,
+    IT_FLOAT = 13,
+    IT_SHORTDOUBLE = 14,
+    IT_DOUBLE = 15,
+    IT_LONGDOUBLE = 16
+} IntegralType;
+
+struct TypeIntegral {
+    TypeType type;
+    SInt32 size;
+    unsigned char integral;
+};
+
+
+struct TypeEnum { // checked via CPrec
+    TypeType type;
+    SInt32 size;
+    NameSpace *nspace;
+    ObjEnumConst *enumlist;
+    Type *enumtype;
+    HashNameNode *enumname;
+};
+
+
+struct TypeStruct {
+    TypeType type;
+    SInt32 size;
+    HashNameNode *name;
+    StructMember *members;
+    char stype;
+    SInt16 align;
+};
+struct StructMember {
+    StructMember *next;
+    Type *type;
+    HashNameNode *name;
+    SInt32 offset;
+    UInt32 qual;
+};
+
+enum {
+    STRUCT_TYPE_STRUCT = 0,
+    STRUCT_TYPE_UNION = 1,
+    STRUCT_TYPE_4 = 4,
+    STRUCT_TYPE_5 = 5,
+    STRUCT_TYPE_6 = 6,
+    STRUCT_TYPE_7 = 7,
+    STRUCT_TYPE_8 = 8,
+    STRUCT_TYPE_9 = 9,
+    STRUCT_TYPE_A = 10,
+    STRUCT_TYPE_B = 11,
+    STRUCT_TYPE_C = 12,
+    STRUCT_TYPE_D = 13,
+    STRUCT_TYPE_E = 14
+};
+
+
+typedef struct ClassList { // checked via CPrec
+    struct ClassList *next;
+    TypeClass *base;
+    SInt32 offset;
+    SInt32 voffset;
+    AccessType access;
+    Boolean is_virtual;
+} ClassList;
+
+typedef struct VClassList { // checked via CPrec
+    struct VClassList *next;
+    TypeClass *base;
+    SInt32 offset;
+    SInt32 voffset;
+    Boolean has_override;
+    char alignsave;
+} VClassList;
+
+typedef struct ClassFriend { // checked via CPrec
+    struct ClassFriend *next;
+    union {
+        TypeClass *theclass;
+        Object *obj;
+    } u;
+    Boolean isclass;
+} ClassFriend;
+
+struct BClassList { // checked via CPrec
+    struct BClassList *next;
+    Type *type;
+};
+
+typedef struct VTable { // checked via CPrec
+    Object *object;
+    TypeClass *owner;
+    SInt32 offset;
+    SInt32 size;
+} VTable;
+
+struct TypeClass {
+    TypeType type;
+    SInt32 size;
+    NameSpace *nspace;
+    HashNameNode *classname;
+    ClassList *bases;
+    VClassList *vbases;
+    ObjMemberVar *ivars;
+    ClassFriend *friends;
+    VTable *vtable;
+    SOMInfo *sominfo;
+    ObjCInfo *objcinfo;
+    UInt16 flags;
+    SInt8 mode;
+    SInt8 action;
+    SInt16 align;
+    UInt8 eflags;
+};
+
+enum {
+    CLASS_FLAGS_2 = 2,
+    CLASS_FLAGS_20 = 0x20,
+    CLASS_FLAGS_100 = 0x100, // is TemplClass
+    CLASS_FLAGS_800 = 0x800, // is TemplClassInst
+    CLASS_FLAGS_900 = 0x900
+};
+
+
+typedef struct ExceptSpecList {
+    struct ExceptSpecList *next;
+    Type *type;
+    UInt32 qual;
+} ExceptSpecList;
+
+struct FuncArg { // ok
+    struct FuncArg *next;
+    HashNameNode *name;
+    ENode *dexpr;
+    Type *type;
+    UInt32 qual;
+    SInt16 sclass;
+    Boolean is_array;
+    Boolean has_defdefarg;
+};
+
+struct TypeFunc {
+    TypeType type;
+    SInt32 size;
+    FuncArg *args;
+    ExceptSpecList *exspecs;
+    Type *functype;
+    UInt32 qual;
+    UInt32 flags;
+};
+enum {
+    FUNC_FLAGS_PASCAL = 1, // on TypeFunc::flags
+    FUNC_FLAGS_METHOD = 0x10,
+    FUNC_FLAGS_40 = 0x40, // func that's like "operator SomeOtherType()"
+    FUNC_FLAGS_1000 = 0x1000,
+    FUNC_FLAGS_2000 = 0x2000,
+    FUNC_FLAGS_100000 = 0x100000,
+    FUNC_FLAGS_900000 = 0x900000
+};
+
+// There seems to be a version of this which adds a class pointer at the end
+struct TypeMethod {
+    TypeType type;
+    SInt32 size;
+    FuncArg *args;
+    ExceptSpecList *exspecs;
+    Type *functype;
+    UInt32 qual;
+    UInt32 flags;
+    TypeClass *theclass;
+    void *x1E;
+    void *x22;
+    Boolean x26;
+};
+
+
+struct TypeBitfield {
+    TypeType type;
+    SInt32 size;
+    Type *bitfieldtype;
+    unsigned char unkA;
+    char unkB;
+};
+
+
+// Label
+
+
+typedef enum TypeTemplDepType {
+    TEMPLDEP_ARGUMENT,
+    TEMPLDEP_QUALNAME,
+    TEMPLDEP_TEMPLATE,
+    TEMPLDEP_ARRAY,
+    TEMPLDEP_QUALTEMPL,
+    TEMPLDEP_BITFIELD,
+    TEMPLDEP_VALUEDEP, // not in v7?
+    TEMPLDEP_ENUMVAL, // not in v7?
+    TEMPLDEP_TYPEOF // not in v7?
+} TypeTemplDepType;
+
+struct TypeTemplDep {
+    TypeType type;
+    SInt32 size;
+    TypeTemplDepType dtype;
+    union {
+        TemplParamID pid;
+        struct {
+            TypeTemplDep *type;
+            HashNameNode *name;
+        } qual;
+        struct {
+            TemplClass *templ;
+            TemplArg *args;
+        } templ;
+        struct {
+            Type *type;
+            ENode *index;
+        } array;
+        struct {
+            TypeTemplDep *type;
+            TemplArg *args;
+        } qualtempl;
+        struct {
+            Type *type;
+            ENode *size;
+        } bitfield;
+        // the following ones may not be in v7
+        Type *vdep;
+        ENode *tof;
+        struct {
+            TypeEnum *etype;
+            ENode *expr;
+        } enumval;
+    } u;
+};
+
+
+struct TypeMemberPointer {
+    TypeType type;
+    SInt32 size;
+    Type *ty1;
+    Type *ty2;
+    UInt32 qual;
+};
+
+
+/// Used for TYPEPOINTER and TYPEARRAY
+struct TypePointer {
+    TypeType type;
+    SInt32 size;
+    Type *target;
+    UInt32 qual;
+};
+
+
+// ObjCID
+
+
+// Not sure if these existed originally, but they'll help
+#define TYPE_INTEGRAL(ty) ((TypeIntegral *) (ty))
+#define TYPE_ENUM(ty) ((TypeEnum *) (ty))
+#define TYPE_STRUCT(ty) ((TypeStruct *) (ty))
+#define TYPE_CLASS(ty) ((TypeClass *) (ty))
+#define TYPE_FUNC(ty) ((TypeFunc *) (ty))
+#define TYPE_METHOD(ty) ((TypeMethod *) (ty))
+#define TYPE_BITFIELD(ty) ((TypeBitfield *) (ty))
+#define TYPE_TEMPLATE(ty) ((TypeTemplDep *) (ty))
+#define TYPE_MEMBER_POINTER(ty) ((TypeMemberPointer *) (ty))
+#define TYPE_POINTER(ty) ((TypePointer *) (ty))
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif