honk

28 files changed, 3681 insertions, 38 deletions

diff --git a/includes/compiler/CABI.h b/includes/compiler/CABI.h
new file mode 100644
index 0000000..fde5b21
--- /dev/null
+++ b/includes/compiler/CABI.h
@@ -0,0 +1,39 @@
+#ifndef COMPILER_CABI_H
+#define COMPILER_CABI_H
+
+#include "compiler/common.h"
+#include "compiler/CDecl.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern short CABI_GetStructResultArgumentIndex(void);
+extern Type *CABI_GetSizeTType(void);
+extern Type *CABI_GetPtrDiffTType(void);
+extern SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size);
+extern void CABI_ReverseBitField(TypeBitfield *tbitfield);
+extern void CABI_AddVTable(TypeClass *tclass);
+extern SInt32 CABI_GetVTableOffset(TypeClass *tclass);
+extern void CABI_LayoutClass(DeclE *decle, TypeClass *tclass);
+extern void CABI_MakeDefaultArgConstructor(Object *obj, TypeClass *tclass);
+extern ENode *CABI_MakeThisExpr(TypeClass *tclass, SInt32 offset);
+extern SInt32 CABI_GetCtorOffsetOffset(TypeClass *tclass, TypeClass *base);
+extern Object *CABI_ConstructorCallsNew(TypeClass *tclass);
+typedef Statement *(*TransConstructorCallback)(Statement *stmt, TypeClass *tclass, TypeClass *base, SInt32 offset, Boolean flag);
+extern void CABI_TransConstructor(Object *obj, Statement *stmt, TypeClass *tclass, TransConstructorCallback callback, Boolean flag);
+extern void CABI_MakeDefaultConstructor(TypeClass *tclass, Object *obj);
+extern void CABI_MakeDefaultCopyConstructor(TypeClass *tclass, Object *obj);
+extern void CABI_MakeDefaultAssignmentOperator(TypeClass *tclass, Object *obj);
+extern void CABI_TransDestructor(Object *obj1, Object *obj2, Statement *stmt, TypeClass *tclass);
+extern void CABI_MakeDefaultDestructor(TypeClass *tclass, Object *obj);
+extern void CABI_MakeLayeredDestructor(TypeClass *tclass, Object *obj);
+extern Object *CABI_GetDestructorObject(Object *obj, int what);
+extern void CABI_AddLayeredDestructors(TypeClass *tclass);
+extern ENode *CABI_DestroyObject(Object *dtor, ENode *objexpr, UInt8 mode, Boolean flag1, Boolean flag2);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CClass.h b/includes/compiler/CClass.h
new file mode 100644
index 0000000..edefa92
--- /dev/null
+++ b/includes/compiler/CClass.h
@@ -0,0 +1,71 @@
+#ifndef COMPILER_CCLASS_H
+#define COMPILER_CCLASS_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct VTableObjectLink {
+    struct VTableObjectLink *next;
+    Object *methodobj;
+    SInt32 offset;
+    SInt32 xC;
+} VTableObjectLink;
+
+extern void CClass_Init(void);
+extern void CClass_GenThunks(void);
+extern UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag);
+extern Boolean CClass_IsEmpty(TypeClass *tclass);
+extern Boolean CClass_IsNonStaticMemberFunc(TypeMethod *tmethod);
+extern Object *CClass_DefaultConstructor(TypeClass *tclass);
+extern Object *CClass_DummyDefaultConstructor(TypeClass *tclass);
+extern ENode *CClass_DefaultConstructorCall(TypeClass *a, TypeClass *b, ENode *expr, SInt32 unkshortparam, Boolean flag1, Boolean flag2, Boolean *errorflag);
+extern Object *CClass_AssignmentOperator(TypeClass *tclass);
+extern Object *CClass_CopyConstructor(TypeClass *tclass);
+extern NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name);
+extern Object *CClass_Constructor(TypeClass *tclass);
+extern Object *CClass_Destructor(TypeClass *tclass);
+extern Boolean CClass_IsConstructor(Object *obj);
+extern Boolean CClass_IsDestructor(Object *obj);
+extern Boolean CClass_IsPODClass(TypeClass *tclass);
+extern Boolean CClass_IsTrivialCopyClass(TypeClass *tclass);
+extern Boolean CClass_IsTrivialCopyAssignClass(TypeClass *tclass);
+extern Boolean CClass_ReferenceArgument(TypeClass *tclass);
+extern BClassList *CClass_GetPathCopy(BClassList *path, Boolean is_global);
+extern BClassList *CClass_AppendPath(BClassList *a, BClassList *b);
+extern Boolean CClass_IsMoreAccessiblePath(BClassList *path1, BClassList *path2);
+extern BClassList *CClass_GetBasePath(TypeClass *a, TypeClass *b, short *founddepth, Boolean *isambigbase);
+extern Boolean CClass_IsBaseClass(TypeClass *a, TypeClass *b, short *founddepth, Boolean pathcheckflag, Boolean ambigerrorflag);
+extern TypeClass *CClass_GetQualifiedClass(void);
+extern ENode *CClass_AccessPathCast(BClassList *path, ENode *expr, Boolean flag);
+extern ENode *CClass_ClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean ambigerrorflag, Boolean pathcheckflag);
+extern ENode *CClass_DirectBasePointerCast(ENode *expr, TypeClass *a, TypeClass *b);
+extern SInt32 CClass_GetPathOffset(BClassList *path);
+extern Boolean CClass_ClassDominates(TypeClass *a, TypeClass *b);
+extern SInt32 CClass_VirtualBaseOffset(TypeClass *a, TypeClass *b);
+extern SInt32 CClass_VirtualBaseVTableOffset(TypeClass *a, TypeClass *b);
+extern SInt32 CClass_GetMemberOffset(TypeClass *tclass, HashNameNode *name, ObjMemberVar **obj);
+extern Boolean CClass_OverridesBaseMember(TypeClass *tclass, HashNameNode *name, Object *obj);
+extern void CClass_DefineCovariantFuncs(Object *method, CI_FuncData *ifuncdata);
+extern void CClass_CheckOverrides(TypeClass *tclass);
+extern void CClass_ClassDefaultFuncAction(TypeClass *tclass);
+extern void CClass_ClassAction(TypeClass *tclass);
+extern void CClass_MakeStaticActionClass(TypeClass *tclass);
+extern Object *CClass_CheckPures(TypeClass *tclass);
+extern void CClass_MemberDef(Object *obj, TypeClass *tclass);
+extern Object *CClass_ThisSelfObject(void);
+extern ENode *CClass_CreateThisSelfExpr(void);
+extern void CClass_CheckPathAccess(BClassList *path, Object *obj, AccessType access);
+extern void CClass_CheckStaticAccess(BClassList *path, TypeClass *tclass, AccessType access);
+extern void CClass_CheckObjectAccess(BClassList *path, Object *obj);
+extern void CClass_CheckEnumAccess(BClassList *path, ObjEnumConst *objec);
+extern Type *CClass_CombineClassAccessQualifiers(Type *type, UInt32 qual1, UInt32 qual2, UInt32 *outflags);
+extern ENode *CClass_AccessMember(ENode *classexpr, Type *type, UInt32 qual, SInt32 offset);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CDecl.h b/includes/compiler/CDecl.h
new file mode 100644
index 0000000..eda8669
--- /dev/null
+++ b/includes/compiler/CDecl.h
@@ -0,0 +1,127 @@
+#ifndef COMPILER_CDECL_H
+#define COMPILER_CDECL_H
+
+#include "compiler/common.h"
+#include "compiler/tokens.h"
+#include "compiler/types.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+// named because it's 0xE bytes big (hurr)
+typedef struct DeclE {
+    ObjBase **objlist;
+    void *x4;
+    unsigned short x8;
+    unsigned short xA;
+    Boolean xC;
+} DeclE;
+
+struct DeclInfo {
+    Type *thetype;
+    UInt32 qual;
+    NameSpace *nspace;
+    HashNameNode *name;
+    Object *x10;
+    NameSpaceObjectList *x14;
+    void *x18;
+    void *x1C;
+    Type *x20;
+    ENode *x24;
+    TemplClass *x28;
+    TemplArg *expltargs;
+    void *x30;
+    void *x34;
+    void *x38;
+    Boolean x3C;
+    Boolean x3D;
+    short x3E;
+    short storageclass;
+    UInt8 section;
+    UInt8 exportflags;
+    Boolean x44;
+    Boolean x45;
+    Boolean x46;
+    Boolean x47;
+    Boolean x48;
+    Boolean x49;
+    Boolean x4A;
+    Boolean x4B;
+    Boolean x4C;
+    Boolean x4D;
+    Boolean x4E;
+    Boolean x4F;
+    Boolean x50;
+    Boolean x51;
+    Boolean has_expltargs;
+    Boolean x53;
+    Boolean x54;
+    Boolean x55;
+    Boolean x56;
+    Boolean x57;
+    FileOffsetInfo fileoffsetinfo;
+};
+
+typedef struct BigDeclInfo {
+    DeclInfo declinfo;
+    DeclInfo declinfo2;
+    Boolean xCC;
+    Boolean xCD;
+} BigDeclInfo;
+
+extern AccessType global_access;
+extern FileOffsetInfo member_fileoffset;
+
+extern Type *CDecl_NewStructType(SInt32 size, SInt16 align);
+extern Type *CDecl_NewArrayType(Type *type, SInt32 size);
+extern Type *CDecl_NewPointerType(Type *type);
+extern Type *CDecl_NewRefPointerType(Type *type);
+extern Type *CDecl_NewTemplDepType(TypeTemplDepType tdt);
+extern void CDecl_SetResultReg(TypeFunc *tfunc);
+extern void CDecl_SetFuncFlags(TypeFunc *tfunc, UInt32 flags);
+extern void CDecl_NewConvFuncType(DeclInfo *declinfo);
+extern void CDecl_CompleteType(Type *type);
+extern Boolean IsCompleteType(Type *type);
+extern Boolean CanAllocObject(Type *type);
+extern Boolean CanCreateObject(Type *type);
+extern void makethetypepointer(DeclInfo *declinfo, UInt32 qual);
+extern void CDecl_AddThisPointerArgument(TypeFunc *tfunc, TypeClass *tclass);
+extern void CDecl_MakePTMFuncType(TypeFunc *tfunc);
+extern void CDecl_AddArgument(TypeFunc *tfunc, Type *argtype);
+extern Boolean CDecl_CheckArrayIntegr(Type *type);
+extern void CDecl_ParseDirectFuncDecl(DeclInfo *declinfo);
+extern void makememberpointertype(DeclInfo *declinfo, TypeClass *tclass, UInt32 qual);
+extern void CDecl_ScanPointer(DeclInfo *declinfo, NameSpace *nspace, Boolean flag);
+extern void scandeclarator(DeclInfo *declinfo);
+extern void conversion_type_name(DeclInfo *declinfo);
+extern void MergeDefaultArgs(FuncArg *a, FuncArg *b);
+extern void CheckDefaultArgs(FuncArg *args);
+extern Object *CDecl_GetFunctionObject(DeclInfo *declinfo, NameSpace *nspace, Boolean *pflag, Boolean someotherflag);
+extern void CDecl_TypedefDeclarator(DeclInfo *declinfo);
+extern Boolean CDecl_FunctionDeclarator(DeclInfo *declinfo, NameSpace *nspace, Boolean flag, Boolean flag2);
+extern void CDecl_ScanDeclarator(DeclInfo *declinfo);
+extern void scandeclaratorlist(DeclInfo *declinfo);
+extern void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum);
+extern void scanenum(DeclInfo *declinfo);
+extern void CDecl_ScanStructDeclarator(BigDeclInfo *bde);
+extern void scanstruct(DeclInfo *declinfo, short structtype);
+extern void CDecl_ExtractClassExportFlags(DeclInfo *declinfo, UInt8 flags);
+extern TypeMethod *CDecl_MakeTypeMemberFunc(TypeFunc *tfunc, TypeClass *tclass, Boolean flag);
+extern void CDecl_PackDeclInfo(PackedDeclInfo *packed, DeclInfo *declinfo);
+extern void CDecl_UnpackDeclInfo(DeclInfo *declinfo, PackedDeclInfo *packed);
+extern void CDecl_AddFriend(TypeClass *tclass, Object *friendfunc, TypeClass *friendclass);
+extern void CDecl_CheckCtorIntegrity(FuncArg *args, TypeClass *tclass);
+extern void CDecl_MakeVBaseList(TypeClass *tclass);
+extern Boolean CDecl_CheckNewBase(TypeClass *a, TypeClass *b, Boolean flag);
+extern TypeMethod *CDecl_MakeDefaultDtorType(TypeClass *tclass, Boolean is_virtual);
+extern void CDecl_CompleteClass(DeclE *decle, TypeClass *tclass);
+extern TypeClass *CDecl_DefineClass(NameSpace *nspace, HashNameNode *name, TypeClass *tclass, short mode, Boolean flag2, Boolean flag3);
+extern void CDecl_ParseClassDeclSpec(UInt8 *declspec);
+extern void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class_declspec);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CError.h b/includes/compiler/CError.h
index 89f67e4..dbe80c0 100644
--- a/includes/compiler/CError.h
+++ b/includes/compiler/CError.h
@@ -311,6 +311,11 @@ typedef struct _CErrorBuffer {
     UInt32 remaining;
 } CErrorBuffer;
 
+extern TStreamElement *cerror_locktoken;
+extern char cerror_synchdata[32];
+extern short cerror_synchoffset;
+extern int CError_BreakPointcount;
+
 extern void CError_Init();
 extern void CError_SetErrorToken(TStreamElement *token);
 extern void CError_SetNullErrorToken();
@@ -354,7 +359,7 @@ 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_Internal(char *filename, int line);
 extern void CError_ExpressionTooComplex();
 extern void CError_NoMem();
 extern void CError_UserBreak();
diff --git a/includes/compiler/CExpr.h b/includes/compiler/CExpr.h
new file mode 100644
index 0000000..a82e56e
--- /dev/null
+++ b/includes/compiler/CExpr.h
@@ -0,0 +1,237 @@
+#ifndef COMPILER_CEXPR_H
+#define COMPILER_CEXPR_H
+
+#include "compiler/common.h"
+#include "compiler/enode.h"
+#include "compiler/types.h"
+#include "compiler/CScope.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct ConIteratorList {
+    struct ConIteratorList *next;
+    struct ConIterator *iter;
+} ConIteratorList;
+
+typedef struct ConIterator {
+    struct ConIterator *parent;
+    ConIteratorList *children;
+    TypeClass *tclass;
+} ConIterator;
+
+typedef struct ConversionIterator {
+    CScopeObjectIterator objiter;
+    ConIterator myconiter;
+    ConIterator *coniter;
+} ConversionIterator;
+
+enum {
+    CheckResult0,
+    CheckResult1,
+    CheckResult2,
+    CheckResult3,
+    CheckResult4
+};
+
+// Rename me to StdMatch?
+typedef struct Match5 {
+    short x0;
+    short x2;
+    short x4;
+    short x6;
+    short x8;
+} Match5;
+
+typedef struct Match13 {
+    short x0;
+    short x2;
+    short x4;
+    short x6;
+    short x8;
+    short xA;
+    short xC;
+    short xE;
+    Match5 match5;
+} Match13;
+
+// CExpr.c
+extern Boolean (*name_obj_check)(void *, Object *); // TODO figure out the right type
+extern Boolean disallowgreaterthan;
+
+// CExpr2.c
+extern ENode *assign_node;
+extern Boolean temp_reference_init;
+
+// CExpr.c
+extern void CExpr_RewriteConst();
+extern void optimizecomm(ENode *expr);
+extern short canadd(ENode *expr, SInt32 value);
+extern ENode *checkreference(ENode *expr);
+extern ENode *pointer_generation(ENode *expr);
+extern void CExpr_PointerGeneration();
+extern void oldassignmentpromotion();
+extern ENode *argumentpromotion(ENode *expr, Type *type, short qual, Boolean flag);
+extern ENode *classargument(ENode *expr);
+extern ENodeList *CExpr_ScanExpressionList(Boolean flag);
+extern void CExpr_DoExplicitConversion();
+extern void CExpr_MakeNameLookupResultExpr();
+extern void scansizeof();
+extern void scanalignof();
+extern ENode *getnodeaddress(ENode *expr, Boolean flag);
+extern void getpointertomemberfunc();
+extern void CExpr_New_ELOGNOT_Node();
+extern void CExpr_New_EMONMIN_Node();
+extern void CExpr_New_EBINNOT_Node();
+extern ENode *unary_expression(void);
+extern ENode *do_castnullcheck(ENode *a, ENode *b);
+extern void CExpr_SafeClassPointerCast();
+extern ENode *PointerToMemberCast(ENode *expr, TypeMemberPointer *tm1, TypeMemberPointer *tm2, Boolean flag);
+extern void CExpr_MemberPointerConversion();
+extern ENode *do_typecast(ENode *expr, Type *type, UInt32 qual);
+extern void cast_expression();
+extern void CExpr_New_EMUL_Node();
+extern void CExpr_New_EDIV_Node();
+extern void CExpr_New_EMODULO_Node();
+extern void CExpr_New_EADD_Node();
+extern void CExpr_New_ESUB_Node();
+extern void CExpr_New_ESHL_Node();
+extern void CExpr_New_ESHR_Node();
+extern void CExpr_New_ELESS_Node();
+extern void CExpr_New_ELESSEQU_Node();
+extern void CExpr_New_EGREATER_Node();
+extern void CExpr_New_EGREATEREQU_Node();
+extern ENode *memberpointercompare(ENodeType t, ENode *left, ENode *right);
+extern void CExpr_New_EEQU_Node();
+extern void CExpr_New_ENOTEQU_Node();
+extern void CExpr_New_EAND_Node();
+extern void CExpr_New_EXOR_Node();
+extern void CExpr_New_EOR_Node();
+extern void CExpr_New_ELAND_Node();
+extern void CExpr_New_ELOR_Node();
+extern void CExpr_NewDyadicNode();
+extern void CExpr_New_ECOND_Node();
+extern ENode *assignment_expression(void);
+extern ENode *conv_assignment_expression(void);
+extern void CExpr_CheckUnusedExpression();
+extern void s_expression();
+extern ENode *expression(void);
+extern CInt64 CExpr_IntegralConstExprType(Type **tint);
+extern ENode *CExpr_IntegralConstOrDepExpr(void);
+extern CInt64 CExpr_IntegralConstExpr(void);
+extern void CExpr_CheckUnwantedAssignment();
+extern void CExpr_ParseAsmExpr();
+
+// CExpr2.c
+typedef void (*CExprSearchCB)(ENode *expr);
+typedef ENode *(*CExprReplaceCB)(ENode *expr);
+
+extern void CExpr_SearchExprTree(ENode *expr, CExprSearchCB callback, int count, ...);
+extern ENode *CExpr_SearchExprTreeReplace(ENode *expr, CExprReplaceCB callback, int count, ...);
+extern Boolean CExpr_HasFuncCall(ENode *expr);
+extern void CExpr_AliasTransform(ENode *expr);
+extern ENode *CExpr_UnaryFloatExpression(ENode *expr);
+extern ENode *CExpr_BinaryFloatExpression(ENode *expr);
+extern ENode *CExpr_NewENode(ENodeType ty);
+extern ENode *CExpr_NewTemplDepENode(TemplDepSubType t);
+extern ENode *nullnode(void);
+extern ENode *intconstnode(Type *type, SInt32 value);
+extern ENode *stringconstnode(char *str);
+extern ENode *forceintegral(ENode *expr);
+extern ENode *makemonadicnode(ENode *inner, ENodeType ty);
+extern ENode *makediadicnode(ENode *left, ENode *right, ENodeType ty);
+extern ENode *makecommaexpression(ENode *left, ENode *right);
+extern short iszero(ENode *expr);
+extern short isnotzero(ENode *expr);
+extern Boolean CExpr_IsOne(ENode *expr);
+extern Boolean CExpr_AllBitsSet(ENode *expr);
+extern ENode *CExpr_NewETEMPNode(Type *type, Boolean assign_id);
+extern ENode *CExpr_GetETEMPCopy(ENode *expr);
+extern ENode *integralpromote(ENode *expr);
+extern CInt64 CExpr_IntConstConvert(Type *a, Type *b, CInt64 val);
+extern ENode *promote(ENode *expr, Type *type);
+extern void CExpr_ArithmeticConversion(ENode **left, ENode **right);
+extern ENode *CExpr_TempModifyExpr(ENode *expr);
+extern Boolean CExpr_IsLValue(ENode *expr);
+extern ENode *CExpr_LValue(ENode *expr, Boolean flag1, Boolean flag2);
+extern ENode *CExpr_MakeObjRefNode(Object *obj, Boolean flag);
+extern ENode *create_objectrefnode(Object *obj);
+extern ENode *create_objectnode2(Object *obj);
+extern ENode *create_objectnode(Object *obj);
+extern ENode *CExpr_IsTempConstruction(ENode *expr, Type *type, ENode **resultexpr);
+extern ENode *CExpr_AdjustFunctionCall(ENode *expr);
+extern ENode *funccallexpr(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, ENode *arg4);
+extern ENode *CExpr_FuncCallSix(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, ENode *arg4, ENode *arg5, ENode *arg6);
+extern void CExpr_MatchCV(Type *t1, UInt32 q1, Type *t2, UInt32 q2, Match13 *match);
+extern Boolean CExpr_MatchAssign(Type *type, UInt32 qual, ENode *expr, Match13 *match);
+extern ENode *CExpr_ClassPointerCast(BClassList *cls, ENode *expr, Boolean nullcheckflag);
+extern ENode *CExpr_GetClassAccessNode(BClassList *a, BClassList *b, ENode *expr, Object *obj, AccessType access, Boolean flag);
+extern ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag);
+extern void CExpr_ConversionIteratorInit(ConversionIterator *iter, TypeClass *tclass);
+extern Object *CExpr_ConversionIteratorNext(ConversionIterator *iter);
+extern void user_assign_check();
+extern ENode *CExpr_ConvertToCondition(ENode *expr);
+extern void CExpr_ConvertToIntegral();
+extern void CExpr_CheckArithmConversion();
+extern void get_address_of_temp_copy();
+extern short assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2, Boolean flag3);
+extern void CExpr_MatchCompare();
+extern void CExpr_GetFuncMatchArgs();
+extern ENode *CExpr_GetDefaultArgument(ENode *funcexpr, FuncArg *arg);
+extern ENode *CExpr_VarArgPromotion(ENode *expr, Boolean flag);
+extern void CExpr_GenericFuncCall();
+extern void CExpr_GenericPtmfCall();
+extern void CExpr_MakeFunctionCall();
+extern void CExpr_CheckOperatorConversion();
+extern void CExpr_CheckOperator();
+extern ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *args, Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4, Boolean flag5);
+extern void scannew();
+extern void scandelete();
+
+// CExprConvMatch.c
+// static void CExpr_GetImplictObjectParamType();
+// static void CExpr_GetParamType();
+// static void CExpr_HasNParams();
+// static void CExpr_TypeCompare();
+// static void CExpr_IsReferenceCompatible();
+// static void CExpr_IsBaseOf();
+// static void CExpr_IsBetterClassConversion();
+// static void CExpr_IsBetterStandardConv();
+// static void CExpr_IsBetterImplicitConv();
+// static void CExpr_SetupStandardConversionResult();
+// static void CExpr_SetQualConversionResult();
+// static void CExpr_OverloadFuncMatch();
+// static void CExpr_StandardConversionMatch();
+// static void CExpr_UserConversion();
+// static void CExpr_UserConversionMatch();
+// static void CExpr_ImplicitConversionMatch();
+extern Boolean CExpr_CanImplicitlyConvert(ENode *expr, Type *type, UInt32 qual);
+// static void CExpr_DerivedToBase();
+// static void CExpr_ClassReferenceConversion();
+// static void CExpr_BindToReference();
+extern ENode *CExpr_Convert(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2);
+extern ENode *CExpr_AssignmentPromotion(ENode *expr, Type *type, UInt32 qual, Boolean flag);
+// static void CExpr_IsBetterMatch();
+// static void CExpr_MatchArgs();
+// static void CExpr_GetMatchObject();
+// static void CExpr_FindBestMatch();
+extern void CExpr_FuncArgMatch();
+// static void CExpr_BuildConversionTypeList();
+// static void CExpr_NextPromotedIntegralType();
+// static void CExpr_NextArithmeticType();
+// static void CExpr_NextPromotedArithmeticType();
+// static void CExpr_MatchBuiltin();
+// static void CExpr_CheckIncDecBuiltin();
+// static void CExpr_CheckUnaryBuiltin();
+// static void CExpr_CheckBinaryBuiltin();
+// static void CExpr_MatchOperands();
+extern void CExpr_CondOperatorMatch();
+extern void CExpr_OperatorMatch();
+// static void CExpr_ClassCopyInit();
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CFunc.h b/includes/compiler/CFunc.h
new file mode 100644
index 0000000..2247e5e
--- /dev/null
+++ b/includes/compiler/CFunc.h
@@ -0,0 +1,147 @@
+#ifndef COMPILER_CFUNC_H
+#define COMPILER_CFUNC_H
+
+#include "compiler/common.h"
+#include "compiler/CScope.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct DeclBlock {
+    struct DeclBlock *next;
+    ExceptionAction *dobjstack; // is type right?
+    NameSpace *parent_nspace;
+    short index;
+} DeclBlock;
+
+struct CLabel {
+    CLabel *next;
+    Statement *stmt;
+    HashNameNode *uniquename;
+    HashNameNode *name;
+    PCodeLabel *pclabel;
+    //void *sicg_label;
+};
+
+typedef enum StatementType {
+    ST_NOP = 1,
+    ST_LABEL,
+    ST_GOTO,
+    ST_EXPRESSION,
+    ST_SWITCH,
+    ST_IFGOTO,
+    ST_IFNGOTO,
+    ST_RETURN,
+    ST_OVF,
+    ST_EXIT,
+    ST_ENTRY,
+    ST_BEGINCATCH,
+    ST_ENDCATCH,
+    ST_ENDCATCHDTOR,
+    ST_GOTOEXPR,
+    ST_ASM,
+    ST_BEGINLOOP,
+    ST_ENDLOOP,
+    ST_ILLEGAL
+} StatementType;
+
+enum {
+    StmtFlag_1 = 1
+};
+
+struct Statement {
+    Statement *next;
+    StatementType type;
+    char marked;
+    UInt8 flags;
+    UInt16 value;
+    ENode *expr;
+    CLabel *label;
+    ExceptionAction *dobjstack;
+    SInt32 sourceoffset;
+    HashNameNode *sourcefilepath;
+};
+
+typedef struct InitExpr {
+    struct InitExpr *next;
+    ENode *expr;
+    Object *object;
+} InitExpr;
+
+typedef struct CtorChain {
+    struct CtorChain *next;
+    UInt8 what;
+    ENode *objexpr;
+    union {
+        ClassList *base; // 0
+        VClassList *vbase; // 1
+        ObjMemberVar *membervar; // 2
+    } u;
+} CtorChain;
+
+typedef struct CFuncSave {
+    CScopeSave scope;
+    // lots of fields
+} CFuncSave;
+
+struct DeclThing {
+    Type *thetype;
+    UInt32 qual;
+    NameSpace *nspace;
+    CLabel *xC;
+    CLabel *x10;
+};
+
+extern FuncArg elipsis;
+extern FuncArg oldstyle;
+extern ObjectList *arguments;
+extern ObjectList *locals;
+extern short localcount;
+extern SInt32 curstmtvalue;
+extern SInt32 sourceoffset;
+extern HashNameNode *sourcefilepath;
+extern SInt32 functionbodyoffset;
+extern HashNameNode *functionbodypath;
+extern InitExpr *init_expressions;
+extern CLabel *Labels;
+extern CtorChain *ctor_chain;
+extern Statement *curstmt;
+
+extern DeclBlock *CFunc_NewDeclBlock(void);
+extern void CFunc_RestoreBlock(DeclBlock *block);
+extern void CFunc_SetupLocalVarInfo(Object *obj);
+extern void CFunc_DefaultArg(Type *type, short qual, FuncArg *args);
+extern Boolean CFunc_ParseFakeArgList(Boolean flag);
+extern FuncArg *parameter_type_list(DeclInfo *declinfo);
+extern CLabel *findlabel(void);
+extern CLabel *newlabel(void);
+extern Statement *CFunc_AppendStatement(StatementType sttype);
+extern Statement *CFunc_InsertStatement(StatementType sttype, Statement *after);
+extern Statement *CFunc_InsertBeforeStatement(StatementType sttype, Statement *before);
+extern void CheckCLabels(void);
+extern Object *create_temp_object(Type *type);
+extern ENode *create_temp_node(Type *type);
+extern ENode *create_temp_node2(Type *type);
+extern void CFunc_WarnUnused(void);
+extern void CFunc_CodeCleanup(Statement *stmt);
+extern void CFunc_DestructorCleanup(Statement *stmt);
+extern Statement *CFunc_GenerateLoop(Statement *stmt, Type *type, ENode *expr1, ENode *expr2, ENode *expr3, ENode *expr4, ENode (*callback)(ENode *, ENode *));
+extern void CFunc_CompoundStatement(DeclThing *thing);
+extern void CFunc_SetupNewFuncArgs(Object *obj, FuncArg *args);
+extern NameSpace *CFunc_FuncGenSetup(Statement *stmt);
+extern void CFunc_GetGlobalCompilerState(CFuncSave *state);
+extern void CFunc_SetGlobalCompilerState(CFuncSave *state);
+extern void CFunc_Gen(Statement *stmt, Object *obj, UInt8 unk);
+extern void CFunc_CheckClassCtors(TypeClass *tclass);
+extern void CFunc_ParseFuncDef(Object *obj, DeclInfo *declinfo, TypeClass *tclass, Boolean is_method, Boolean is_static, NameSpace *nspace);
+extern void InitExpr_Register(ENode *expr, Object *object);
+extern void CFunc_GenerateDummyFunction(Object *a);
+extern void CFunc_GenerateSingleExprFunc(Object *a, ENode *expr);
+extern void CFunc_GenerateDummyCtorFunc(Object *a, Object *b);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CInit.h b/includes/compiler/CInit.h
new file mode 100644
index 0000000..9b1c24b
--- /dev/null
+++ b/includes/compiler/CInit.h
@@ -0,0 +1,77 @@
+#ifndef COMPILER_CINIT_H
+#define COMPILER_CINIT_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef void (*ExprCB)(Type *type, ENode *expr, Boolean flag);
+typedef void (*InitExprRegisterCB)(ENode *expr);
+typedef void (*InsertExprCB)(ENode *expr);
+// fix last arg
+typedef ENode *(*RegisterObjectCB)(Type *type, Object *obj, SInt32 offset, void *);
+typedef ENode *(*TempNodeCB)(Type *type, Boolean flag);
+
+typedef struct OLinkList {
+    struct OLinkList *next;
+    Object *obj;
+    SInt32 offset;
+    SInt32 somevalue;
+} OLinkList;
+
+typedef struct PooledString {
+    struct PooledString *next;
+    Object *obj;
+    int offset;
+    char *data;
+    SInt32 size;
+    Boolean ispascal;
+    Boolean iswide;
+} PooledString;
+
+typedef struct InitInfo {
+    Object *obj;
+    OLinkList *list;
+    void *x8;
+    SInt32 expr_offset;
+    ExprCB expr_cb;
+    Boolean expr_cb_called;
+    Boolean x15;
+    Boolean x16;
+    InitExprRegisterCB init_expr_register_cb;
+    Object *obj1C;
+    InsertExprCB insert_expr_cb;
+    RegisterObjectCB register_object_cb;
+    char *buffer;
+    SInt32 size;
+    SInt32 bufferSize;
+    struct InitInfo *next;
+} InitInfo;
+
+extern TempNodeCB cinit_tempnodefunc;
+extern InitInfo *cinit_initinfo;
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+extern void CInit_Init(void);
+extern Boolean CInit_RelocInitCheck(ENode *expr, Object **objptr, CInt64 *valptr, Boolean flag);
+extern void CInit_ExportConst(Object *obj);
+extern Statement *CInit_ConstructClassArray(Statement *stmt, TypeClass *tclass, Object *ctor, Object *dtor, ENode *firstarg, SInt32 count);
+extern ENode *CInit_AutoObject(Object *obj, Type *type, UInt32 qual);
+extern void CInit_InitializeAutoData(Object *obj, InsertExprCB insert_cb, RegisterObjectCB register_cb);
+extern void CInit_InitializeStaticData(Object *obj, InitExprRegisterCB cb);
+extern void CInit_InitializeData(Object *obj);
+extern Object *CInit_DeclareString(char *data, SInt32 size, Boolean ispascal, Boolean iswide);
+extern PooledString *CInit_DeclarePooledString(char *data, SInt32 size, Boolean ispascal);
+extern PooledString *CInit_DeclarePooledWString(char *data, SInt32 size);
+extern void CInit_RewriteString(ENode *expr, Boolean flag);
+extern void CInit_DeclarePooledStrings(void);
+extern void CInit_DeclareData(Object *obj, void *data, OLinkList *list, SInt32 size);
+extern void CInit_DeclareReadOnlyData(Object *obj, void *data, OLinkList *list, SInt32 size);
+extern void CInit_DefineTentativeData(void);
+
+#endif
diff --git a/includes/compiler/CInline.h b/includes/compiler/CInline.h
new file mode 100644
index 0000000..1b5abd5
--- /dev/null
+++ b/includes/compiler/CInline.h
@@ -0,0 +1,121 @@
+#ifndef COMPILER_CINLINE_H
+#define COMPILER_CINLINE_H
+
+#include "compiler/common.h"
+#include "compiler/tokens.h"
+#include "compiler/CFunc.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct CI_Var {
+    HashNameNode *name;
+    Type *type;
+    UInt32 qual;
+    UInt8 sflags;
+    UInt8 xD;
+    UInt8 xE;
+} CI_Var;
+
+typedef struct CI_Switch {
+    int fix_me;
+} CI_Switch;
+
+typedef struct CI_Statement {
+    StatementType type;
+    UInt8 flags;
+    UInt16 value;
+    SInt32 sourceoffset;
+    HashNameNode *sourcefilepath;
+    ExceptionAction *dobjstack;
+    union {
+        SInt16 statementnum;
+        ENode *expr;
+        struct {
+            ENode *expr;
+            SInt16 statementnum;
+        } ifgoto;
+        CI_Switch *switchdata;
+        // TODO: Figure out the one for Inline ASM
+    } u;
+} CI_Statement;
+
+struct CI_FuncData {
+    short numarguments;
+    CI_Var *arguments;
+    short numlocals;
+    CI_Var *locals;
+    short numstatements;
+    CI_Statement *statements;
+    FileOffsetInfo fileoffset;
+    SInt32 symdecloffset;
+    SInt32 functionbodyoffset;
+    HashNameNode *functionbodypath;
+    SInt32 symdeclend;
+    Boolean can_inline;
+};
+
+typedef enum {
+    CI_ActionInlineFunc = 0,
+    CI_ActionMemberFunc = 1,
+    CI_ActionTemplateFunc = 2,
+    CI_ActionDefaultFunc = 3
+} CI_ActionType;
+
+typedef struct CI_Action {
+    struct CI_Action *next;
+    Object *obj;
+    union {
+        struct {
+            FileOffsetInfo fileoffset;
+            TStream stream;
+            TypeClass *tclass;
+            CI_ActionType actiontype;
+        } inlinefunc;
+        struct {
+            Type *a;
+            Type *b;
+            TemplateMember *tmemb;
+        } memberfunc;
+        struct {
+            TemplateFunction *func;
+            TemplFuncInstance *inst;
+        } templatefunc;
+    } u;
+} CI_Action;
+
+typedef enum {
+    CopyMode0,
+    CopyMode1,
+    CopyMode2,
+    CopyMode3,
+    CopyMode4
+} CInlineCopyMode;
+
+extern CI_Action *cinline_tactionlist;
+
+extern void CInline_Init(void);
+extern SInt32 CInline_GetLocalID(Object *obj);
+extern Boolean CInline_ExpressionHasSideEffect(ENode *expr);
+extern ENode *CInline_CopyExpression(ENode *expr, CInlineCopyMode mode);
+extern void CInline_SerializeStatement(Statement *stmt);
+extern Object *CInline_GetLocalObj(SInt32 id, Boolean flag);
+extern SInt32 CInline_GetStatementNumber(Statement *first, Statement *stmt);
+extern void CInline_PackIFunctionData(CI_FuncData *packed, Statement *stmt, Object *obj);
+extern void CInline_UnpackIFunctionData(Object *obj, CI_FuncData *packed, Statement *stmt);
+extern void CInline_AddDefaultFunctionAction(Object *obj);
+extern void CInline_AddInlineFunctionAction(Object *obj, TypeClass *tclass, FileOffsetInfo *fileoffset, TStream *stream, Boolean flag);
+extern void CInline_AddMemberFunctionAction(Object *obj, Type *a, Type *b, TemplateMember *tmemb);
+extern void CInline_AddTemplateFunctionAction(Object *obj, TemplateFunction *func, TemplFuncInstance *inst);
+extern void CInline_ObjectAddrRef(Object *obj);
+extern void CInline_GenFunc(Statement *stmt, Object *obj, UInt8 unk);
+extern Boolean CInline_CanFreeLHeap(void);
+extern Boolean CInline_GenerateDeferredFuncs(void);
+extern void CInline_Finish(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CInt64.h b/includes/compiler/CInt64.h
index 455bf3f..7986a4a 100644
--- a/includes/compiler/CInt64.h
+++ b/includes/compiler/CInt64.h
@@ -13,6 +13,10 @@ extern const CInt64 cint64_min;
 inline int CInt64_IsNegative(const CInt64 *n) {
     return (n->hi & 0x80000000) != 0;
 }
+inline UInt32 CInt64_GetULong(const CInt64 *n) { // 42E660 in mwcppc.exe
+    return n->lo;
+
+}
 inline void CInt64_SetLong(CInt64 *pN, SInt32 n) {
     pN->lo = n;
     pN->hi = (n < 0) ? 0xFFFFFFFF : 0;
@@ -22,7 +26,7 @@ inline void CInt64_SetULong(CInt64 *pN, UInt32 n) {
     pN->hi = 0;
 }
 
-inline int CInt64_IsZero(CInt64 *n) {
+inline Boolean CInt64_IsZero(CInt64 *n) {
     //if (n->hi == 0 && n->lo == 0)
     //    return 1;
     //else
diff --git a/includes/compiler/CMachine.h b/includes/compiler/CMachine.h
new file mode 100644
index 0000000..a4bc1a5
--- /dev/null
+++ b/includes/compiler/CMachine.h
@@ -0,0 +1,84 @@
+#ifndef COMPILER_CMACHINE_H
+#define COMPILER_CMACHINE_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern TypeIntegral stbool;
+extern TypeIntegral stchar;
+extern TypeIntegral stsignedchar;
+extern TypeIntegral stunsignedchar;
+extern TypeIntegral stwchar;
+extern TypeIntegral stsignedshort;
+extern TypeIntegral stunsignedshort;
+extern TypeIntegral stsignedint;
+extern TypeIntegral stunsignedint;
+extern TypeIntegral stsignedlong;
+extern TypeIntegral stunsignedlong;
+extern TypeIntegral stsignedlonglong;
+extern TypeIntegral stunsignedlonglong;
+extern TypeIntegral stfloat;
+extern TypeIntegral stshortdouble;
+extern TypeIntegral stdouble;
+extern TypeIntegral stlongdouble;
+
+extern TypeStruct stvectorunsignedchar;
+extern TypeStruct stvectorsignedchar;
+extern TypeStruct stvectorboolchar;
+extern TypeStruct stvectorunsignedshort;
+extern TypeStruct stvectorsignedshort;
+extern TypeStruct stvectorboolshort;
+extern TypeStruct stvectorunsignedlong;
+extern TypeStruct stvectorsignedlong;
+extern TypeStruct stvectorboollong;
+extern TypeStruct stvectorfloat;
+extern TypeStruct stvectorpixel;
+extern TypeStruct stvector;
+
+extern void CMach_Configure(void);
+extern SInt32 CMach_GetQUALalign(UInt32 qual);
+extern SInt32 CMach_ArgumentAlignment(Type *type);
+extern SInt32 CMach_AllocationAlignment(Type *type, UInt32 qual);
+extern CInt64 CMach_CalcIntDiadic(Type *type, CInt64 left, short op, CInt64 right);
+extern CInt64 CMach_CalcIntMonadic(Type *type, short op, CInt64 val);
+extern CInt64 CMach_CalcIntConvertFromFloat(Type *type, Float fval);
+extern void CMach_InitIntMem(Type *type, CInt64 val, void *mem);
+extern void CMach_InitVectorMem(Type *type, MWVector128 val, void *mem, Boolean flag);
+extern Float CMach_CalcFloatDiadic(Type *type, Float left, short op, Float right);
+extern Float CMach_CalcFloatMonadic(Type *type, short op, Float fval);
+extern Boolean CMach_CalcFloatDiadicBool(Type *type, Float left, short op, Float right);
+extern Boolean CMach_CalcVectorDiadicBool(Type *type, MWVector128 *left, short op, MWVector128 *right);
+extern char *CMach_FloatScan(char *input, Float *result, Boolean *fail);
+extern Float CMach_CalcFloatConvertFromInt(Type *type, CInt64 val);
+extern Float CMach_CalcFloatConvert(Type *type, Float fval);
+extern Boolean CMach_FloatIsZero(Float fval);
+extern Boolean CMach_FloatIsOne(Float fval);
+extern Boolean CMach_FloatIsNegOne(Float fval);
+extern void CMach_InitFloatMem(Type *type, Float val, void *mem);
+extern void CMach_PrintFloat(char *buf, Float val);
+extern void CMach_PragmaParams(void);
+extern void CMach_AdjustFuntionArgs(void);
+extern SInt16 CMach_GetStructAlign(TypeStruct *tstruct);
+extern SInt16 CMach_GetClassAlign(TypeClass *tclass);
+extern SInt16 CMach_GetTypeAlign(Type *type);
+extern SInt16 CMach_MemberAlignValue(Type *type, SInt32 var);
+extern void CMach_StructLayoutInitOffset(SInt32 offset);
+extern SInt32 CMach_StructLayoutGetCurSize(void);
+extern SInt32 CMach_StructLayoutGetOffset(Type *type, UInt32 qual);
+extern SInt32 CMach_StructLayoutBitfield(TypeBitfield *tbitfield, UInt32 qual);
+extern UInt8 CMach_GetFunctionResultClass(TypeFunc *tfunc);
+extern Boolean CMach_PassResultInHiddenArg(Type *type);
+extern const char *CMach_GetCPU(void);
+extern Boolean CMach_FloatIsPowerOf2(Float flt);
+extern Float CMach_FloatReciprocal(Float flt);
+extern SInt32 CMach_RoundedSizeOf(Object *object);
+extern void CMach_ReInitRuntimeObjects(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CMangler.h b/includes/compiler/CMangler.h
new file mode 100644
index 0000000..f08ecd8
--- /dev/null
+++ b/includes/compiler/CMangler.h
@@ -0,0 +1,35 @@
+#ifndef COMPILER_CMANGLER_H
+#define COMPILER_CMANGLER_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern HashNameNode *constructor_name_node;
+extern HashNameNode *destructor_name_node;
+extern HashNameNode *asop_name_node;
+
+extern void CMangler_Setup(void);
+extern HashNameNode *CMangler_BasicDtorName(void);
+extern HashNameNode *CMangler_VBaseDtorName(void);
+extern HashNameNode *CMangler_ArrayDtorName(void);
+extern HashNameNode *CMangler_SDeleteDtorName(void);
+extern HashNameNode *CMangler_DeleteDtorName(void);
+extern char *CMangler_GetOperator(HashNameNode *opname);
+extern HashNameNode *CMangler_OperatorName(short token);
+extern HashNameNode *CMangler_VTableName(TypeClass *tclass);
+extern HashNameNode *CMangler_RTTIObjectName(Type *type, UInt32 qual);
+extern HashNameNode *CMangler_ThunkName(Object *obj, int a, int b, int c);
+extern HashNameNode *CMangler_TemplateInstanceName(HashNameNode *basename, TemplArg *args);
+extern void CMangler_MangleType(Type *type, UInt32 qual);
+extern HashNameNode *CMangler_ConversionFuncName(Type *type, UInt32 qual);
+extern HashNameNode *CMangler_GetCovariantFunctionName(Object *obj, Type *type);
+extern HashNameNode *CMangler_GetLinkName(Object *obj);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CParser.h b/includes/compiler/CParser.h
new file mode 100644
index 0000000..21a3d59
--- /dev/null
+++ b/includes/compiler/CParser.h
@@ -0,0 +1,385 @@
+#ifndef COMPILER_CPARSER_H
+#define COMPILER_CPARSER_H
+
+#include "compiler/common.h"
+#include "compiler/enode.h"
+#include "compiler/tokens.h"
+#include "compiler/types.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+enum {
+    AlignMode0_Mac68k,
+    AlignMode1_Mac68k4byte,
+    AlignMode2_PPC,
+    AlignMode3_1Byte,
+    AlignMode4_2Byte,
+    AlignMode5_4Byte,
+    AlignMode6_8Byte,
+    AlignMode7_16Byte,
+    AlignMode8_Packed
+};
+
+// not sure how many of these are char and how many are unsigned char or Boolean
+typedef struct COpts {
+    Boolean little_endian;
+    Boolean codegen_dynamic;
+    Boolean codegen_pic;
+    Boolean no_common;
+    char no_implicit_templates;
+    char absolutepath; // determines the path written to debug info
+    char x06; // linker/objgen related
+    short cpu;
+    char schedule_cpu;
+    unsigned char schedule_mode; // may be an enum??
+    SInt32 debuglisting;
+    char profile;
+    char traceback;
+    Boolean disable_registers;
+    char fp_contract;
+    Boolean no_register_save_helpers;
+    char ppc_unroll_speculative;
+    short ppc_unroll_instructions_limit;
+    short ppc_unroll_factor_limit;
+    Boolean altivec_model;
+    UInt8 x1B; // altivec/vrsave related
+    UInt8 code_alignment;
+    char x1D;
+    UInt8 x1E; // some register used in TOC_use_isel
+    UInt8 gen_fsel;
+    char ppc_opt_bclr_bcctr;
+    Boolean use_lmw_stmw;
+    char report_heap_info;
+    char misaligned_mem_access;
+    char switch_tables;
+    char prepare_compress;
+    char some_alignment; // used in CMach_AllocationAlignment
+    Boolean asmsemicolcomment;
+    Boolean asmpoundcomment;
+    StringPtr oldprefixname;
+    short inlinelevel;
+    int inline_max_size;
+    int inline_max_total_size;
+    char inline_bottom_up;
+    Boolean cplusplus;
+    Boolean ecplusplus;
+    Boolean objective_c;
+    char objc_strict;
+    Boolean ARM_conform;
+    char ARM_scoping;
+    Boolean require_prototypes;
+    Boolean trigraphs;
+    Boolean only_std_keywords;
+    Boolean enumsalwaysint;
+    Boolean ANSI_strict;
+    Boolean mpwc_relax;
+    Boolean mpwc_newline;
+    Boolean ignore_oldstyle;
+    Boolean cpp_extensions;
+    Boolean pointercast_lvalue;
+    char useRTTI;
+    char delete_exception;
+    char _4B;
+    Boolean oldalignment;
+    Boolean unsignedchars;
+    Boolean multibyteaware;
+    char autoinline;
+    char defer_codegen;
+    Boolean direct_to_som;
+    char som_env_check;
+    char som_call_opt;
+    Boolean booltruefalse;
+    char old_enum_mangler;
+    Boolean longlong;
+    Boolean longlong_enums;
+    char no_tfuncinline;
+    char _59;
+    Boolean flat_include;
+    char syspath_once;
+    Boolean always_import;
+    char simple_class_byval;
+    Boolean wchar_type;
+    Boolean vbase_ctor_offset;
+    char vbase_abi_v2;
+    Boolean def_inherited;
+    char template_patch;
+    char template_friends;
+    char faster_pch_gen;
+    Boolean array_new_delete;
+    Boolean dollar_identifiers;
+    char def_inline_tfuncs;
+    char arg_dep_lookup;
+    Boolean simple_prepdump;
+    char line_prepdump;
+    char fullpath_prepdump;
+    char old_mtemplparser;
+    char suppress_init_code;
+    Boolean reverse_bitfields;
+    Boolean c9x;
+    Boolean float_constants;
+    Boolean no_static_dtors;
+    Boolean longlong_prepeval;
+    Boolean const_strings;
+    char dumpir;
+    char experimental;
+    Boolean gcc_extensions;
+    char stdc_fp_contract;
+    char stdc_fenv_access;
+    char stdc_cx_limitedr;
+    Boolean old_argmatch;
+    char optEH;
+    char optEH2;
+    Boolean new_mangler;
+    char microsoft;
+    Boolean warningerrors;
+    Boolean pedantic;
+    char check_header_flags;
+    Boolean supress_warnings;
+    Boolean warn_illpragma;
+    Boolean warn_emptydecl;
+    char warn_possunwant;
+    char warn_unusedvar;
+    char warn_unusedarg;
+    Boolean warn_extracomma;
+    char warn_hidevirtual;
+    Boolean warn_largeargs;
+    char warn_implicitconv;
+    char warn_notinlined;
+    Boolean warn_structclass;
+    Boolean warn_padding;
+    char warn_no_side_effect;
+    char warn_resultnotused;
+    char warn_ptr_int_conv;
+    char align_mode;
+    Boolean align_array_members;
+    Boolean dont_reuse_strings;
+    Boolean pool_strings;
+    Boolean explicit_zero_data;
+    Boolean readonly_strings;
+    Boolean exceptions;
+    char _99;
+    char dont_inline;
+    char always_inline;
+    Boolean peephole;
+    char global_optimizer;
+    char side_effects;
+    Boolean internal;
+    Boolean import;
+    Boolean export;
+    Boolean lib_export;
+    char nosyminline;
+    char force_active;
+    char optimizationlevel;
+    Boolean optimize_for_size;
+    char optimizewithasm;
+    Boolean crippled;
+    char opt_common_subs;
+    char opt_loop_invariants;
+    char opt_propagation;
+    char opt_dead_assignments;
+    char opt_strength_reduction;
+    char opt_strength_reduction_strict;
+    char opt_dead_code;
+    char opt_lifetimes;
+    char _B1; // unused?
+    char opt_unroll_loops;
+    char opt_vectorize_loops;
+    char _B4; // amount of IRO passes?
+    char opt_pointer_analysis;
+    char opt_pointer_analysis_mode;
+    char loop_unroll_count;
+    char loop_unroll_size_threshold;
+    Boolean isGeneratingDebugInfo;
+    CWDataType pchCreator;
+    CWDataType pchType;
+    CWDataType text;
+    HashNameNode *forcedSegment; // when set by #pragma segment
+} COpts;
+
+typedef struct ParserTryBlock {
+    struct ParserTryBlock *next;
+    jmp_buf jmpbuf;
+    NameSpace *cscope_current;
+    TypeClass *cscope_currentclass;
+    Object *cscope_currentfunc;
+    TemplStack *ctempl_curinstance;
+    TStreamElement *cerror_locktoken;
+    Boolean cscope_is_member_func;
+} ParserTryBlock;
+
+typedef struct CallbackAction {
+    struct CallbackAction *next;
+    Object *obj;
+    TypeClass *tclass;
+} CallbackAction;
+
+extern FileOffsetInfo cparser_fileoffset;
+extern TStreamElement symdecltoken;
+extern ParserTryBlock *trychain;
+extern Boolean inassembler;
+extern Boolean dont_set_references;
+extern TypeStruct ptmstruct;
+extern TypeStruct catchinfostruct;
+extern Boolean in_assembler;
+extern Boolean illegalimplicitconversion;
+extern Boolean in_func_arglist;
+extern NameSpaceName *newp_fobj;
+extern NameSpaceName *newa_fobj;
+extern NameSpaceName *delp_fobj;
+extern NameSpaceName *dela_fobj;
+extern Object *newh_func;
+extern Object *delh_func;
+extern Object *copy_func;
+extern Object *clear_func;
+extern Object *Rgtid_func;
+extern Object *Rdync_func;
+extern Object *rt_ptmf_cast;
+extern Object *rt_ptmf_cmpr;
+extern Object *rt_ptmf_test;
+extern Object *rt_ptmf_call;
+extern Object *rt_ptmf_scall;
+extern Object *rt_ptmf_call4;
+extern Object *rt_ptmf_scall4;
+extern Object *rt_ptmf_null;
+extern Object *rt_som_new;
+extern Object *rt_som_newcheck;
+extern Object *rt_som_check;
+extern Object *rt_som_glue1;
+extern Object *rt_som_glue2;
+extern Object *rt_som_glue3;
+extern Object *carr_func;
+extern Object *cnar_func;
+extern Object *darr_func;
+extern Object *dnar_func;
+extern Object *dnar3_func;
+extern Object *Xgreg_func;
+extern Object *Xthrw_func;
+extern Object *Xicth_func;
+extern Object *Xecth_func;
+extern Object *Xunex_func;
+extern COpts copts;
+extern struct GList name_mangle_list;
+extern HashNameNode *no_name_node;
+extern HashNameNode *temp_argument_name;
+extern HashNameNode *this_name_node;
+extern HashNameNode *self_name_node;
+extern HashNameNode *vptr_name_node;
+extern CallbackAction *callbackactions;
+extern Boolean fatalerrors;
+extern Boolean anyerrors;
+extern jmp_buf errorreturn;
+extern char string[256];
+extern SInt32 compilererrornum;
+extern SInt32 compilererrfile;
+extern SInt32 compilererrline;
+
+extern Type sttemplexpr;
+extern Type stillegal;
+extern Type stvoid;
+extern TypePointer void_ptr;
+extern TypeFunc rt_func;
+
+enum {
+    ATOM_VOID = 1,
+    ATOM_CHAR,
+    ATOM_UCHAR,
+    ATOM_WCHAR,
+    ATOM_SHORT,
+    ATOM_USHORT,
+    ATOM_INT,
+    ATOM_UINT,
+    ATOM_LONG,
+    ATOM_ULONG,
+    ATOM_LONGLONG,
+    ATOM_ULONGLONG,
+    ATOM_FLOAT,
+    ATOM_SHORTDOUBLE,
+    ATOM_DOUBLE,
+    ATOM_LONGDOUBLE
+};
+
+extern Object *CParser_NewRTFunc(Type *rettype, HashNameNode *name, Boolean flag, int argcount, ...);
+extern Boolean CParser_IsPublicRuntimeObject(Object *obj);
+extern Object *CParser_FindPublicRuntimeObject(HashNameNode *name);
+extern Boolean CParser_ReInitRuntimeObjects(Boolean is_precompiler);
+extern void CParser_Setup(void);
+extern void CParser_Cleanup(void);
+extern short GetPrec(short token);
+extern Boolean CParser_ParseOperatorName(short *token, Boolean flag1, Boolean flag2);
+extern SInt32 CParser_GetUniqueID(void);
+extern void CParser_PrintUniqueID(char *buf);
+extern void CParser_SetUniqueID(SInt32 id);
+extern HashNameNode *CParser_GetUniqueName(void);
+extern HashNameNode *CParser_NameConcat(char *a, char *b);
+extern HashNameNode *CParser_AppendUniqueName(char *prefix);
+extern HashNameNode *CParser_AppendUniqueNameFile(char *prefix);
+extern Boolean IsTempName(HashNameNode *name);
+extern void CParser_UpdateObject(Object *object, DeclInfo *declinfo);
+extern Object *CParser_NewObject(DeclInfo *declinfo);
+extern Object *CParser_NewLocalDataObject(DeclInfo *declinfo, Boolean add_to_locals);
+extern Object *CParser_NewGlobalDataObject(DeclInfo *declinfo);
+extern Object *CParser_NewCompilerDefDataObject(void);
+extern Object *CParser_NewFunctionObject(DeclInfo *declinfo);
+extern Object *CParser_NewCompilerDefFunctionObject(void);
+extern Object *CParser_NewAliasObject(Object *object, SInt32 offset);
+extern FuncArg *CParser_NewFuncArg(void);
+extern Type *atomtype(void);
+extern Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1, Boolean flag2, Boolean *outflag);
+extern short is_memberpointerequal(Type *a, Type *b);
+extern short is_typeequal(Type *a, Type *b);
+extern short iscpp_typeequal(Type *a, Type *b);
+extern short CParser_CompareArgLists(FuncArg *a, FuncArg *b);
+extern Boolean is_arglistsame(FuncArg *a, FuncArg *b);
+extern short is_typesame(Type *a, Type *b);
+extern Type *CParser_GetBoolType(void);
+extern Type *CParser_GetWCharType(void);
+extern short CParser_GetOperator(ENodeType t);
+extern Boolean CParser_IsMoreCVQualified(UInt32 a, UInt32 b);
+extern Boolean CParser_IsSameOrMoreCVQualified(UInt32 a, UInt32 b);
+extern Boolean is_unsigned(Type *type);
+extern StructMember *ismember(TypeStruct *tstruct, HashNameNode *name);
+extern void appendmember(TypeStruct *tstruct, StructMember *member);
+extern Boolean isdeclaration(UInt8 flag1, UInt8 flag2, UInt8 flag3, short token);
+extern Boolean islookaheaddeclaration(void);
+extern Type *CParser_ParseTypeID(UInt32 *qual, Boolean *flag);
+extern Boolean CParser_TryFuncDecl(void);
+extern Boolean CParser_TryParamList(Boolean flag);
+extern Type *CParser_RemoveTopMostQualifiers(Type *type, UInt32 *qual);
+extern UInt32 CParser_GetTypeQualifiers(Type *type, UInt32 qual);
+extern UInt32 CParser_GetCVTypeQualifiers(Type *type, UInt32 qual);
+extern Boolean CParser_IsConst(Type *type, UInt32 qual);
+extern Boolean CParser_IsVolatile(Type *type, UInt32 qual);
+extern Boolean is_const_object(Object *obj);
+extern Boolean is_volatile_object(Object *obj);
+extern Boolean CParserIsConstExpr(ENode *expr);
+extern Boolean CParserIsVolatileExpr(ENode *expr);
+extern Boolean CParser_HasInternalLinkage(Object *obj);
+extern Boolean CParser_HasInternalLinkage2(Object *obj);
+extern Boolean CParser_IsVirtualFunction(Object *obj, TypeClass **tclass, SInt32 *index);
+extern Boolean is_pascal_object(Object *obj);
+extern Boolean is_cfm_type(Type *type);
+extern Boolean CParser_IsVTableObject(Object *obj);
+extern void TypedefDeclInfo(DeclInfo *declinfo, Type *type, UInt32 qual);
+extern void CParser_ParseAttribute(Type *type, DeclInfo *declinfo);
+extern void CParser_ParseDeclSpec(DeclInfo *declinfo, Boolean flag);
+extern Boolean CParser_CheckTemplateClassUsage(TemplClass *tmclass, Boolean flag);
+extern void CParser_GetDeclSpecs(DeclInfo *di, Boolean flag);
+extern void CParser_RegisterNonGlobalClass(TypeClass *tclass);
+extern void CParser_RegisterSingleExprFunction(Object *func, ENode *expr);
+extern void CParser_RegisterDummyCtorFunction(Object *func, Object *obj);
+extern Boolean CParser_IsAnonymousUnion(DeclInfo *di, Boolean flag);
+extern void CParser_CheckAnonymousUnion(DeclInfo *di, Boolean flag);
+extern void CParser_NewCallBackAction(Object *obj, TypeClass *tclass);
+extern void CParser_NewClassAction(TypeClass *tclass);
+extern void CParser_CallBackAction(Object *obj);
+extern Object *CParser_ParseObject(void);
+extern void CParser_ParseGlobalDeclaration(void);
+extern void cparser(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CPrep.h b/includes/compiler/CPrep.h
new file mode 100644
index 0000000..a681ec5
--- /dev/null
+++ b/includes/compiler/CPrep.h
@@ -0,0 +1,122 @@
+#ifndef COMPILER_CPREP_H
+#define COMPILER_CPREP_H
+
+#include "compiler/common.h"
+#include "compiler/tokens.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct Macro {
+    struct Macro *next;
+    HashNameNode *name;
+    void *c;
+    unsigned short xC;
+    Boolean is_special;
+    Boolean xF;
+    void *e;
+} Macro;
+typedef struct TokenStack {
+    char *pos;
+    char *macrostart;
+    Macro *macro;
+    Boolean macrocheck;
+} TokenStack;
+
+extern CParams *cparamblkptr;
+extern short tk;
+extern CInt64 tkintconst;
+extern Float tkfloatconst;
+extern char *tkstring;
+extern HashNameNode *tkidentifier;
+extern SInt32 tksize;
+extern short ispascalstring;
+extern short nlflag;
+extern SInt32 lines;
+extern Boolean spaceskip;
+extern struct Macro **macrohashtable;
+extern Boolean cprep_nomem_exit;
+extern Boolean cprep_nostring;
+extern Boolean cprep_eoltokens;
+extern TokenStack tokenstack[128];
+extern short tokenstacklevel;
+extern CPrepFileInfo *cprep_cursymfile;
+extern char *pos;
+extern char *macropos;
+extern char *nextcharpos;
+extern unsigned char CPrep_SkipNewCommentChar;
+extern Boolean preprocessing_only;
+extern Handle stringmem;
+extern SInt32 maxstringsize;
+extern char cprep_idarray[256];
+extern Boolean was_escchar;
+extern Boolean macrocheck;
+extern Boolean widestring;
+extern Boolean at_linestart;
+extern char *prep_file_start;
+extern char *prep_file_end;
+extern char *macrostart;
+extern Boolean cprep_strconcat;
+extern CPrepFileInfo *prep_file;
+extern short filesp;
+extern SInt32 linenumber;
+extern struct GList pplist;
+extern TStreamElement *ts_current;
+extern SInt32 ts_preread_elements;
+
+extern void CPrep_InsertSpecialMacro(Macro *macro, char *name);
+extern void CPrep_InsertSpecialMacros(void);
+extern void CPrep_RemoveSpecialMacros(void);
+extern Boolean setupprep(void);
+extern void cleanupprep(void);
+extern void CPrep_TSBufferGrow(int amount);
+extern void CPrep_TokenStreamGetState(SInt32 *state);
+extern void CPrep_TokenStreamSetState(SInt32 *state);
+extern void CPrep_UnLex(void);
+extern void CPrep_TokenStreamSetCurState(SInt32 *state);
+typedef void (*CPrepStreamFuncPtr)(TStreamElement *);
+extern void CPrep_StreamGetBlock(TStream *stream, CPrepStreamFuncPtr func, int arg);
+extern void CPrep_StreamGetSemicolon(TStream *stream, CPrepStreamFuncPtr func);
+extern void CPrep_StreamGetTemplate(TStream *stream, CPrepStreamFuncPtr func);
+extern void CPrep_StreamInsert(TStream *stream, SInt32 *state);
+extern void CPrep_StreamRemove(TStream *stream, SInt32 *state);
+extern void CPrep_RemoveTokens(SInt32 amount);
+extern void CPrep_TokenStreamFlush(void);
+extern TStreamElement *CPrep_CurStreamElement(void);
+extern void CPrep_GetTokenContext(TStreamElement *token, CPrepFileInfo **tokenfile, SInt32 *selectionoffset, short *tokensize, SInt32 *linenumber, char *buf1, short *tokenoffset, short *tokenlength, char *buf2, short *lastarg);
+extern void CPrep_Error(short code);
+extern void CPrep_ErrorName(short code, const char *name);
+extern void CPrep_Warning(short code);
+extern void CPrep_WarningName(short code, const char *name);
+extern void CPrep_ErrorMessage(int errTable, char *str, Boolean flag1, Boolean flag2);
+extern void CPrep_ErrorMessageVA(int code, const char *format, va_list list, Boolean flag1, Boolean flag2);
+extern void popfile(void);
+extern void CPrep_SetSourceFile(FileOffsetInfo *foi);
+extern HashNameNode *CPrep_GetSourceFilePath(CPrepFileInfo *fileinfo);
+extern void CPrep_NewFileOffsetInfo(FileOffsetInfo *foi, TStreamElement *ts);
+extern SInt32 CPrep_GetFileOffsetInfo(FileOffsetInfo *foi);
+extern void CPrep_GetFileOffsetInfo2(FileOffsetInfo *foi, SInt32 *pLine, HashNameNode **pName);
+extern void CPrep_ResetFileInfo(FileOffsetInfo *foi);
+extern void CPrep_GetPrepPos(CPrepFileInfo **file, SInt32 *ppos);
+extern UInt8 C_Compiler(CParams *param);
+extern void poptokenseq(void);
+extern void foundnl(void);
+extern void newline(void);
+extern short notendofline(void);
+extern char *CPrep_GetFileName(char *buffer, Boolean flag1, Boolean flag2);
+extern Boolean macrotest(void);
+extern short CPrep_PragmaLex(Boolean no_err);
+extern void CPrep_PushOption(SInt32 id, char value);
+extern void CPrep_PopOption(SInt32 id);
+extern void preprocessor(void);
+extern SInt32 CPrep_BrowserTokenOffset(FileOffsetInfo *foi);
+extern SInt32 CPrep_BrowserFileOffset(void);
+extern void CPrep_BrowserFilePosition(CPrepFileInfo **fileinfo, SInt32 *offset);
+extern CPrepFileInfo *CPrep_BrowserCurrentFile(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CPrepTokenizer.h b/includes/compiler/CPrepTokenizer.h
new file mode 100644
index 0000000..f65cff6
--- /dev/null
+++ b/includes/compiler/CPrepTokenizer.h
@@ -0,0 +1,32 @@
+#ifndef COMPILER_CPREPTOKENIZER_H
+#define COMPILER_CPREPTOKENIZER_H
+
+#include "compiler/common.h"
+#include "compiler/tokens.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern short prepskipnextchar(void);
+extern short prepnextchar(void);
+extern short prepnextstringchar(char *str, Boolean flag);
+extern void CPrep_MatchChar(char ch, Boolean flag);
+extern char *CPrep_MatchChar2(char *start, char ch, Boolean flag);
+extern short prepcurchar(void);
+extern char *ReadIdentifier(char *p);
+extern char *CPrep_SkipNewComment(char *str);
+extern Boolean skipendoflinematch(char *str, short token);
+extern void skipendofline(void);
+extern void CPrep_SkipAsmComment(void);
+extern short lookahead(void);
+extern short lookahead_noeol(void);
+extern short lex(void);
+extern short plex(void);
+extern short lexidentifier(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CScope.h b/includes/compiler/CScope.h
new file mode 100644
index 0000000..95266b1
--- /dev/null
+++ b/includes/compiler/CScope.h
@@ -0,0 +1,107 @@
+#ifndef COMPILER_CSCOPE_H
+#define COMPILER_CSCOPE_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern Boolean cscope_is_member_func;
+extern Object *cscope_currentfunc;
+extern TypeClass *cscope_currentclass;
+extern NameSpace *cscope_current;
+extern NameSpace *cscope_root;
+
+typedef struct CScopeSave {
+    NameSpace *current;
+    TypeClass *currentclass;
+    Object *currentfunc;
+    Boolean is_member_func;
+} CScopeSave; // assumed name
+
+typedef struct CScopeParseResult {
+    NameSpace *nspace_0;
+    HashNameNode *name_4;
+    Type *x8;
+    UInt32 xC; // qual
+    ObjBase *obj_10;
+    NameSpaceObjectList *nsol_14;
+    BClassList *bcl_18;
+    Boolean x1C;
+    Boolean x1D;
+    Boolean isambig;
+    Boolean x1F;
+    Boolean x20;
+    Boolean x21;
+} CScopeParseResult;
+
+typedef struct CScopeNSIterator {
+    NameSpace *nspace;
+    NameSpaceLookupList *lookup;
+    CScopeParseResult *result;
+} CScopeNSIterator;
+
+typedef struct CScopeObjectIterator {
+    NameSpace *nspace;
+    NameSpaceName *nextname;
+    NameSpaceObjectList *currlist;
+    int hashindex;
+} CScopeObjectIterator;
+
+extern void CScope_Setup(void);
+extern void CScope_Cleanup(void);
+extern void CScope_GetScope(CScopeSave *save);
+extern void CScope_SetNameSpaceScope(NameSpace *nspace, CScopeSave *save);
+extern void CScope_SetClassScope(TypeClass *cls, CScopeSave *save);
+extern void CScope_SetClassDefScope(TypeClass *cls, CScopeSave *save);
+extern void CScope_SetFunctionScope(Object *function, CScopeSave *save);
+extern void CScope_SetMethodScope(Object *function, TypeClass *cls, Boolean unknownFlag, CScopeSave *save);
+extern void CScope_RestoreScope(CScopeSave *saved);
+extern Boolean CScope_IsEmptySymTable(void);
+extern Boolean CScope_IsInLocalNameSpace(NameSpace *nspace);
+extern NameSpaceObjectList *CScope_FindName(NameSpace *nspace, HashNameNode *name);
+extern NameSpaceName *CScope_FindNameSpaceName(NameSpace *nspace, HashNameNode *name);
+extern NameSpaceObjectList *CScope_InsertName(NameSpace *nspace, HashNameNode *name);
+extern NameSpaceObjectList *CScope_ArgumentDependentNameLookup(NameSpaceObjectList *list, HashNameNode *name, ENodeList *argNodes, Boolean flag);
+extern NameSpace *CScope_NewHashNameSpace(HashNameNode *name);
+extern NameSpace *CScope_NewListNameSpace(HashNameNode *name, Boolean is_global);
+extern NameSpace *CScope_FindNonClassNonFunctionNS(NameSpace *nspace);
+extern NameSpace *CScope_FindGlobalNS(NameSpace *nspoce);
+extern Boolean CScope_IsStdNameSpace(NameSpace *nspace);
+extern Boolean CScope_IsEmptyNameSpace(NameSpace *nspace);
+extern void CScope_MergeNameSpace(NameSpace *dst, NameSpace *src);
+extern void CScope_AddObject(NameSpace *nspace, HashNameNode *name, ObjBase *obj);
+extern void CScope_AddGlobalObject(Object *obj);
+extern NameSpaceLookupList *CScope_BuildNameSpaceLookupList(NameSpace *nspace);
+extern Boolean CScope_FindQualifiedClassMember(CScopeParseResult *result, TypeClass *tclass, HashNameNode *name);
+extern Type *CScope_GetType(NameSpace *nspace, HashNameNode *name, UInt32 *qual);
+extern Type *CScope_GetTagType(NameSpace *nspace, HashNameNode *name);
+extern Boolean CScope_ParseExprName(CScopeParseResult *result);
+extern Boolean CScope_ParseDeclName(CScopeParseResult *result);
+extern Boolean CScope_ParseQualifiedNameSpace(CScopeParseResult *result, Boolean flag1, Boolean flag2);
+extern Boolean CScope_ParseElaborateName(CScopeParseResult *result);
+extern Boolean CScope_FindObject(NameSpace *nspace, CScopeParseResult *result, HashNameNode *name);
+extern Boolean CScope_FindNonClassObject(NameSpace *nspace, CScopeParseResult *result, HashNameNode *name);
+extern NameSpaceObjectList *CScope_FindObjectList(CScopeParseResult *result, HashNameNode *name);
+extern Boolean CScope_PossibleTypeName(HashNameNode *name);
+extern Boolean CScope_FindClassMemberObject(TypeClass *tclass, CScopeParseResult *result, HashNameNode *name);
+extern void CScope_InitObjectIterator(CScopeObjectIterator *iterator, NameSpace *nspace);
+extern ObjBase *CScope_NextObjectIteratorObject(CScopeObjectIterator *iterator);
+extern NameSpaceObjectList *CScope_NextObjectIteratorObjectList(CScopeObjectIterator *iterator);
+extern void CScope_DefineTypeTag(NameSpace *nspace, HashNameNode *name, Type *type);
+extern Type *CScope_GetLocalTagType(NameSpace *nspace, HashNameNode *name);
+extern Boolean CScope_FindTypeName(NameSpace *nspace, HashNameNode *name, CScopeParseResult *result);
+extern NameSpaceObjectList *CScope_GetLocalObject(NameSpace *nspace, HashNameNode *name);
+extern BClassList *CScope_GetClassAccessPath(BClassList *list, TypeClass *tclass);
+extern Boolean CScope_ParseMemberName(TypeClass *tclass, CScopeParseResult *result, Boolean flag);
+extern void CScope_AddClassUsingDeclaration(TypeClass *tclass, TypeClass *tclass2, HashNameNode *name, AccessType access);
+extern void CScope_ParseUsingDeclaration(NameSpace *nspace, short access, Boolean flag);
+extern void CScope_ParseNameSpaceAlias(HashNameNode *name);
+extern void CScope_ParseUsingDirective(NameSpace *nspace);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/CodeGen.h b/includes/compiler/CodeGen.h
new file mode 100644
index 0000000..3954d51
--- /dev/null
+++ b/includes/compiler/CodeGen.h
@@ -0,0 +1,79 @@
+#ifndef COMPILER_CODEGEN_H
+#define COMPILER_CODEGEN_H
+
+#include "compiler/common.h"
+#include "compiler/CPrep.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern Macro vecM;
+extern Macro altivecM;
+extern Object *gFunction;
+extern PCodeLabel *returnlabel;
+extern PCodeLabel *cleanreturnlabel;
+extern Boolean needs_cleanup;
+extern Statement *current_statement;
+extern int has_catch_blocks;
+extern int disable_optimizer;
+extern SInt32 current_linenumber;
+extern Boolean has_altivec_arrays;
+extern short high_reg;
+extern short low_reg;
+extern short high_offset;
+extern short low_offset;
+extern short low_reg2;
+extern short high_reg2;
+extern PCodeLabel *pic_base_pcodelabel;
+extern Object *dyld_stub_binding_helper;
+extern Object *rt_cvt_fp2unsigned;
+extern Object *rt_profile_entry;
+extern Object *rt_profile_exit;
+extern Object *rt_div2i;
+extern Object *rt_div2u;
+extern Object *rt_mod2i;
+extern Object *rt_mod2u;
+extern Object *rt_shr2i;
+extern Object *rt_shr2u;
+extern Object *rt_shl2i;
+extern Object *rt_cvt_ull_dbl;
+extern Object *rt_cvt_sll_dbl;
+extern Object *rt_cvt_ull_flt;
+extern Object *rt_cvt_sll_flt;
+extern Object *rt_cvt_dbl_usll;
+
+extern VarInfo *CodeGen_GetNewVarInfo(void);
+extern Object *maketemporary(Type *type);
+typedef void (*ArgumentProcessor)(Object *obj, short reg);
+extern void process_arguments(ArgumentProcessor func, Boolean flag);
+extern void move_assigned_argument(Object *obj, short reg);
+extern void assign_labels();
+extern void CodeGen_Generator();
+extern void CodeGen_GenVDispatchThunk();
+extern void CodeGen_SetupRuntimeObjects();
+extern Boolean CodeGen_ReInitRuntimeObjects(Boolean is_precompiler);
+extern Boolean CodeGen_IsPublicRuntimeObject(Object *obj);
+extern void CodeGen_SOMStub();
+extern void CodeGen_ParseDeclSpec(HashNameNode *identifier, DeclInfo *declinfo);
+extern void CodeGen_ParsePragma(HashNameNode *name);
+extern void CodeGen_UpdateObject(Object *object);
+extern void CodeGen_UpdateBackEndOptions();
+extern void CodeGen_objc_method_self_offset();
+extern void CodeGen_objc_method_sel_offset();
+extern void CodeGen_objc_method_arg_offset();
+extern void CodeGen_objc_method_args_size();
+extern void CodeGen_HandleIntrinsicCall();
+extern void CodeGen_HandleTypeCast();
+extern short CodeGen_AssignCheck(ENode *expr, Type *type, Boolean flag1, Boolean flag2);
+extern void CodeGen_CollapseVectorExpression();
+extern void CodeGen_InsertSpecialMacros();
+extern char *CodeGen_ExpandSpecialMacro(Macro *macro);
+extern void CodeGen_reportheapinfo();
+extern void CodeGen_InitialSanityCheck();
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/Operands.h b/includes/compiler/Operands.h
new file mode 100644
index 0000000..8c6aa93
--- /dev/null
+++ b/includes/compiler/Operands.h
@@ -0,0 +1,85 @@
+#ifndef COMPILER_OPERANDS_H
+#define COMPILER_OPERANDS_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+extern Float one_point_zero;
+
+enum OperandType {
+    // Value in a register (identified by 'reg')
+    OpndType_GPR = 0,
+    // Uses 'reg', 'object, 'immOffset'
+    OpndType_GPR_ImmOffset = 1,
+    // Uses 'reg', 'regOffset'
+    OpndType_GPR_Indexed = 2,
+    // Value in two registers (identified by 'reg' and 'regHi')
+    OpndType_GPRPair = 3,
+    // Value at an absolute address (identified by 'abs_address')
+    OpndType_Absolute = 4,
+    // Value in a float register (identified by 'reg')
+    OpndType_FPR = 5,
+    // Value in a vector register (identified by 'reg')
+    OpndType_VR = 6,
+    // Condition value: 'reg' stores which condition register, and 'regOffset' is equal to ENOTEQU, EEQU, EGREATEREQU,
+    // ELESS, ELESS or ELESSEQU
+    OpndType_CRField = 7,
+    // Value of a symbol (identified by 'object')
+    OpndType_Symbol = 8,
+    // Reference to a location (at 'reg', offset using 'object' and 'immOffset')
+    OpndType_IndirectGPR_ImmOffset = 9,
+    // Reference to a location (at 'reg', offset using the value of register 'regOffset')
+    OpndType_IndirectGPR_Indexed = 0xA,
+    // Reference to a symbol (identified by 'object')
+    OpndType_IndirectSymbol = 0xB
+};
+
+// These are probably the same as the PCode Flags and can be unified?
+enum {
+    OpndFlags_Const = 0x40,
+    OpndFlags_Volatile = 0x80
+};
+
+struct Operand {
+    enum OperandType optype;
+    SInt16 reg;
+    SInt16 regHi;
+    SInt16 regOffset;
+    SInt32 immOffset;
+    SInt32 abs_address;
+    Object *object;
+    UInt32 flags;
+};
+
+extern void load_immediate(short reg, SInt32 value);
+extern void symbol_operand(Operand *op, Object *obj);
+extern void indirect(Operand *op, ENode *expr);
+extern void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut);
+extern void coerce_to_addressable(Operand *op);
+extern void Coerce_to_register(Operand *op, Type *type, short output_reg);
+extern void coerce_to_register_pair(Operand *op, Type *type, short output_reg, short output_regHi);
+extern void Coerce_to_fp_register(Operand *op, TypeIntegral *tint, short output_reg);
+extern void Coerce_to_v_register(Operand *op, TypeStruct *tstruct, short output_reg);
+extern void store(short reg, Operand *op, Type *type);
+extern void store_pair(short reg, short regHi, Operand *op, Type *type);
+extern void store_fp(short reg, Operand *op, TypeIntegral *tint);
+extern void store_v(short reg, Operand *op, TypeStruct *tstruct);
+extern void extend32(Operand *op, Type *type, short output_reg);
+extern void extend64(Operand *op, Type *type, short output_reg, short output_regHi);
+extern void load_floating_constant(short reg, TypeIntegral *type, double *data);
+extern void convert_integer_to_floating(Operand *op, Boolean is_single, short output_reg);
+extern void convert_unsigned_to_floating(Operand *op, Boolean is_single, short output_reg);
+extern void convert_floating_to_integer(Operand *op, short output_reg);
+extern void convert_floating_to_unsigned(Operand *op, short output_reg);
+extern void extract_bitfield(Operand *input_op, TypeBitfield *tbitfield, short output_reg, Operand *output_op);
+extern void insert_bitfield(short reg, Operand *op, TypeBitfield *tbitfield);
+extern void load_address(short dest_reg, Operand *op);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/PCode.h b/includes/compiler/PCode.h
new file mode 100644
index 0000000..55aac38
--- /dev/null
+++ b/includes/compiler/PCode.h
@@ -0,0 +1,194 @@
+#ifndef COMPILER_PCODE_H
+#define COMPILER_PCODE_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+#define PCODE_FLAG_SET_T(pcode) (((pcode)->flags & (fPCodeFlag1 | fPCodeFlag8)) ? (pcode)->flags : 0)
+#define PCODE_FLAG_SET_F(pcode) (((pcode)->flags & (fPCodeFlag1 | fPCodeFlag8)) ? 0 : (pcode)->flags)
+
+enum {
+    EffectRead = 1,
+    EffectWrite = 2
+};
+
+typedef enum {
+    PCOp_REGISTER,
+    PCOp_SYSREG,
+    PCOp_IMMEDIATE,
+    PCOp_MEMORY,
+    PCOp_LABEL,
+    PCOp_LABELDIFF,
+    PCOp_PLACEHOLDEROPERAND
+} PCOpKind;
+
+typedef enum {
+    RefType_0,
+    RefType_1,
+    RefType_2,
+    RefType_3,
+    RefType_4,
+    RefType_5,
+    RefType_6,
+    RefType_7,
+    RefType_8,
+    RefType_9,
+    RefType_A,
+    RefType_B,
+    RefType_C,
+    RefType_D
+} PCRefType;
+
+struct PCodeArg {
+    PCOpKind kind;
+    char arg;
+    union {
+        struct {
+            unsigned short effect;
+            short reg;
+        } reg;
+        struct {
+            SInt32 value;
+            Object *obj;
+        } imm;
+        struct {
+            SInt32 offset;
+            Object *obj;
+        } mem;
+        struct {
+            PCodeLabel *label;
+        } label;
+        struct {
+            SInt16 offset;
+            PCodeLabel *labelA;
+            PCodeLabel *labelB;
+        } labeldiff;
+        unsigned char placeholder[10]; // keep the size
+    } data;
+};
+
+struct PCode {
+    PCode *nextPCode;
+    PCode *prevPCode;
+    PCodeBlock *block;
+    unsigned int xx_C;
+    unsigned int _10;
+    int flags;
+    void *_18;
+    SInt32 sourceoffset;
+    short op;
+    short argCount;
+    PCodeArg args[0];
+};
+
+struct PCodeLabel {
+    PCodeLabel *nextLabel;
+    PCodeBlock *block;
+    short resolved;
+    short index;
+};
+
+typedef struct _PCLink {
+    struct _PCLink *nextLink;
+    struct PCodeBlock *block;
+} PCLink;
+
+struct PCodeBlock {
+    struct PCodeBlock *nextBlock;
+    struct PCodeBlock *prevBlock;
+    PCodeLabel *labels;
+    PCLink *predecessors;
+    PCLink *successors;
+    PCode *firstPCode;
+    PCode *lastPCode;
+    int blockIndex;
+    int codeOffset; // in bytes
+    int loopWeight;
+    short pcodeCount;
+    unsigned short flags;
+};
+
+/* PCode Flags */
+enum {
+    fPCodeFlag1 = 1,
+    fPCodeFlag2 = 2,
+    fPCodeFlag4 = 4,
+    fPCodeFlag8 = 8,
+    fPCodeFlag10 = 0x10,
+    fPCodeFlag20 = 0x20,
+    // Always valid
+    fIsConst = 0x40,
+    fIsVolatile = 0x80,
+    fSideEffects = 0x100,
+    fPCodeFlag200 = 0x200, // ?
+    fPCodeFlag400 = 0x400, // ?
+    fPCodeFlag800 = 0x800, // ?
+    fPCodeFlag1000 = 0x1000, // ?
+    fCommutative = 0x2000,
+    fIsCSE = 0x4000,
+    fPCodeFlag8000 = 0x8000,
+    fPCodeFlag20000 = 0x20000, // ?
+    fPCodeFlag40000 = 0x40000, // ?
+    // Set 1 only
+    fLink = 0x1000000,
+    fBranchNotTaken = 0x4000000,
+    fBranchTaken = 0x8000000,
+    fAbsolute = 0x10000000,
+    // Set 2 only
+    fIsPtrOp = 0x20,
+    fOverflow = 0x800000,
+    fSetsCarry = 0x10000000,
+    // ??
+    fPCodeFlag8000000 = 0x8000000,
+    fPCodeFlag10000000 = 0x10000000,
+    fPCodeFlag20000000 = 0x20000000,
+    fPCodeFlag40000000 = 0x40000000,
+    fPCodeFlag80000000 = 0x80000000
+};
+
+enum {
+    fPCBlockFlag1 = 1, // prologue
+    fPCBlockFlag2 = 2, // epilogue
+    fPCBlockFlag4 = 4,
+    fPCBlockFlag8 = 8,
+    fPCBlockFlag10 = 0x10,
+    fPCBlockFlag20 = 0x20,
+    fPCBlockFlag4000 = 0x4000
+};
+
+extern PCodeBlock *pcbasicblocks;
+extern PCodeBlock *pclastblock;
+extern PCodeBlock *prologue;
+extern PCodeBlock *epilogue;
+extern PCodeBlock **depthfirstordering;
+extern int pcblockcount;
+extern int pcloopweight;
+
+extern void initpcode();
+extern PCode *makepcode(short op, ...);
+extern void emitpcode(short op, ...);
+extern PCode *copypcode(PCode *pcode);
+extern PCodeLabel *makepclabel();
+extern PCodeBlock *makepcblock();
+extern void pclabel(PCodeBlock *block, PCodeLabel *label);
+extern void pcbranch(PCodeBlock *block, PCodeLabel *label);
+extern void pccomputepredecessors();
+extern void deleteblock(PCodeBlock *block);
+extern void deleteunreachableblocks();
+extern void appendpcode(PCodeBlock *block, PCode *pcode);
+extern void deletepcode(PCode *pcode);
+extern void insertpcodebefore(PCode *anchor, PCode *newpcode);
+extern void insertpcodeafter(PCode *anchor, PCode *newpcode);
+extern void setpcodeflags(int flags);
+extern void clearpcodeflags(int flags);
+extern int pccomputeoffsets();
+extern void computedepthfirstordering();
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/PCodeInfo.h b/includes/compiler/PCodeInfo.h
new file mode 100644
index 0000000..137e10a
--- /dev/null
+++ b/includes/compiler/PCodeInfo.h
@@ -0,0 +1,1335 @@
+#ifndef COMPILER_PCODEINFO_H
+#define COMPILER_PCODEINFO_H
+
+#include "compiler/PCode.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct _OpcodeInfo {
+    const char *name;
+    const char *format;
+    unsigned char x8;
+    unsigned char x9;
+    int flags;
+    unsigned int insn;
+} OpcodeInfo;
+
+/*enum {
+    PC_B = 0x0,
+    PC_BL = 0x1,
+    PC_BC = 0x2,
+    PC_BCLR = 0x3,
+    PC_BCCTR = 0x4,
+    PC_BT = 0x5,
+    PC_BTLR = 0x6,
+    PC_BTCTR = 0x7,
+    PC_BF = 0x8,
+    PC_BFLR = 0x9,
+    PC_BFCTR = 0xA,
+    PC_BDNZ = 0xB,
+    PC_BDNZT = 0xC,
+    PC_BDNZF = 0xD,
+    PC_BDZ = 0xE,
+    PC_BDZT = 0xF,
+    PC_BDZF = 0x10,
+    PC_BLR = 0x11,
+    PC_BCTR = 0x12,
+    PC_BCTRL = 0x13,
+    PC_BLRL = 0x14,
+    PC_LBZ = 0x15,
+    PC_LBZU = 0x16,
+    PC_LBZX = 0x17,
+    PC_LBZUX = 0x18,
+    PC_LHZ = 0x19,
+    PC_LHZU = 0x1A,
+    PC_LHZX = 0x1B,
+    PC_LHZUX = 0x1C,
+    PC_LHA = 0x1D,
+    PC_LHAU = 0x1E,
+    PC_LHAX = 0x1F,
+    PC_LHAUX = 0x20,
+    PC_LHBRX = 0x21,
+    PC_LWZ = 0x22,
+    PC_LWZU = 0x23,
+    PC_LWZX = 0x24,
+    PC_LWZUX = 0x25,
+    PC_LWBRX = 0x26,
+    PC_LMW = 0x27,
+    PC_STB = 0x28,
+    PC_STBU = 0x29,
+    PC_STBX = 0x2A,
+    PC_STBUX = 0x2B,
+    PC_STH = 0x2C,
+    PC_STHU = 0x2D,
+    PC_STHX = 0x2E,
+    PC_STHUX = 0x2F,
+    PC_STHBRX = 0x30,
+    PC_STW = 0x31,
+    PC_STWU = 0x32,
+    PC_STWX = 0x33,
+    PC_STWUX = 0x34,
+    PC_STWBRX = 0x35,
+    PC_STMW = 0x36,
+    PC_DCBF = 0x37,
+    PC_DCBST = 0x38,
+    PC_DCBT = 0x39,
+    PC_DCBTST = 0x3A,
+    PC_DCBZ = 0x3B,
+    PC_ADD = 0x3C,
+    PC_ADDC = 0x3D,
+    PC_ADDE = 0x3E,
+    PC_ADDI = 0x3F,
+    PC_ADDIC = 0x40,
+    PC_ADDICR = 0x41,
+    PC_ADDIS = 0x42,
+    PC_ADDME = 0x43,
+    PC_ADDZE = 0x44,
+    PC_DIVW = 0x45,
+    PC_DIVWU = 0x46,
+    PC_MULHW = 0x47,
+    PC_MULHWU = 0x48,
+    PC_MULLI = 0x49,
+    PC_MULLW = 0x4A,
+    PC_NEG = 0x4B,
+    PC_SUBF = 0x4C,
+    PC_SUBFC = 0x4D,
+    PC_SUBFE = 0x4E,
+    PC_SUBFIC = 0x4F,
+    PC_SUBFME = 0x50,
+    PC_SUBFZE = 0x51,
+    PC_CMPI = 0x52,
+    PC_CMP = 0x53,
+    PC_CMPLI = 0x54,
+    PC_CMPL = 0x55,
+    PC_ANDI = 0x56,
+    PC_ANDIS = 0x57,
+    PC_ORI = 0x58,
+    PC_ORIS = 0x59,
+    PC_XORI = 0x5A,
+    PC_XORIS = 0x5B,
+    PC_AND = 0x5C,
+    PC_OR = 0x5D,
+    PC_XOR = 0x5E,
+    PC_NAND = 0x5F,
+    PC_NOR = 0x60,
+    PC_EQV = 0x61,
+    PC_ANDC = 0x62,
+    PC_ORC = 0x63,
+    PC_EXTSB = 0x64,
+    PC_EXTSH = 0x65,
+    PC_CNTLZW = 0x66,
+    PC_RLWINM = 0x67,
+    PC_RLWNM = 0x68,
+    PC_RLWIMI = 0x69,
+    PC_SLW = 0x6A,
+    PC_SRW = 0x6B,
+    PC_SRAWI = 0x6C,
+    PC_SRAW = 0x6D,
+    PC_CRAND = 0x6E,
+    PC_CRANDC = 0x6F,
+    PC_CREQV = 0x70,
+    PC_CRNAND = 0x71,
+    PC_CRNOR = 0x72,
+    PC_CROR = 0x73,
+    PC_CRORC = 0x74,
+    PC_CRXOR = 0x75,
+    PC_MCRF = 0x76,
+    PC_MTXER = 0x77,
+    PC_MTCTR = 0x78,
+    PC_MTLR = 0x79,
+    PC_MTCRF = 0x7A,
+    PC_MTMSR = 0x7B,
+    PC_MTSPR = 0x7C,
+    PC_MFMSR = 0x7D,
+    PC_MFSPR = 0x7E,
+    PC_MFXER = 0x7F,
+    PC_MFCTR = 0x80,
+    PC_MFLR = 0x81,
+    PC_MFCR = 0x82,
+    PC_MFFS = 0x83,
+    PC_MTFSF = 0x84,
+    PC_EIEIO = 0x85,
+    PC_ISYNC = 0x86,
+    PC_SYNC = 0x87,
+    PC_RFI = 0x88,
+    PC_LI = 0x89,
+    PC_LIS = 0x8A,
+    PC_MR = 0x8B,
+    PC_NOP = 0x8C,
+    PC_NOT = 0x8D,
+    PC_LFS = 0x8E,
+    PC_LFSU = 0x8F,
+    PC_LFSX = 0x90,
+    PC_LFSUX = 0x91,
+    PC_LFD = 0x92,
+    PC_LFDU = 0x93,
+    PC_LFDX = 0x94,
+    PC_LFDUX = 0x95,
+    PC_STFS = 0x96,
+    PC_STFSU = 0x97,
+    PC_STFSX = 0x98,
+    PC_STFSUX = 0x99,
+    PC_STFD = 0x9A,
+    PC_STFDU = 0x9B,
+    PC_STFDX = 0x9C,
+    PC_STFDUX = 0x9D,
+    PC_FMR = 0x9E,
+    PC_FABS = 0x9F,
+    PC_FNEG = 0xA0,
+    PC_FNABS = 0xA1,
+    PC_FADD = 0xA2,
+    PC_FADDS = 0xA3,
+    PC_FSUB = 0xA4,
+    PC_FSUBS = 0xA5,
+    PC_FMUL = 0xA6,
+    PC_FMULS = 0xA7,
+    PC_FDIV = 0xA8,
+    PC_FDIVS = 0xA9,
+    PC_FMADD = 0xAA,
+    PC_FMADDS = 0xAB,
+    PC_FMSUB = 0xAC,
+    PC_FMSUBS = 0xAD,
+    PC_FNMADD = 0xAE,
+    PC_FNMADDS = 0xAF,
+    PC_FNMSUB = 0xB0,
+    PC_FNMSUBS = 0xB1,
+    PC_FRES = 0xB2,
+    PC_FRSQRTE = 0xB3,
+    PC_FSEL = 0xB4,
+    PC_FRSP = 0xB5,
+    PC_FCTIW = 0xB6,
+    PC_FCTIWZ = 0xB7,
+    PC_FCMPU = 0xB8,
+    PC_FCMPO = 0xB9,
+    PC_LWARX = 0xBA,
+    PC_LSWI = 0xBB,
+    PC_LSWX = 0xBC,
+    PC_STFIWX = 0xBD,
+    PC_STSWI = 0xBE,
+    PC_STSWX = 0xBF,
+    PC_STWCX = 0xC0,
+    PC_ECIWX = 0xC1,
+    PC_ECOWX = 0xC2,
+    PC_DCBI = 0xC3,
+    PC_ICBI = 0xC4,
+    PC_MCRFS = 0xC5,
+    PC_MCRXR = 0xC6,
+    PC_MFTB = 0xC7,
+    PC_MFSR = 0xC8,
+    PC_MTSR = 0xC9,
+    PC_MFSRIN = 0xCA,
+    PC_MTSRIN = 0xCB,
+    PC_MTFSB0 = 0xCC,
+    PC_MTFSB1 = 0xCD,
+    PC_MTFSFI = 0xCE,
+    PC_SC = 0xCF,
+    PC_FSQRT = 0xD0,
+    PC_FSQRTS = 0xD1,
+    PC_TLBIA = 0xD2,
+    PC_TLBIE = 0xD3,
+    PC_TLBLD = 0xD4,
+    PC_TLBLI = 0xD5,
+    PC_TLBSYNC = 0xD6,
+    PC_TW = 0xD7,
+    PC_TRAP = 0xD8,
+    PC_TWI = 0xD9,
+    PC_OPWORD = 0xDA,
+    PC_MFROM = 0xDB,
+    PC_DSA = 0xDC,
+    PC_ESA = 0xDD,
+    PC_DCCCI = 0xDE,
+    PC_DCREAD = 0xDF,
+    PC_ICBT = 0xE0,
+    PC_ICCCI = 0xE1,
+    PC_ICREAD = 0xE2,
+    PC_RFCI = 0xE3,
+    PC_TLBRE = 0xE4,
+    PC_TLBSX = 0xE5,
+    PC_TLBWE = 0xE6,
+    PC_WRTEE = 0xE7,
+    PC_WRTEEI = 0xE8,
+    PC_MFDCR = 0xE9,
+    PC_MTDCR = 0xEA,
+    PC_DCBA = 0xEB,
+    PC_DSS = 0xEC,
+    PC_DSSALL = 0xED,
+    PC_DST = 0xEE,
+    PC_DSTT = 0xEF,
+    PC_DSTST = 0xF0,
+    PC_DSTSTT = 0xF1,
+    PC_LVEBX = 0xF2,
+    PC_LVEHX = 0xF3,
+    PC_LVEWX = 0xF4,
+    PC_LVSL = 0xF5,
+    PC_LVSR = 0xF6,
+    PC_LVX = 0xF7,
+    PC_LVXL = 0xF8,
+    PC_STVEBX = 0xF9,
+    PC_STVEHX = 0xFA,
+    PC_STVEWX = 0xFB,
+    PC_STVX = 0xFC,
+    PC_STVXL = 0xFD,
+    PC_MFVSCR = 0xFE,
+    PC_MTVSCR = 0xFF,
+    PC_VADDCUW = 0x100,
+    PC_VADDFP = 0x101,
+    PC_VADDSBS = 0x102,
+    PC_VADDSHS = 0x103,
+    PC_VADDSWS = 0x104,
+    PC_VADDUBM = 0x105,
+    PC_VADDUBS = 0x106,
+    PC_VADDUHM = 0x107,
+    PC_VADDUHS = 0x108,
+    PC_VADDUWM = 0x109,
+    PC_VADDUWS = 0x10A,
+    PC_VAND = 0x10B,
+    PC_VANDC = 0x10C,
+    PC_VAVGSB = 0x10D,
+    PC_VAVGSH = 0x10E,
+    PC_VAVGSW = 0x10F,
+    PC_VAVGUB = 0x110,
+    PC_VAVGUH = 0x111,
+    PC_VAVGUW = 0x112,
+    PC_VCFSX = 0x113,
+    PC_VCFUX = 0x114,
+    PC_VCMPBFP = 0x115,
+    PC_VCMPEQFP = 0x116,
+    PC_VCMPEQUB = 0x117,
+    PC_VCMPEQUH = 0x118,
+    PC_VCMPEQUW = 0x119,
+    PC_VCMPGEFP = 0x11A,
+    PC_VCMPGTFP = 0x11B,
+    PC_VCMPGTSB = 0x11C,
+    PC_VCMPGTSH = 0x11D,
+    PC_VCMPGTSW = 0x11E,
+    PC_VCMPGTUB = 0x11F,
+    PC_VCMPGTUH = 0x120,
+    PC_VCMPGTUW = 0x121,
+    PC_VCTSXS = 0x122,
+    PC_VCTUXS = 0x123,
+    PC_VEXPTEFP = 0x124,
+    PC_VLOGEFP = 0x125,
+    PC_VMAXFP = 0x126,
+    PC_VMAXSB = 0x127,
+    PC_VMAXSH = 0x128,
+    PC_VMAXSW = 0x129,
+    PC_VMAXUB = 0x12A,
+    PC_VMAXUH = 0x12B,
+    PC_VMAXUW = 0x12C,
+    PC_VMINFP = 0x12D,
+    PC_VMINSB = 0x12E,
+    PC_VMINSH = 0x12F,
+    PC_VMINSW = 0x130,
+    PC_VMINUB = 0x131,
+    PC_VMINUH = 0x132,
+    PC_VMINUW = 0x133,
+    PC_VMRGHB = 0x134,
+    PC_VMRGHH = 0x135,
+    PC_VMRGHW = 0x136,
+    PC_VMRGLB = 0x137,
+    PC_VMRGLH = 0x138,
+    PC_VMRGLW = 0x139,
+    PC_VMULESB = 0x13A,
+    PC_VMULESH = 0x13B,
+    PC_VMULEUB = 0x13C,
+    PC_VMULEUH = 0x13D,
+    PC_VMULOSB = 0x13E,
+    PC_VMULOSH = 0x13F,
+    PC_VMULOUB = 0x140,
+    PC_VMULOUH = 0x141,
+    PC_VNOR = 0x142,
+    PC_VOR = 0x143,
+    PC_VPKPX = 0x144,
+    PC_VPKSHSS = 0x145,
+    PC_VPKSHUS = 0x146,
+    PC_VPKSWSS = 0x147,
+    PC_VPKSWUS = 0x148,
+    PC_VPKUHUM = 0x149,
+    PC_VPKUHUS = 0x14A,
+    PC_VPKUWUM = 0x14B,
+    PC_VPKUWUS = 0x14C,
+    PC_VREFP = 0x14D,
+    PC_VRFIM = 0x14E,
+    PC_VRFIN = 0x14F,
+    PC_VRFIP = 0x150,
+    PC_VRFIZ = 0x151,
+    PC_VRLB = 0x152,
+    PC_VRLH = 0x153,
+    PC_VRLW = 0x154,
+    PC_VRSQRTEFP = 0x155,
+    PC_VSL = 0x156,
+    PC_VSLB = 0x157,
+    PC_VSLH = 0x158,
+    PC_VSLO = 0x159,
+    PC_VSLW = 0x15A,
+    PC_VSPLTB = 0x15B,
+    PC_VSPLTH = 0x15C,
+    PC_VSPLTW = 0x15D,
+    PC_VSPLTISB = 0x15E,
+    PC_VSPLTISH = 0x15F,
+    PC_VSPLTISW = 0x160,
+    PC_VSR = 0x161,
+    PC_VSRAB = 0x162,
+    PC_VSRAH = 0x163,
+    PC_VSRAW = 0x164,
+    PC_VSRB = 0x165,
+    PC_VSRH = 0x166,
+    PC_VSRO = 0x167,
+    PC_VSRW = 0x168,
+    PC_VSUBCUW = 0x169,
+    PC_VSUBFP = 0x16A,
+    PC_VSUBSBS = 0x16B,
+    PC_VSUBSHS = 0x16C,
+    PC_VSUBSWS = 0x16D,
+    PC_VSUBUBM = 0x16E,
+    PC_VSUBUBS = 0x16F,
+    PC_VSUBUHM = 0x170,
+    PC_VSUBUHS = 0x171,
+    PC_VSUBUWM = 0x172,
+    PC_VSUBUWS = 0x173,
+    PC_VSUMSWS = 0x174,
+    PC_VSUM2SWS = 0x175,
+    PC_VSUM4SBS = 0x176,
+    PC_VSUM4SHS = 0x177,
+    PC_VSUM4UBS = 0x178,
+    PC_VUPKHPX = 0x179,
+    PC_VUPKHSB = 0x17A,
+    PC_VUPKHSH = 0x17B,
+    PC_VUPKLPX = 0x17C,
+    PC_VUPKLSB = 0x17D,
+    PC_VUPKLSH = 0x17E,
+    PC_VXOR = 0x17F,
+    PC_VMADDFP = 0x180,
+    PC_VMHADDSHS = 0x181,
+    PC_VMHRADDSHS = 0x182,
+    PC_VMLADDUHM = 0x183,
+    PC_VMSUMMBM = 0x184,
+    PC_VMSUMSHM = 0x185,
+    PC_VMSUMSHS = 0x186,
+    PC_VMSUMUBM = 0x187,
+    PC_VMSUMUHM = 0x188,
+    PC_VMSUMUHS = 0x189,
+    PC_VNMSUBFP = 0x18A,
+    PC_VPERM = 0x18B,
+    PC_VSEL = 0x18C,
+    PC_VSLDOI = 0x18D,
+    PC_VMR = 0x18E,
+    PC_VMRP = 0x18F,
+    PC_SLE = 0x190,
+    PC_SLEQ = 0x191,
+    PC_SLIQ = 0x192,
+    PC_SLLIQ = 0x193,
+    PC_SLLQ = 0x194,
+    PC_SLQ = 0x195,
+    PC_SRAIQ = 0x196,
+    PC_SRAQ = 0x197,
+    PC_SRE = 0x198,
+    PC_SREA = 0x199,
+    PC_SREQ = 0x19A,
+    PC_SRIQ = 0x19B,
+    PC_SRLIQ = 0x19C,
+    PC_SRLQ = 0x19D,
+    PC_SRQ = 0x19E,
+    PC_MASKG = 0x19F,
+    PC_MASKIR = 0x1A0,
+    PC_LSCBX = 0x1A1,
+    PC_DIV = 0x1A2,
+    PC_DIVS = 0x1A3,
+    PC_DOZ = 0x1A4,
+    PC_MUL = 0x1A5,
+    PC_NABS = 0x1A6,
+    PC_ABS = 0x1A7,
+    PC_CLCS = 0x1A8,
+    PC_DOZI = 0x1A9,
+    PC_RLMI = 0x1AA,
+    PC_RRIB = 0x1AB,
+    PC_PENTRY = 0x1AC,
+    PC_PEXIT = 0x1AD,
+    OPCODE_MAX = 0x1AE
+};*/
+//#define PC_B 0x0
+//#define PC_BL 0x1
+//#define PC_BC 0x2
+//#define PC_BCLR 0x3
+//#define PC_BCCTR 0x4
+//#define PC_BT 0x5
+//#define PC_BTLR 0x6
+//#define PC_BTCTR 0x7
+//#define PC_BF 0x8
+//#define PC_BFLR 0x9
+//#define PC_BFCTR 0xA
+//#define PC_BDNZ 0xB
+//#define PC_BDNZT 0xC
+//#define PC_BDNZF 0xD
+//#define PC_BDZ 0xE
+//#define PC_BDZT 0xF
+//#define PC_BDZF 0x10
+//#define PC_BLR 0x11
+//#define PC_BCTR 0x12
+//#define PC_BCTRL 0x13
+//#define PC_BLRL 0x14
+//#define PC_LBZ 0x15
+//#define PC_LBZU 0x16
+//#define PC_LBZX 0x17
+//#define PC_LBZUX 0x18
+//#define PC_LHZ 0x19
+//#define PC_LHZU 0x1A
+//#define PC_LHZX 0x1B
+//#define PC_LHZUX 0x1C
+//#define PC_LHA 0x1D
+//#define PC_LHAU 0x1E
+//#define PC_LHAX 0x1F
+//#define PC_LHAUX 0x20
+//#define PC_LHBRX 0x21
+//#define PC_LWZ 0x22
+//#define PC_LWZU 0x23
+//#define PC_LWZX 0x24
+//#define PC_LWZUX 0x25
+//#define PC_LWBRX 0x26
+//#define PC_LMW 0x27
+//#define PC_STB 0x28
+//#define PC_STBU 0x29
+//#define PC_STBX 0x2A
+//#define PC_STBUX 0x2B
+//#define PC_STH 0x2C
+//#define PC_STHU 0x2D
+//#define PC_STHX 0x2E
+//#define PC_STHUX 0x2F
+//#define PC_STHBRX 0x30
+//#define PC_STW 0x31
+//#define PC_STWU 0x32
+//#define PC_STWX 0x33
+//#define PC_STWUX 0x34
+//#define PC_STWBRX 0x35
+//#define PC_STMW 0x36
+//#define PC_DCBF 0x37
+//#define PC_DCBST 0x38
+//#define PC_DCBT 0x39
+//#define PC_DCBTST 0x3A
+//#define PC_DCBZ 0x3B
+//#define PC_ADD 0x3C
+//#define PC_ADDC 0x3D
+//#define PC_ADDE 0x3E
+//#define PC_ADDI 0x3F
+//#define PC_ADDIC 0x40
+//#define PC_ADDICR 0x41
+//#define PC_ADDIS 0x42
+//#define PC_ADDME 0x43
+//#define PC_ADDZE 0x44
+//#define PC_DIVW 0x45
+//#define PC_DIVWU 0x46
+//#define PC_MULHW 0x47
+//#define PC_MULHWU 0x48
+//#define PC_MULLI 0x49
+//#define PC_MULLW 0x4A
+//#define PC_NEG 0x4B
+//#define PC_SUBF 0x4C
+//#define PC_SUBFC 0x4D
+//#define PC_SUBFE 0x4E
+//#define PC_SUBFIC 0x4F
+//#define PC_SUBFME 0x50
+//#define PC_SUBFZE 0x51
+//#define PC_CMPI 0x52
+//#define PC_CMP 0x53
+//#define PC_CMPLI 0x54
+//#define PC_CMPL 0x55
+//#define PC_ANDI 0x56
+//#define PC_ANDIS 0x57
+//#define PC_ORI 0x58
+//#define PC_ORIS 0x59
+//#define PC_XORI 0x5A
+//#define PC_XORIS 0x5B
+//#define PC_AND 0x5C
+//#define PC_OR 0x5D
+//#define PC_XOR 0x5E
+//#define PC_NAND 0x5F
+//#define PC_NOR 0x60
+//#define PC_EQV 0x61
+//#define PC_ANDC 0x62
+//#define PC_ORC 0x63
+//#define PC_EXTSB 0x64
+//#define PC_EXTSH 0x65
+//#define PC_CNTLZW 0x66
+//#define PC_RLWINM 0x67
+//#define PC_RLWNM 0x68
+//#define PC_RLWIMI 0x69
+//#define PC_SLW 0x6A
+//#define PC_SRW 0x6B
+//#define PC_SRAWI 0x6C
+//#define PC_SRAW 0x6D
+//#define PC_CRAND 0x6E
+//#define PC_CRANDC 0x6F
+//#define PC_CREQV 0x70
+//#define PC_CRNAND 0x71
+//#define PC_CRNOR 0x72
+//#define PC_CROR 0x73
+//#define PC_CRORC 0x74
+//#define PC_CRXOR 0x75
+//#define PC_MCRF 0x76
+//#define PC_MTXER 0x77
+//#define PC_MTCTR 0x78
+//#define PC_MTLR 0x79
+//#define PC_MTCRF 0x7A
+//#define PC_MTMSR 0x7B
+//#define PC_MTSPR 0x7C
+//#define PC_MFMSR 0x7D
+//#define PC_MFSPR 0x7E
+//#define PC_MFXER 0x7F
+//#define PC_MFCTR 0x80
+//#define PC_MFLR 0x81
+//#define PC_MFCR 0x82
+//#define PC_MFFS 0x83
+//#define PC_MTFSF 0x84
+//#define PC_EIEIO 0x85
+//#define PC_ISYNC 0x86
+//#define PC_SYNC 0x87
+//#define PC_RFI 0x88
+//#define PC_LI 0x89
+//#define PC_LIS 0x8A
+//#define PC_MR 0x8B
+//#define PC_NOP 0x8C
+//#define PC_NOT 0x8D
+//#define PC_LFS 0x8E
+//#define PC_LFSU 0x8F
+//#define PC_LFSX 0x90
+//#define PC_LFSUX 0x91
+//#define PC_LFD 0x92
+//#define PC_LFDU 0x93
+//#define PC_LFDX 0x94
+//#define PC_LFDUX 0x95
+//#define PC_STFS 0x96
+//#define PC_STFSU 0x97
+//#define PC_STFSX 0x98
+//#define PC_STFSUX 0x99
+//#define PC_STFD 0x9A
+//#define PC_STFDU 0x9B
+//#define PC_STFDX 0x9C
+//#define PC_STFDUX 0x9D
+//#define PC_FMR 0x9E
+//#define PC_FABS 0x9F
+//#define PC_FNEG 0xA0
+//#define PC_FNABS 0xA1
+//#define PC_FADD 0xA2
+//#define PC_FADDS 0xA3
+//#define PC_FSUB 0xA4
+//#define PC_FSUBS 0xA5
+//#define PC_FMUL 0xA6
+//#define PC_FMULS 0xA7
+//#define PC_FDIV 0xA8
+//#define PC_FDIVS 0xA9
+//#define PC_FMADD 0xAA
+//#define PC_FMADDS 0xAB
+//#define PC_FMSUB 0xAC
+//#define PC_FMSUBS 0xAD
+//#define PC_FNMADD 0xAE
+//#define PC_FNMADDS 0xAF
+//#define PC_FNMSUB 0xB0
+//#define PC_FNMSUBS 0xB1
+//#define PC_FRES 0xB2
+//#define PC_FRSQRTE 0xB3
+//#define PC_FSEL 0xB4
+//#define PC_FRSP 0xB5
+//#define PC_FCTIW 0xB6
+//#define PC_FCTIWZ 0xB7
+//#define PC_FCMPU 0xB8
+//#define PC_FCMPO 0xB9
+//#define PC_LWARX 0xBA
+//#define PC_LSWI 0xBB
+//#define PC_LSWX 0xBC
+//#define PC_STFIWX 0xBD
+//#define PC_STSWI 0xBE
+//#define PC_STSWX 0xBF
+//#define PC_STWCX 0xC0
+//#define PC_ECIWX 0xC1
+//#define PC_ECOWX 0xC2
+//#define PC_DCBI 0xC3
+//#define PC_ICBI 0xC4
+//#define PC_MCRFS 0xC5
+//#define PC_MCRXR 0xC6
+//#define PC_MFTB 0xC7
+//#define PC_MFSR 0xC8
+//#define PC_MTSR 0xC9
+//#define PC_MFSRIN 0xCA
+//#define PC_MTSRIN 0xCB
+//#define PC_MTFSB0 0xCC
+//#define PC_MTFSB1 0xCD
+//#define PC_MTFSFI 0xCE
+//#define PC_SC 0xCF
+//#define PC_FSQRT 0xD0
+//#define PC_FSQRTS 0xD1
+//#define PC_TLBIA 0xD2
+//#define PC_TLBIE 0xD3
+//#define PC_TLBLD 0xD4
+//#define PC_TLBLI 0xD5
+//#define PC_TLBSYNC 0xD6
+//#define PC_TW 0xD7
+//#define PC_TRAP 0xD8
+//#define PC_TWI 0xD9
+//#define PC_OPWORD 0xDA
+//#define PC_MFROM 0xDB
+//#define PC_DSA 0xDC
+//#define PC_ESA 0xDD
+//#define PC_DCCCI 0xDE
+//#define PC_DCREAD 0xDF
+//#define PC_ICBT 0xE0
+//#define PC_ICCCI 0xE1
+//#define PC_ICREAD 0xE2
+//#define PC_RFCI 0xE3
+//#define PC_TLBRE 0xE4
+//#define PC_TLBSX 0xE5
+//#define PC_TLBWE 0xE6
+//#define PC_WRTEE 0xE7
+//#define PC_WRTEEI 0xE8
+//#define PC_MFDCR 0xE9
+//#define PC_MTDCR 0xEA
+//#define PC_DCBA 0xEB
+//#define PC_DSS 0xEC
+//#define PC_DSSALL 0xED
+//#define PC_DST 0xEE
+//#define PC_DSTT 0xEF
+//#define PC_DSTST 0xF0
+//#define PC_DSTSTT 0xF1
+//#define PC_LVEBX 0xF2
+//#define PC_LVEHX 0xF3
+//#define PC_LVEWX 0xF4
+//#define PC_LVSL 0xF5
+//#define PC_LVSR 0xF6
+//#define PC_LVX 0xF7
+//#define PC_LVXL 0xF8
+//#define PC_STVEBX 0xF9
+//#define PC_STVEHX 0xFA
+//#define PC_STVEWX 0xFB
+//#define PC_STVX 0xFC
+//#define PC_STVXL 0xFD
+//#define PC_MFVSCR 0xFE
+//#define PC_MTVSCR 0xFF
+//#define PC_VADDCUW 0x100
+//#define PC_VADDFP 0x101
+//#define PC_VADDSBS 0x102
+//#define PC_VADDSHS 0x103
+//#define PC_VADDSWS 0x104
+//#define PC_VADDUBM 0x105
+//#define PC_VADDUBS 0x106
+//#define PC_VADDUHM 0x107
+//#define PC_VADDUHS 0x108
+//#define PC_VADDUWM 0x109
+//#define PC_VADDUWS 0x10A
+//#define PC_VAND 0x10B
+//#define PC_VANDC 0x10C
+//#define PC_VAVGSB 0x10D
+//#define PC_VAVGSH 0x10E
+//#define PC_VAVGSW 0x10F
+//#define PC_VAVGUB 0x110
+//#define PC_VAVGUH 0x111
+//#define PC_VAVGUW 0x112
+//#define PC_VCFSX 0x113
+//#define PC_VCFUX 0x114
+//#define PC_VCMPBFP 0x115
+//#define PC_VCMPEQFP 0x116
+//#define PC_VCMPEQUB 0x117
+//#define PC_VCMPEQUH 0x118
+//#define PC_VCMPEQUW 0x119
+//#define PC_VCMPGEFP 0x11A
+//#define PC_VCMPGTFP 0x11B
+//#define PC_VCMPGTSB 0x11C
+//#define PC_VCMPGTSH 0x11D
+//#define PC_VCMPGTSW 0x11E
+//#define PC_VCMPGTUB 0x11F
+//#define PC_VCMPGTUH 0x120
+//#define PC_VCMPGTUW 0x121
+//#define PC_VCTSXS 0x122
+//#define PC_VCTUXS 0x123
+//#define PC_VEXPTEFP 0x124
+//#define PC_VLOGEFP 0x125
+//#define PC_VMAXFP 0x126
+//#define PC_VMAXSB 0x127
+//#define PC_VMAXSH 0x128
+//#define PC_VMAXSW 0x129
+//#define PC_VMAXUB 0x12A
+//#define PC_VMAXUH 0x12B
+//#define PC_VMAXUW 0x12C
+//#define PC_VMINFP 0x12D
+//#define PC_VMINSB 0x12E
+//#define PC_VMINSH 0x12F
+//#define PC_VMINSW 0x130
+//#define PC_VMINUB 0x131
+//#define PC_VMINUH 0x132
+//#define PC_VMINUW 0x133
+//#define PC_VMRGHB 0x134
+//#define PC_VMRGHH 0x135
+//#define PC_VMRGHW 0x136
+//#define PC_VMRGLB 0x137
+//#define PC_VMRGLH 0x138
+//#define PC_VMRGLW 0x139
+//#define PC_VMULESB 0x13A
+//#define PC_VMULESH 0x13B
+//#define PC_VMULEUB 0x13C
+//#define PC_VMULEUH 0x13D
+//#define PC_VMULOSB 0x13E
+//#define PC_VMULOSH 0x13F
+//#define PC_VMULOUB 0x140
+//#define PC_VMULOUH 0x141
+//#define PC_VNOR 0x142
+//#define PC_VOR 0x143
+//#define PC_VPKPX 0x144
+//#define PC_VPKSHSS 0x145
+//#define PC_VPKSHUS 0x146
+//#define PC_VPKSWSS 0x147
+//#define PC_VPKSWUS 0x148
+//#define PC_VPKUHUM 0x149
+//#define PC_VPKUHUS 0x14A
+//#define PC_VPKUWUM 0x14B
+//#define PC_VPKUWUS 0x14C
+//#define PC_VREFP 0x14D
+//#define PC_VRFIM 0x14E
+//#define PC_VRFIN 0x14F
+//#define PC_VRFIP 0x150
+//#define PC_VRFIZ 0x151
+//#define PC_VRLB 0x152
+//#define PC_VRLH 0x153
+//#define PC_VRLW 0x154
+//#define PC_VRSQRTEFP 0x155
+//#define PC_VSL 0x156
+//#define PC_VSLB 0x157
+//#define PC_VSLH 0x158
+//#define PC_VSLO 0x159
+//#define PC_VSLW 0x15A
+//#define PC_VSPLTB 0x15B
+//#define PC_VSPLTH 0x15C
+//#define PC_VSPLTW 0x15D
+//#define PC_VSPLTISB 0x15E
+//#define PC_VSPLTISH 0x15F
+//#define PC_VSPLTISW 0x160
+//#define PC_VSR 0x161
+//#define PC_VSRAB 0x162
+//#define PC_VSRAH 0x163
+//#define PC_VSRAW 0x164
+//#define PC_VSRB 0x165
+//#define PC_VSRH 0x166
+//#define PC_VSRO 0x167
+//#define PC_VSRW 0x168
+//#define PC_VSUBCUW 0x169
+//#define PC_VSUBFP 0x16A
+//#define PC_VSUBSBS 0x16B
+//#define PC_VSUBSHS 0x16C
+//#define PC_VSUBSWS 0x16D
+//#define PC_VSUBUBM 0x16E
+//#define PC_VSUBUBS 0x16F
+//#define PC_VSUBUHM 0x170
+//#define PC_VSUBUHS 0x171
+//#define PC_VSUBUWM 0x172
+//#define PC_VSUBUWS 0x173
+//#define PC_VSUMSWS 0x174
+//#define PC_VSUM2SWS 0x175
+//#define PC_VSUM4SBS 0x176
+//#define PC_VSUM4SHS 0x177
+//#define PC_VSUM4UBS 0x178
+//#define PC_VUPKHPX 0x179
+//#define PC_VUPKHSB 0x17A
+//#define PC_VUPKHSH 0x17B
+//#define PC_VUPKLPX 0x17C
+//#define PC_VUPKLSB 0x17D
+//#define PC_VUPKLSH 0x17E
+//#define PC_VXOR 0x17F
+//#define PC_VMADDFP 0x180
+//#define PC_VMHADDSHS 0x181
+//#define PC_VMHRADDSHS 0x182
+//#define PC_VMLADDUHM 0x183
+//#define PC_VMSUMMBM 0x184
+//#define PC_VMSUMSHM 0x185
+//#define PC_VMSUMSHS 0x186
+//#define PC_VMSUMUBM 0x187
+//#define PC_VMSUMUHM 0x188
+//#define PC_VMSUMUHS 0x189
+//#define PC_VNMSUBFP 0x18A
+//#define PC_VPERM 0x18B
+//#define PC_VSEL 0x18C
+//#define PC_VSLDOI 0x18D
+//#define PC_VMR 0x18E
+//#define PC_VMRP 0x18F
+//#define PC_SLE 0x190
+//#define PC_SLEQ 0x191
+//#define PC_SLIQ 0x192
+//#define PC_SLLIQ 0x193
+//#define PC_SLLQ 0x194
+//#define PC_SLQ 0x195
+//#define PC_SRAIQ 0x196
+//#define PC_SRAQ 0x197
+//#define PC_SRE 0x198
+//#define PC_SREA 0x199
+//#define PC_SREQ 0x19A
+//#define PC_SRIQ 0x19B
+//#define PC_SRLIQ 0x19C
+//#define PC_SRLQ 0x19D
+//#define PC_SRQ 0x19E
+//#define PC_MASKG 0x19F
+//#define PC_MASKIR 0x1A0
+//#define PC_LSCBX 0x1A1
+//#define PC_DIV 0x1A2
+//#define PC_DIVS 0x1A3
+//#define PC_DOZ 0x1A4
+//#define PC_MUL 0x1A5
+//#define PC_NABS 0x1A6
+//#define PC_ABS 0x1A7
+//#define PC_CLCS 0x1A8
+//#define PC_DOZI 0x1A9
+//#define PC_RLMI 0x1AA
+//#define PC_RRIB 0x1AB
+//#define PC_PENTRY 0x1AC
+//#define PC_PEXIT 0x1AD
+//#define OPCODE_MAX 0x1AE
+const short PC_B = 0x0;
+const short PC_BL = 0x1;
+const short PC_BC = 0x2;
+const short PC_BCLR = 0x3;
+const short PC_BCCTR = 0x4;
+const short PC_BT = 0x5;
+const short PC_BTLR = 0x6;
+const short PC_BTCTR = 0x7;
+const short PC_BF = 0x8;
+const short PC_BFLR = 0x9;
+const short PC_BFCTR = 0xA;
+const short PC_BDNZ = 0xB;
+const short PC_BDNZT = 0xC;
+const short PC_BDNZF = 0xD;
+const short PC_BDZ = 0xE;
+const short PC_BDZT = 0xF;
+const short PC_BDZF = 0x10;
+const short PC_BLR = 0x11;
+const short PC_BCTR = 0x12;
+const short PC_BCTRL = 0x13;
+const short PC_BLRL = 0x14;
+const short PC_LBZ = 0x15;
+const short PC_LBZU = 0x16;
+const short PC_LBZX = 0x17;
+const short PC_LBZUX = 0x18;
+const short PC_LHZ = 0x19;
+const short PC_LHZU = 0x1A;
+const short PC_LHZX = 0x1B;
+const short PC_LHZUX = 0x1C;
+const short PC_LHA = 0x1D;
+const short PC_LHAU = 0x1E;
+const short PC_LHAX = 0x1F;
+const short PC_LHAUX = 0x20;
+const short PC_LHBRX = 0x21;
+const short PC_LWZ = 0x22;
+const short PC_LWZU = 0x23;
+const short PC_LWZX = 0x24;
+const short PC_LWZUX = 0x25;
+const short PC_LWBRX = 0x26;
+const short PC_LMW = 0x27;
+const short PC_STB = 0x28;
+const short PC_STBU = 0x29;
+const short PC_STBX = 0x2A;
+const short PC_STBUX = 0x2B;
+const short PC_STH = 0x2C;
+const short PC_STHU = 0x2D;
+const short PC_STHX = 0x2E;
+const short PC_STHUX = 0x2F;
+const short PC_STHBRX = 0x30;
+const short PC_STW = 0x31;
+const short PC_STWU = 0x32;
+const short PC_STWX = 0x33;
+const short PC_STWUX = 0x34;
+const short PC_STWBRX = 0x35;
+const short PC_STMW = 0x36;
+const short PC_DCBF = 0x37;
+const short PC_DCBST = 0x38;
+const short PC_DCBT = 0x39;
+const short PC_DCBTST = 0x3A;
+const short PC_DCBZ = 0x3B;
+const short PC_ADD = 0x3C;
+const short PC_ADDC = 0x3D;
+const short PC_ADDE = 0x3E;
+const short PC_ADDI = 0x3F;
+const short PC_ADDIC = 0x40;
+const short PC_ADDICR = 0x41;
+const short PC_ADDIS = 0x42;
+const short PC_ADDME = 0x43;
+const short PC_ADDZE = 0x44;
+const short PC_DIVW = 0x45;
+const short PC_DIVWU = 0x46;
+const short PC_MULHW = 0x47;
+const short PC_MULHWU = 0x48;
+const short PC_MULLI = 0x49;
+const short PC_MULLW = 0x4A;
+const short PC_NEG = 0x4B;
+const short PC_SUBF = 0x4C;
+const short PC_SUBFC = 0x4D;
+const short PC_SUBFE = 0x4E;
+const short PC_SUBFIC = 0x4F;
+const short PC_SUBFME = 0x50;
+const short PC_SUBFZE = 0x51;
+const short PC_CMPI = 0x52;
+const short PC_CMP = 0x53;
+const short PC_CMPLI = 0x54;
+const short PC_CMPL = 0x55;
+const short PC_ANDI = 0x56;
+const short PC_ANDIS = 0x57;
+const short PC_ORI = 0x58;
+const short PC_ORIS = 0x59;
+const short PC_XORI = 0x5A;
+const short PC_XORIS = 0x5B;
+const short PC_AND = 0x5C;
+const short PC_OR = 0x5D;
+const short PC_XOR = 0x5E;
+const short PC_NAND = 0x5F;
+const short PC_NOR = 0x60;
+const short PC_EQV = 0x61;
+const short PC_ANDC = 0x62;
+const short PC_ORC = 0x63;
+const short PC_EXTSB = 0x64;
+const short PC_EXTSH = 0x65;
+const short PC_CNTLZW = 0x66;
+const short PC_RLWINM = 0x67;
+const short PC_RLWNM = 0x68;
+const short PC_RLWIMI = 0x69;
+const short PC_SLW = 0x6A;
+const short PC_SRW = 0x6B;
+const short PC_SRAWI = 0x6C;
+const short PC_SRAW = 0x6D;
+const short PC_CRAND = 0x6E;
+const short PC_CRANDC = 0x6F;
+const short PC_CREQV = 0x70;
+const short PC_CRNAND = 0x71;
+const short PC_CRNOR = 0x72;
+const short PC_CROR = 0x73;
+const short PC_CRORC = 0x74;
+const short PC_CRXOR = 0x75;
+const short PC_MCRF = 0x76;
+const short PC_MTXER = 0x77;
+const short PC_MTCTR = 0x78;
+const short PC_MTLR = 0x79;
+const short PC_MTCRF = 0x7A;
+const short PC_MTMSR = 0x7B;
+const short PC_MTSPR = 0x7C;
+const short PC_MFMSR = 0x7D;
+const short PC_MFSPR = 0x7E;
+const short PC_MFXER = 0x7F;
+const short PC_MFCTR = 0x80;
+const short PC_MFLR = 0x81;
+const short PC_MFCR = 0x82;
+const short PC_MFFS = 0x83;
+const short PC_MTFSF = 0x84;
+const short PC_EIEIO = 0x85;
+const short PC_ISYNC = 0x86;
+const short PC_SYNC = 0x87;
+const short PC_RFI = 0x88;
+const short PC_LI = 0x89;
+const short PC_LIS = 0x8A;
+const short PC_MR = 0x8B;
+const short PC_NOP = 0x8C;
+const short PC_NOT = 0x8D;
+const short PC_LFS = 0x8E;
+const short PC_LFSU = 0x8F;
+const short PC_LFSX = 0x90;
+const short PC_LFSUX = 0x91;
+const short PC_LFD = 0x92;
+const short PC_LFDU = 0x93;
+const short PC_LFDX = 0x94;
+const short PC_LFDUX = 0x95;
+const short PC_STFS = 0x96;
+const short PC_STFSU = 0x97;
+const short PC_STFSX = 0x98;
+const short PC_STFSUX = 0x99;
+const short PC_STFD = 0x9A;
+const short PC_STFDU = 0x9B;
+const short PC_STFDX = 0x9C;
+const short PC_STFDUX = 0x9D;
+const short PC_FMR = 0x9E;
+const short PC_FABS = 0x9F;
+const short PC_FNEG = 0xA0;
+const short PC_FNABS = 0xA1;
+const short PC_FADD = 0xA2;
+const short PC_FADDS = 0xA3;
+const short PC_FSUB = 0xA4;
+const short PC_FSUBS = 0xA5;
+const short PC_FMUL = 0xA6;
+const short PC_FMULS = 0xA7;
+const short PC_FDIV = 0xA8;
+const short PC_FDIVS = 0xA9;
+const short PC_FMADD = 0xAA;
+const short PC_FMADDS = 0xAB;
+const short PC_FMSUB = 0xAC;
+const short PC_FMSUBS = 0xAD;
+const short PC_FNMADD = 0xAE;
+const short PC_FNMADDS = 0xAF;
+const short PC_FNMSUB = 0xB0;
+const short PC_FNMSUBS = 0xB1;
+const short PC_FRES = 0xB2;
+const short PC_FRSQRTE = 0xB3;
+const short PC_FSEL = 0xB4;
+const short PC_FRSP = 0xB5;
+const short PC_FCTIW = 0xB6;
+const short PC_FCTIWZ = 0xB7;
+const short PC_FCMPU = 0xB8;
+const short PC_FCMPO = 0xB9;
+const short PC_LWARX = 0xBA;
+const short PC_LSWI = 0xBB;
+const short PC_LSWX = 0xBC;
+const short PC_STFIWX = 0xBD;
+const short PC_STSWI = 0xBE;
+const short PC_STSWX = 0xBF;
+const short PC_STWCX = 0xC0;
+const short PC_ECIWX = 0xC1;
+const short PC_ECOWX = 0xC2;
+const short PC_DCBI = 0xC3;
+const short PC_ICBI = 0xC4;
+const short PC_MCRFS = 0xC5;
+const short PC_MCRXR = 0xC6;
+const short PC_MFTB = 0xC7;
+const short PC_MFSR = 0xC8;
+const short PC_MTSR = 0xC9;
+const short PC_MFSRIN = 0xCA;
+const short PC_MTSRIN = 0xCB;
+const short PC_MTFSB0 = 0xCC;
+const short PC_MTFSB1 = 0xCD;
+const short PC_MTFSFI = 0xCE;
+const short PC_SC = 0xCF;
+const short PC_FSQRT = 0xD0;
+const short PC_FSQRTS = 0xD1;
+const short PC_TLBIA = 0xD2;
+const short PC_TLBIE = 0xD3;
+const short PC_TLBLD = 0xD4;
+const short PC_TLBLI = 0xD5;
+const short PC_TLBSYNC = 0xD6;
+const short PC_TW = 0xD7;
+const short PC_TRAP = 0xD8;
+const short PC_TWI = 0xD9;
+const short PC_OPWORD = 0xDA;
+const short PC_MFROM = 0xDB;
+const short PC_DSA = 0xDC;
+const short PC_ESA = 0xDD;
+const short PC_DCCCI = 0xDE;
+const short PC_DCREAD = 0xDF;
+const short PC_ICBT = 0xE0;
+const short PC_ICCCI = 0xE1;
+const short PC_ICREAD = 0xE2;
+const short PC_RFCI = 0xE3;
+const short PC_TLBRE = 0xE4;
+const short PC_TLBSX = 0xE5;
+const short PC_TLBWE = 0xE6;
+const short PC_WRTEE = 0xE7;
+const short PC_WRTEEI = 0xE8;
+const short PC_MFDCR = 0xE9;
+const short PC_MTDCR = 0xEA;
+const short PC_DCBA = 0xEB;
+const short PC_DSS = 0xEC;
+const short PC_DSSALL = 0xED;
+const short PC_DST = 0xEE;
+const short PC_DSTT = 0xEF;
+const short PC_DSTST = 0xF0;
+const short PC_DSTSTT = 0xF1;
+const short PC_LVEBX = 0xF2;
+const short PC_LVEHX = 0xF3;
+const short PC_LVEWX = 0xF4;
+const short PC_LVSL = 0xF5;
+const short PC_LVSR = 0xF6;
+const short PC_LVX = 0xF7;
+const short PC_LVXL = 0xF8;
+const short PC_STVEBX = 0xF9;
+const short PC_STVEHX = 0xFA;
+const short PC_STVEWX = 0xFB;
+const short PC_STVX = 0xFC;
+const short PC_STVXL = 0xFD;
+const short PC_MFVSCR = 0xFE;
+const short PC_MTVSCR = 0xFF;
+const short PC_VADDCUW = 0x100;
+const short PC_VADDFP = 0x101;
+const short PC_VADDSBS = 0x102;
+const short PC_VADDSHS = 0x103;
+const short PC_VADDSWS = 0x104;
+const short PC_VADDUBM = 0x105;
+const short PC_VADDUBS = 0x106;
+const short PC_VADDUHM = 0x107;
+const short PC_VADDUHS = 0x108;
+const short PC_VADDUWM = 0x109;
+const short PC_VADDUWS = 0x10A;
+const short PC_VAND = 0x10B;
+const short PC_VANDC = 0x10C;
+const short PC_VAVGSB = 0x10D;
+const short PC_VAVGSH = 0x10E;
+const short PC_VAVGSW = 0x10F;
+const short PC_VAVGUB = 0x110;
+const short PC_VAVGUH = 0x111;
+const short PC_VAVGUW = 0x112;
+const short PC_VCFSX = 0x113;
+const short PC_VCFUX = 0x114;
+const short PC_VCMPBFP = 0x115;
+const short PC_VCMPEQFP = 0x116;
+const short PC_VCMPEQUB = 0x117;
+const short PC_VCMPEQUH = 0x118;
+const short PC_VCMPEQUW = 0x119;
+const short PC_VCMPGEFP = 0x11A;
+const short PC_VCMPGTFP = 0x11B;
+const short PC_VCMPGTSB = 0x11C;
+const short PC_VCMPGTSH = 0x11D;
+const short PC_VCMPGTSW = 0x11E;
+const short PC_VCMPGTUB = 0x11F;
+const short PC_VCMPGTUH = 0x120;
+const short PC_VCMPGTUW = 0x121;
+const short PC_VCTSXS = 0x122;
+const short PC_VCTUXS = 0x123;
+const short PC_VEXPTEFP = 0x124;
+const short PC_VLOGEFP = 0x125;
+const short PC_VMAXFP = 0x126;
+const short PC_VMAXSB = 0x127;
+const short PC_VMAXSH = 0x128;
+const short PC_VMAXSW = 0x129;
+const short PC_VMAXUB = 0x12A;
+const short PC_VMAXUH = 0x12B;
+const short PC_VMAXUW = 0x12C;
+const short PC_VMINFP = 0x12D;
+const short PC_VMINSB = 0x12E;
+const short PC_VMINSH = 0x12F;
+const short PC_VMINSW = 0x130;
+const short PC_VMINUB = 0x131;
+const short PC_VMINUH = 0x132;
+const short PC_VMINUW = 0x133;
+const short PC_VMRGHB = 0x134;
+const short PC_VMRGHH = 0x135;
+const short PC_VMRGHW = 0x136;
+const short PC_VMRGLB = 0x137;
+const short PC_VMRGLH = 0x138;
+const short PC_VMRGLW = 0x139;
+const short PC_VMULESB = 0x13A;
+const short PC_VMULESH = 0x13B;
+const short PC_VMULEUB = 0x13C;
+const short PC_VMULEUH = 0x13D;
+const short PC_VMULOSB = 0x13E;
+const short PC_VMULOSH = 0x13F;
+const short PC_VMULOUB = 0x140;
+const short PC_VMULOUH = 0x141;
+const short PC_VNOR = 0x142;
+const short PC_VOR = 0x143;
+const short PC_VPKPX = 0x144;
+const short PC_VPKSHSS = 0x145;
+const short PC_VPKSHUS = 0x146;
+const short PC_VPKSWSS = 0x147;
+const short PC_VPKSWUS = 0x148;
+const short PC_VPKUHUM = 0x149;
+const short PC_VPKUHUS = 0x14A;
+const short PC_VPKUWUM = 0x14B;
+const short PC_VPKUWUS = 0x14C;
+const short PC_VREFP = 0x14D;
+const short PC_VRFIM = 0x14E;
+const short PC_VRFIN = 0x14F;
+const short PC_VRFIP = 0x150;
+const short PC_VRFIZ = 0x151;
+const short PC_VRLB = 0x152;
+const short PC_VRLH = 0x153;
+const short PC_VRLW = 0x154;
+const short PC_VRSQRTEFP = 0x155;
+const short PC_VSL = 0x156;
+const short PC_VSLB = 0x157;
+const short PC_VSLH = 0x158;
+const short PC_VSLO = 0x159;
+const short PC_VSLW = 0x15A;
+const short PC_VSPLTB = 0x15B;
+const short PC_VSPLTH = 0x15C;
+const short PC_VSPLTW = 0x15D;
+const short PC_VSPLTISB = 0x15E;
+const short PC_VSPLTISH = 0x15F;
+const short PC_VSPLTISW = 0x160;
+const short PC_VSR = 0x161;
+const short PC_VSRAB = 0x162;
+const short PC_VSRAH = 0x163;
+const short PC_VSRAW = 0x164;
+const short PC_VSRB = 0x165;
+const short PC_VSRH = 0x166;
+const short PC_VSRO = 0x167;
+const short PC_VSRW = 0x168;
+const short PC_VSUBCUW = 0x169;
+const short PC_VSUBFP = 0x16A;
+const short PC_VSUBSBS = 0x16B;
+const short PC_VSUBSHS = 0x16C;
+const short PC_VSUBSWS = 0x16D;
+const short PC_VSUBUBM = 0x16E;
+const short PC_VSUBUBS = 0x16F;
+const short PC_VSUBUHM = 0x170;
+const short PC_VSUBUHS = 0x171;
+const short PC_VSUBUWM = 0x172;
+const short PC_VSUBUWS = 0x173;
+const short PC_VSUMSWS = 0x174;
+const short PC_VSUM2SWS = 0x175;
+const short PC_VSUM4SBS = 0x176;
+const short PC_VSUM4SHS = 0x177;
+const short PC_VSUM4UBS = 0x178;
+const short PC_VUPKHPX = 0x179;
+const short PC_VUPKHSB = 0x17A;
+const short PC_VUPKHSH = 0x17B;
+const short PC_VUPKLPX = 0x17C;
+const short PC_VUPKLSB = 0x17D;
+const short PC_VUPKLSH = 0x17E;
+const short PC_VXOR = 0x17F;
+const short PC_VMADDFP = 0x180;
+const short PC_VMHADDSHS = 0x181;
+const short PC_VMHRADDSHS = 0x182;
+const short PC_VMLADDUHM = 0x183;
+const short PC_VMSUMMBM = 0x184;
+const short PC_VMSUMSHM = 0x185;
+const short PC_VMSUMSHS = 0x186;
+const short PC_VMSUMUBM = 0x187;
+const short PC_VMSUMUHM = 0x188;
+const short PC_VMSUMUHS = 0x189;
+const short PC_VNMSUBFP = 0x18A;
+const short PC_VPERM = 0x18B;
+const short PC_VSEL = 0x18C;
+const short PC_VSLDOI = 0x18D;
+const short PC_VMR = 0x18E;
+const short PC_VMRP = 0x18F;
+const short PC_SLE = 0x190;
+const short PC_SLEQ = 0x191;
+const short PC_SLIQ = 0x192;
+const short PC_SLLIQ = 0x193;
+const short PC_SLLQ = 0x194;
+const short PC_SLQ = 0x195;
+const short PC_SRAIQ = 0x196;
+const short PC_SRAQ = 0x197;
+const short PC_SRE = 0x198;
+const short PC_SREA = 0x199;
+const short PC_SREQ = 0x19A;
+const short PC_SRIQ = 0x19B;
+const short PC_SRLIQ = 0x19C;
+const short PC_SRLQ = 0x19D;
+const short PC_SRQ = 0x19E;
+const short PC_MASKG = 0x19F;
+const short PC_MASKIR = 0x1A0;
+const short PC_LSCBX = 0x1A1;
+const short PC_DIV = 0x1A2;
+const short PC_DIVS = 0x1A3;
+const short PC_DOZ = 0x1A4;
+const short PC_MUL = 0x1A5;
+const short PC_NABS = 0x1A6;
+const short PC_ABS = 0x1A7;
+const short PC_CLCS = 0x1A8;
+const short PC_DOZI = 0x1A9;
+const short PC_RLMI = 0x1AA;
+const short PC_RRIB = 0x1AB;
+const short PC_PENTRY = 0x1AC;
+const short PC_PEXIT = 0x1AD;
+const short OPCODE_MAX = 0x1AE;
+
+extern OpcodeInfo opcodeinfo[OPCODE_MAX];
+
+extern void pcode_get_hi_lo(int bits, char typechar, SInt32 *hi, SInt32 *lo);
+extern int pcode_check_imm_bits(SInt32 value, int bits, char typechar);
+extern int pcode_const_from_format(const char *format, int *pResult);
+extern PCode *vformatpcode(short opcode, va_list argList);
+extern int expectandformatoperand(PCodeArg *operand, PCOpKind expectedKind, char a3, int bitCount, char *buf);
+extern int formatoperand(PCodeArg *operand, char *buf);
+extern void formatoperands(PCode *pcode, char *buf, int showBasicBlocks);
+extern PCode *makecopyinstruction(PCodeArg *a, PCodeArg *b);
+extern int is_location_independent(PCode *pcode);
+extern int can_reuse_stored_value(PCode *a, PCode *b);
+extern int nbytes_loaded_or_stored_by(PCode *pcode);
+extern void change_num_operands(PCode *pcode, int newNum);
+extern void change_opcode(PCode *pcode, short opcode);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/PCodeUtilities.h b/includes/compiler/PCodeUtilities.h
new file mode 100644
index 0000000..312dd55
--- /dev/null
+++ b/includes/compiler/PCodeUtilities.h
@@ -0,0 +1,23 @@
+#ifndef COMPILER_PCODEUTILITIES_H
+#define COMPILER_PCODEUTILITIES_H
+
+#include "compiler/common.h"
+
+extern void pcsetrecordbit(PCode *pc);
+extern void pcsetsideeffects(PCode *pc);
+extern void pcsetlinkbit(PCode *pc);
+extern void branch_label(PCodeLabel *label);
+extern void branch_conditional(short a, short compareop, short c, PCodeLabel *label);
+extern void branch_always(PCodeLabel *label);
+extern void branch_decrement_always(short opcode, PCodeLabel *label);
+extern void branch_indirect(Object *obj);
+extern int branch_count_volatiles(void);
+extern PCodeArg *branch_record_volatiles(PCodeArg *arglist, UInt32 *masks);
+extern void branch_subroutine(Object *obj, short add_nop, UInt32 *masks);
+extern void branch_subroutine_ctr(UInt32 *masks);
+extern void add_immediate(short dest_reg, short base_reg, Object *obj, short offset);
+extern PCode *add_immediate_lo(short dest_reg, short base_reg, Object *obj, short offset, char add_to_block);
+extern PCode *op_absolute_ha(short dest_reg, short base_reg, Object *obj, short offset, char add_to_block);
+extern void load_store_register(short opcode, short dest_reg, short base_reg, Object *obj, SInt32 offset);
+
+#endif
diff --git a/includes/compiler/StackFrame.h b/includes/compiler/StackFrame.h
new file mode 100644
index 0000000..3145bdb
--- /dev/null
+++ b/includes/compiler/StackFrame.h
@@ -0,0 +1,60 @@
+#ifndef COMPILER_STACKFRAME_H
+#define COMPILER_STACKFRAME_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+enum ObjClass {
+    ObjClass0,
+    ObjClass1,
+    ObjClass2,
+    ObjClassMax
+};
+
+extern Boolean requires_frame;
+extern Boolean makes_call;
+extern Boolean uses_globals;
+extern Boolean dynamic_stack;
+extern Boolean large_stack;
+extern Object *dummyvaparam;
+extern void *dummyprofiler;
+
+extern void init_stack_globals(void);
+extern void init_frame_sizes(void);
+extern void assign_local_memory(Object *obj);
+extern void assign_locals_to_memory(ObjectList *first);
+extern void compute_frame_sizes(void);
+extern void generate_prologue(PCodeBlock *block);
+extern void generate_epilogue(PCodeBlock *block, Boolean add_blr);
+extern void allocate_dynamic_stack_space(Boolean flag1, int reg1, int reg2, SInt32 size);
+extern char *generate_traceback(SInt32 funcsize, char *funcname, SInt32 *tbsize, Object *func);
+extern void check_dynamic_aligned_frame(void);
+extern void move_varargs_to_memory(void);
+extern void assign_arguments_to_memory(Object *func, UInt8 mysteryFlag, Boolean hasVarargs);
+extern SInt32 set_out_param_displ(SInt32 a, Type *type, Boolean flag, SInt32 *outvar, SInt32 b);
+extern SInt32 out_param_displ_to_offset(SInt32 displ);
+extern Boolean needs_frame(void);
+extern void update_out_param_size(SInt32 size);
+extern void estimate_out_param_size(SInt32 size);
+extern void update_out_param_align(SInt32 align);
+extern void update_in_param_align(SInt32 align);
+extern void update_frame_align(SInt32 align);
+extern SInt32 local_offset_32(Object *obj);
+extern SInt16 local_offset_lo(Object *obj, SInt32 offset);
+extern SInt16 local_offset_ha(Object *obj, SInt32 offset);
+extern SInt16 local_offset_16(Object *obj);
+extern Boolean local_is_16bit_offset(Object *obj);
+extern int local_base_register(Object *obj);
+extern Boolean is_large_frame(void);
+extern void no_frame_for_asm(void);
+extern Boolean can_add_displ_to_local(Object *obj, SInt32 displ);
+extern SInt32 get_alloca_alignment(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/TOC.h b/includes/compiler/TOC.h
new file mode 100644
index 0000000..59ec8a1
--- /dev/null
+++ b/includes/compiler/TOC.h
@@ -0,0 +1,60 @@
+#ifndef COMPILER_TOC_H
+#define COMPILER_TOC_H
+
+#include "compiler/common.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct CodeLabelList {
+    struct CodeLabelList *next;
+    Object *object;
+    CLabel *label;
+} CodeLabelList;
+
+extern ObjectList *toclist;
+extern ObjectList *exceptionlist;
+extern void *descriptorlist;
+extern void *floatconstpool;
+extern void *doubleconstpool;
+extern ObjectList *floatconstlist;
+extern void *vectorconstpool;
+extern ObjectList *vectorconstlist;
+extern Object toc0;
+extern Boolean no_descriptors;
+extern Object pic_base;
+extern VarInfo pic_base_varinfo;
+extern short pic_base_reg;
+extern CodeLabelList *codelabellist;
+
+extern void setupaddressing(void);
+extern void createNonLazyPointer(Object *obj);
+extern void referenceIndirectPointer(Object *obj);
+extern Object *createIndirect(Object *obj, Boolean flag1, Boolean flag2);
+extern Object *createfloatconstant(Type *type, Float *data);
+extern Object *createvectorconstant(Type *type, MWVector128 *data);
+extern void DeclarePooledConstants();
+extern Object *CreateFloatConst(Type *type, Float *data, SInt32 *unkptr);
+extern void dumpcodelabels(Object *func);
+typedef struct COVCResult {
+    // this struct might be used in other places too???
+    short op1;
+    short op2;
+    unsigned char arg;
+} COVCResult;
+extern Boolean canoptimizevectorconst(MWVector128 *vecp, Type *type, COVCResult *result);
+extern Boolean TOC_use_fsel(ENode *expr);
+extern Boolean TOC_use_isel(ENode *expr, Boolean flag);
+extern SInt32 GetSizeSkip(ENode *expr);
+extern void Optimize64bitMath(ENode *expr);
+extern void expandTOCreferences(Statement **stmts);
+extern void resetTOCvarinfo(void);
+extern Boolean needdescriptor(void);
+extern Object *createstaticinitobject(void);
+
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+#endif
diff --git a/includes/compiler/common.h b/includes/compiler/common.h
index b5909e2..15043f5 100644
--- a/includes/compiler/common.h
+++ b/includes/compiler/common.h
@@ -94,27 +94,34 @@ typedef enum Section {
     SECT_MW_SWITCH = 30,
     SECT_8BYTE_LITERALS = 31,
     SECT_4BYTE_LITERALS = 32,
+    // one of these next 2 is missing in pro7
     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
+    SECT_CONST = 34,
+    SECT_CONST_PTR = 35,
+    // everything after here is known ok
+    SECT_NONLAZY_PTRS = 36,
+    SECT_COMMON_VARS = 37,
+    SECT_16BYTE_LITERALS = 38,
+    SECT_TEXT_COALESCE = 39,
+    SECT_DATA_COALESCE = 40,
+    SECT_UDATA_COALESCE = 41,
+    SECT_CONST_COALESCE = 42,
+    SECT_CONST_PTR_COALESCE = 43,
+    SECT_CSTR_COALESCE = 44,
+    N_SECTIONS = 45
 } Section;
 
 typedef struct BClassList BClassList;
 typedef struct CI_FuncData CI_FuncData;
 typedef struct CLabel CLabel;
+typedef struct ClassList ClassList;
+typedef struct CParams CParams;
+typedef struct DeclInfo DeclInfo;
+typedef struct DeclThing DeclThing; // rename me please
 typedef struct DefArgCtorInfo DefArgCtorInfo;
 typedef struct DepName DepName;
+typedef struct EMemberInfo EMemberInfo;
 typedef struct ENode ENode;
 typedef struct ENodeList ENodeList;
 typedef struct ExceptionAction ExceptionAction;
@@ -139,6 +146,11 @@ typedef struct Object Object;
 typedef struct ObjectList ObjectList;
 typedef struct ObjCInfo ObjCInfo;
 typedef struct ObjCMethod ObjCMethod;
+typedef struct Operand Operand;
+typedef struct PackedDeclInfo PackedDeclInfo;
+typedef struct PCode PCode;
+typedef struct PCodeArg PCodeArg;
+typedef struct PCodeBlock PCodeBlock;
 typedef struct PCodeLabel PCodeLabel;
 typedef struct PointsToFunction PointsToFunction;
 typedef struct PTFList PTFList;
@@ -166,6 +178,7 @@ typedef struct TypeClass TypeClass;
 typedef struct TypeEnum TypeEnum;
 typedef struct TypeFunc TypeFunc;
 typedef struct TypeIntegral TypeIntegral;
+typedef struct TypeList TypeList;
 typedef struct TypeMemberPointer TypeMemberPointer;
 typedef struct TypeMethod TypeMethod;
 typedef struct TypePointer TypePointer;
@@ -173,6 +186,7 @@ typedef struct TypeStruct TypeStruct;
 typedef struct TypeTemplDep TypeTemplDep;
 typedef struct VarInfo VarInfo;
 typedef struct VarRecord VarRecord;
+typedef struct VClassList VClassList;
 
 // Common bits for templates
 typedef enum TemplParamType {
@@ -262,7 +276,12 @@ enum {
     Q_BYCOPY = 0x2000,
     Q_BYREF = 0x4000,
     Q_ONEWAY = 0x8000,
+    Q_10000 = 0x10000,
+    Q_20000 = 0x20000,
+    Q_OVERLOAD = 0x40000, // weak
+    Q_80000 = 0x80000,
     Q_RESTRICT = 0x200000,
+    Q_1000000 = 0x1000000,
     Q_ALIGNED_1 = 0x2000000,
     Q_ALIGNED_2 = 0x4000000,
     Q_ALIGNED_4 = 0x6000000,
@@ -280,4 +299,42 @@ enum {
     Q_ALIGNED_MASK = 0x1E000000
 };
 
+enum {
+    EXPORT_FLAGS_INTERNAL = 0x10,
+    EXPORT_FLAGS_IMPORT = 0x20,
+    EXPORT_FLAGS_EXPORT = 0x40
+};
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+struct CParams {
+    CWPluginContext context;
+    CWObjectData objectdata;
+    Handle objectDataHandle;
+    Handle browseDataHandle;
+    SInt32 pluginRequest;
+    SInt32 apiVersion;
+    FSSpec projectFile;
+    SInt32 projectFileCount;
+    SInt32 mainFileNumber;
+    FSSpec mainFileSpec;
+    const char *mainFileText;
+    SInt32 mainFileTextLength;
+    Boolean isPrecompiling;
+    Boolean isAutoPrecompiling;
+    Boolean isPreprocessing;
+    Boolean isGeneratingDebugInfo;
+    Boolean isCachingPrecompiledHeaders;
+    CWBrowseOptions browseOptions;
+    Boolean field276;
+    SInt16 mainFileID;
+    CWDataType targetOS;
+    CWDataType targetCPU;
+    char *targetName;
+};
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
 #endif
diff --git a/includes/compiler/enode.h b/includes/compiler/enode.h
index 6e0ab2c..e12b1ae 100644
--- a/includes/compiler/enode.h
+++ b/includes/compiler/enode.h
@@ -75,6 +75,7 @@ typedef enum ENodeType {
     ESETCONST,
     ENEWEXCEPTION,
     ENEWEXCEPTIONARRAY,
+    EMYSTERY67, // no name???
     EOBJLIST,
     EMEMBER,
     ETEMPLDEP,
@@ -88,6 +89,15 @@ typedef enum ENodeType {
 } ENodeType;
 
 
+struct EMemberInfo {
+    BClassList *path;
+    ENodeList *nodes;
+    void *x8;
+    void *xC;
+    void *x10;
+};
+
+
 struct ENodeList {
     ENodeList *next;
     ENode *node;
@@ -116,7 +126,7 @@ typedef union ENodeUnion {
         ENodeList *args;
         TypeFunc *functype;
     } funccall;
-    ObjAccess objaccess;
+    //ObjAccess objaccess;
     struct {
         ENode *accessnode;
         ENode *mfpointer;
@@ -135,7 +145,7 @@ typedef union ENodeUnion {
     struct {
         SInt32 size;
         char *data;
-        SInt32 segnum;
+        //SInt32 segnum; ??
         char ispascal;
         char ispacked;
     } string;
@@ -159,6 +169,10 @@ typedef union ENodeUnion {
         Object *objref;
         SInt32 offset;
     } addr;
+    struct {
+        NameSpaceObjectList *list;
+        TemplArg *templargs;
+    } objlist;
     void *inst;
     MemInitializer *ctorinit;
     Statement *stmt;
@@ -187,7 +201,7 @@ typedef union ENodeUnion {
                 HashNameNode *name;
                 TemplArg *args;
             } qualtempl;
-            ObjAccess objaccess;
+            //ObjAccess objaccess;
             struct {
                 ENode *expr;
                 TStreamElement *token;
@@ -197,7 +211,8 @@ typedef union ENodeUnion {
                 ENode *expr;
                 ENodeList *args;
             } funccall;
-            struct {
+            // have my doubts about this one
+            /*struct {
                 Type *type;
                 UInt32 qual;
                 ENode *arraydim;
@@ -205,7 +220,7 @@ typedef union ENodeUnion {
                 ENodeList *initlist;
                 Boolean is_global;
                 Boolean has_init;
-            } nw;
+            } nw;*/
             struct {
                 ENode *expr;
                 Boolean is_global;
@@ -242,7 +257,7 @@ typedef union ENodeUnion {
 struct ENode {
     ENodeType type;
     UInt8 cost;
-    UInt16 flags; // &1, &2 correspond to quals
+    UInt16 flags;
     Boolean ignored;
     Boolean hascall;
     // void *loc; - might not be in pro7?
@@ -254,9 +269,16 @@ struct ENode {
 enum {
     ENODE_FLAG_CONST = Q_CONST,
     ENODE_FLAG_VOLATILE = Q_VOLATILE,
-    ENODE_FLAG_QUALS = Q_CONST | Q_VOLATILE
+    ENODE_FLAG_QUALS = Q_CONST | Q_VOLATILE,
+    ENODE_FLAG_10 = 0x10,
+    ENODE_FLAG_80 = 0x80
 };
 
+#define ENODE_IS(_enode, _etype) ( (_enode)->type == (_etype) )
+#define ENODE_IS2(_enode, _etype1, _etype2) ( ENODE_IS(_enode, (_etype1)) || ENODE_IS(_enode, (_etype2)) )
+#define ENODE_IS3(_enode, _etype1, _etype2, _etype3) ( ENODE_IS(_enode, (_etype1)) || ENODE_IS(_enode, (_etype2)) || ENODE_IS(_enode, (_etype3)) )
+#define ENODE_IS_RANGE(_enode, _lo, _hi) ( ((_enode)->type >= (_lo)) && ((_enode)->type <= (_hi)) )
+
 #ifdef __MWERKS__
 #pragma options align=reset
 #endif
diff --git a/includes/compiler/objects.h b/includes/compiler/objects.h
index 32552ec..5f01d26 100644
--- a/includes/compiler/objects.h
+++ b/includes/compiler/objects.h
@@ -47,7 +47,7 @@ struct ObjType {
     ObjectType otype;
     AccessType access;
     Type *type;
-    void *unk6;
+    UInt32 qual;
 };
 
 
@@ -184,6 +184,25 @@ struct Object {
     } u;
 };
 
+enum {
+    OBJECT_FLAGS_UNUSED = 1,
+    OBJECT_FLAGS_2 = 2,
+    OBJECT_FLAGS_4 = 4,
+    OBJECT_FLAGS_8 = 8,
+    OBJECT_FLAGS_10 = 0x10, // internal
+    OBJECT_FLAGS_20 = 0x20, // import
+    OBJECT_FLAGS_40 = 0x40, // export
+    OBJECT_FLAGS_60 = 0x60  // lib export
+};
+
+enum {
+    OBJECT_SCLASS_101 = 0x101,
+    OBJECT_SCLASS_102 = 0x102,
+    OBJECT_SCLASS_103 = 0x103,
+    OBJECT_SCLASS_104 = 0x104,
+    OBJECT_SCLASS_12B = 0x12B
+};
+
 #define OBJ_BASE(obj) ((ObjBase *) (obj))
 #define OBJ_ENUM_CONST(obj) ((ObjEnumConst *) (obj))
 #define OBJ_TYPE(obj) ((ObjType *) (obj))
@@ -193,8 +212,30 @@ struct Object {
 #define OBJ_MEMBER_VAR_PATH(obj) ((ObjMemberVarPath *) (obj))
 #define OBJECT(obj) ((Object *) (obj))
 
-#endif
+
+struct VarInfo { // OK!
+    Object *func;
+    SInt32 usage;
+    TStreamElement deftoken;
+    SInt16 varnumber;
+    Boolean noregister;
+    Boolean used;
+    UInt8 flags;
+    UInt8 rclass;
+    SInt16 reg;
+    SInt16 regHi;
+};
+
+enum {
+    VarInfoFlag1 = 1, // is parameter?
+    VarInfoFlag2 = 2,
+    VarInfoFlag4 = 4,
+    VarInfoFlag40 = 0x40,
+    VarInfoFlag80 = 0x80
+};
 
 #ifdef __MWERKS__
 #pragma options align=reset
 #endif
+
+#endif
diff --git a/includes/compiler/templates.h b/includes/compiler/templates.h
index f188e0d..85bc5ec 100644
--- a/includes/compiler/templates.h
+++ b/includes/compiler/templates.h
@@ -143,6 +143,10 @@ struct TemplClass {
     UInt8 flags;
 };
 
+enum {
+    TEMPLCLASS_FLAGS_2 = 2
+};
+
 struct TemplClassInst {
     TypeClass theclass;
     TemplClassInst *next;
@@ -150,7 +154,8 @@ struct TemplClassInst {
     TemplClass *templ;
     TemplArg *inst_args;
     TemplArg *oargs;
-    void *x46;
+    Boolean x46;
+    Boolean x47;
 };
 
 #define TEMPL_CLASS(ty) ( (TemplClass *) (ty) )
diff --git a/includes/compiler/tokens.h b/includes/compiler/tokens.h
index b574a81..2f49f98 100644
--- a/includes/compiler/tokens.h
+++ b/includes/compiler/tokens.h
@@ -39,7 +39,15 @@ typedef enum EToken {
     TK_UNION,
     TK_ENUM,
     TK_CLASS,
-    TK_UU_VECTOR = 283,
+    TK_UNK_113,
+    TK_UNK_114,
+    TK_UNK_115,
+    TK_UNK_116,
+    TK_UNK_117,
+    TK_UNK_118,
+    TK_UNK_119,
+    TK_UNK_11A,
+    TK_UU_VECTOR,
     TK_UU_TYPEOF_UU,
     TK_BOOL,
     TK_WCHAR_T,
@@ -138,7 +146,9 @@ typedef enum EToken {
     TK_AT_DEFS,
     TK_SELF,
     TK_SUPER,
-    TK_UU_ALIGNOF_UU = 388,
+    TK_NEW_ARRAY,
+    TK_DELETE_ARRAY,
+    TK_UU_ALIGNOF_UU,
     TK_RESTRICT,
     TK_UU_ATTRIBUTE_UU,
     TK_UU_UUIDOF
@@ -146,7 +156,7 @@ typedef enum EToken {
 
 typedef struct FileOffsetInfo {
     CPrepFileInfo *file;
-    SInt32 offset;
+    SInt32 tokenline;
     SInt32 tokenoffset;
     Boolean is_inline;
 } FileOffsetInfo;
diff --git a/includes/compiler/types.h b/includes/compiler/types.h
index 9b07590..e5b4d94 100644
--- a/includes/compiler/types.h
+++ b/includes/compiler/types.h
@@ -90,6 +90,7 @@ struct StructMember {
 enum {
     STRUCT_TYPE_STRUCT = 0,
     STRUCT_TYPE_UNION = 1,
+    STRUCT_TYPE_CLASS = 2,
     STRUCT_TYPE_4 = 4,
     STRUCT_TYPE_5 = 5,
     STRUCT_TYPE_6 = 6,
@@ -104,23 +105,23 @@ enum {
 };
 
 
-typedef struct ClassList { // checked via CPrec
-    struct ClassList *next;
+struct ClassList { // checked via CPrec
+    ClassList *next;
     TypeClass *base;
     SInt32 offset;
     SInt32 voffset;
     AccessType access;
     Boolean is_virtual;
-} ClassList;
+};
 
-typedef struct VClassList { // checked via CPrec
-    struct VClassList *next;
+struct VClassList { // checked via CPrec
+    VClassList *next;
     TypeClass *base;
     SInt32 offset;
     SInt32 voffset;
     Boolean has_override;
     char alignsave;
-} VClassList;
+};
 
 typedef struct ClassFriend { // checked via CPrec
     struct ClassFriend *next;
@@ -162,14 +163,42 @@ struct TypeClass {
     UInt8 eflags;
 };
 
+typedef enum {
+    CLASS_MODE_0 = 0,
+    CLASS_MODE_1 = 1,
+    CLASS_MODE_2 = 2
+} ClassMode;
+
 enum {
+    CLASS_FLAGS_1 = 1,
     CLASS_FLAGS_2 = 2,
+    CLASS_FLAGS_ABSTRACT = 8,
+    CLASS_FLAGS_10 = 0x10,
     CLASS_FLAGS_20 = 0x20,
+    CLASS_FLAGS_40 = 0x40,
+    CLASS_FLAGS_80 = 0x80,
     CLASS_FLAGS_100 = 0x100, // is TemplClass
     CLASS_FLAGS_800 = 0x800, // is TemplClassInst
-    CLASS_FLAGS_900 = 0x900
+    CLASS_FLAGS_900 = 0x900,
+    CLASS_FLAGS_1000 = 0x1000,
+    CLASS_FLAGS_2000 = 0x2000,
+    CLASS_FLAGS_4000 = 0x4000,
+    CLASS_FLAGS_8000 = 0x8000
 };
 
+/// maps to TypeClass::eflags
+enum {
+    CLASS_EFLAGS_INTERNAL = 1,
+    CLASS_EFLAGS_IMPORT = 2,
+    CLASS_EFLAGS_EXPORT = 4
+};
+
+enum {
+    CLASS_ACTION_0 = 0,
+    CLASS_ACTION_1 = 1,
+    CLASS_ACTION_2 = 2,
+    CLASS_ACTION_3 = 3 // __javaobject
+};
 
 typedef struct ExceptSpecList {
     struct ExceptSpecList *next;
@@ -199,14 +228,29 @@ struct TypeFunc {
 };
 enum {
     FUNC_FLAGS_PASCAL = 1, // on TypeFunc::flags
+    FUNC_FLAGS_2 = 2,
+    FUNC_FLAGS_4 = 4,
+    FUNC_FLAGS_8 = 8, // abstract?
     FUNC_FLAGS_METHOD = 0x10,
     FUNC_FLAGS_40 = 0x40, // func that's like "operator SomeOtherType()"
+    FUNC_FLAGS_80 = 0x80,
+    FUNC_FLAGS_100 = 0x100,
+    FUNC_FLAGS_200 = 0x200,
+    FUNC_FLAGS_NOTHROW = 0x400,
+    FUNC_FLAGS_800 = 0x800,
     FUNC_FLAGS_1000 = 0x1000,
     FUNC_FLAGS_2000 = 0x2000,
-    FUNC_FLAGS_100000 = 0x100000,
-    FUNC_FLAGS_900000 = 0x900000
+    FUNC_FLAGS_CONST = 0x8000,
+    FUNC_FLAGS_VOLATILE = 0x10000,
+    FUNC_FLAGS_100000 = 0x100000, // is template?
+    FUNC_FLAGS_800000 = 0x800000,
+    FUNC_FLAGS_900000 = 0x900000,
+    FUNC_FLAGS_4000000 = 0x4000000,
+    FUNC_FLAGS_10000000 = 0x10000000,
+    FUNC_FLAGS_F0000000 = 0xF0000000
 };
 
+// This is actually called TypeMemberFunc...
 // There seems to be a version of this which adds a class pointer at the end
 struct TypeMethod {
     TypeType type;
@@ -217,7 +261,7 @@ struct TypeMethod {
     UInt32 qual;
     UInt32 flags;
     TypeClass *theclass;
-    void *x1E;
+    SInt32 x1E; // vtable offset?
     void *x22;
     Boolean x26;
 };
@@ -227,7 +271,7 @@ struct TypeBitfield {
     TypeType type;
     SInt32 size;
     Type *bitfieldtype;
-    unsigned char unkA;
+    char unkA;
     char unkB;
 };
 
@@ -305,7 +349,14 @@ struct TypePointer {
 // ObjCID
 
 
+struct TypeList {
+    TypeList *next;
+    Type *type;
+};
+
+
 // Not sure if these existed originally, but they'll help
+#define TYPE(ty) ((Type *) (ty))
 #define TYPE_INTEGRAL(ty) ((TypeIntegral *) (ty))
 #define TYPE_ENUM(ty) ((TypeEnum *) (ty))
 #define TYPE_STRUCT(ty) ((TypeStruct *) (ty))
@@ -317,6 +368,34 @@ struct TypePointer {
 #define TYPE_MEMBER_POINTER(ty) ((TypeMemberPointer *) (ty))
 #define TYPE_POINTER(ty) ((TypePointer *) (ty))
 
+#define IS_TYPE_VOID(ty) ( (ty)->type == TYPEVOID )
+#define IS_TYPE_INT(ty) ( (ty)->type == TYPEINT )
+#define IS_TYPE_ENUM(ty) ( (ty)->type == TYPEENUM )
+#define IS_TYPE_INT_OR_ENUM(ty) ( IS_TYPE_INT(ty) || IS_TYPE_ENUM(ty) )
+#define IS_TYPE_FLOAT(ty) ( (ty)->type == TYPEFLOAT )
+#define IS_TYPE_STRUCT(ty) ( (ty)->type == TYPESTRUCT )
+#define IS_TYPE_CLASS(ty) ( (ty)->type == TYPECLASS )
+#define IS_TYPE_FUNC(ty) ( (ty)->type == TYPEFUNC )
+#define IS_TYPEFUNC_METHOD(ty) ( (ty)->flags & FUNC_FLAGS_METHOD )
+#define IS_TYPE_TEMPLATE(ty) ( (ty)->type == TYPETEMPLATE )
+#define IS_TYPE_POINTER(ty) ( (ty)->type == TYPEPOINTER || (ty)->type == TYPEARRAY )
+#define IS_TYPE_POINTER_ONLY(ty) ( (ty)->type == TYPEPOINTER )
+#define IS_TYPE_REFERENCE(ty) ( (ty)->type == TYPEPOINTER && (TYPE_POINTER(ty)->qual & Q_REFERENCE) )
+#define IS_TYPEPOINTER_REFERENCE(ty) ( (ty)->qual & Q_REFERENCE )
+#define IS_TYPE_ARRAY(ty) ( (ty)->type == TYPEARRAY )
+#define IS_TYPE_BITFIELD(ty) ( (ty)->type == TYPEBITFIELD )
+#define IS_TYPESTRUCT_VECTOR(ty) ( (ty)->stype >= STRUCT_TYPE_4 && (ty)->stype <= STRUCT_TYPE_E )
+#define IS_TYPE_VECTOR(ty) ( (ty)->type == TYPESTRUCT && IS_TYPESTRUCT_VECTOR(TYPE_STRUCT(ty)) )
+#define IS_TYPE_NONVECTOR_STRUCT(ty) ( (ty)->type == TYPESTRUCT && !IS_TYPESTRUCT_VECTOR(TYPE_STRUCT(ty)) )
+#define IS_TYPE_MEMBERPOINTER(ty) ( (ty)->type == TYPEMEMBERPOINTER )
+#define IS_TYPE_4BYTES_MEMBERPOINTER(ty) ( ((ty)->type == TYPEMEMBERPOINTER) && ((ty)->size == 4u) )
+#define IS_TYPE_12BYTES_MEMBERPOINTER(ty) ( ((ty)->type == TYPEMEMBERPOINTER) && ((ty)->size == 12u) )
+#define TYPE_FITS_IN_REGISTER(ty) ( ((ty)->type == TYPEINT) || ((ty)->type == TYPEENUM) || (IS_TYPE_POINTER(ty) && ((ty)->type != TYPEARRAY)) || IS_TYPE_4BYTES_MEMBERPOINTER(ty) )
+#define TYPE_IS_8BYTES(ty) ( (((ty)->type == TYPEINT) || ((ty)->type == TYPEENUM)) && ((ty)->size == 8) )
+
+#define OBJ_GET_TARGET_VOLATILE(obj) ( IS_TYPE_POINTER((obj)->type) ? (TYPE_POINTER((obj)->type)->qual & Q_VOLATILE) : ((obj)->qual & Q_VOLATILE) )
+#define OBJ_GET_TARGET_CONST(obj) ( IS_TYPE_POINTER((obj)->type) ? (TYPE_POINTER((obj)->type)->qual & Q_CONST) : ((obj)->qual & Q_CONST) )
+
 #ifdef __MWERKS__
 #pragma options align=reset
 #endif