get it to compile with clang

7 files changed, 215 insertions, 215 deletions

diff --git a/compiler_and_linker/unsorted/CExprConvMatch.c b/compiler_and_linker/unsorted/CExprConvMatch.c
index 24afb62..69e6651 100644
--- a/compiler_and_linker/unsorted/CExprConvMatch.c
+++ b/compiler_and_linker/unsorted/CExprConvMatch.c
@@ -225,7 +225,7 @@ static Boolean CExpr_IsBetterClassConversion(TypeClass *a, TypeClass *b, TypeCla
     return 0;
 }
 
-inline Boolean Inline_501D40(Type *a, Type *b) {
+CW_INLINE Boolean Inline_501D40(Type *a, Type *b) {
     return (a == TYPE(&stbool)) && (IS_TYPE_POINTER_ONLY(b) || IS_TYPE_MEMBERPOINTER(b));
 }
 
@@ -430,7 +430,7 @@ typedef enum MysteryEnum {
     ME_255 = 255
 } MysteryEnum;
 
-inline MysteryEnum Inline_501FF0(UInt32 qual1, UInt32 qual2) {
+CW_INLINE MysteryEnum Inline_501FF0(UInt32 qual1, UInt32 qual2) {
     if ((qual1 & Q_CV) == (qual2 & Q_CV))
         return ME_0;
 
diff --git a/compiler_and_linker/unsorted/CInline.c b/compiler_and_linker/unsorted/CInline.c
index 85cdf83..7d3c2ef 100644
--- a/compiler_and_linker/unsorted/CInline.c
+++ b/compiler_and_linker/unsorted/CInline.c
@@ -386,7 +386,7 @@ static ENode *CInline_FoldConst(ENode *expr) {
 }
 
 // unknown name
-inline SInt32 CInline_GetLocalID2(Object *object) {
+CW_INLINE SInt32 CInline_GetLocalID2(Object *object) {
     ObjectList *list;
     SInt32 counter;
 
diff --git a/compiler_and_linker/unsorted/CSOM.c b/compiler_and_linker/unsorted/CSOM.c
index 896c425..816c749 100644
--- a/compiler_and_linker/unsorted/CSOM.c
+++ b/compiler_and_linker/unsorted/CSOM.c
@@ -204,7 +204,7 @@ static Type *CSOM_FindClassType(HashNameNode *name) {
     return type;
 }
 
-static inline UInt16 CSOM_GetTokenTableIndex(const Object *object) {
+CW_INLINE UInt16 CSOM_GetTokenTableIndex(const Object *object) {
     CError_ASSERT(173, IS_TYPE_METHOD(object->type));
     return TYPE_METHOD(object->type)->x1E;
 }
diff --git a/compiler_and_linker/unsorted/InlineAsmPPC.c b/compiler_and_linker/unsorted/InlineAsmPPC.c
index 834432c..606b6af 100644
--- a/compiler_and_linker/unsorted/InlineAsmPPC.c
+++ b/compiler_and_linker/unsorted/InlineAsmPPC.c
@@ -47,7 +47,7 @@ static void DiadicOperatorPPC(IAExpr *left, short token, IAExpr *right);
 static void InlineAsm_ExpressionPPC(IAExpr *expr, SInt32 value);
 static void savepicbase(short reg, HashNameNode *name);
 
-inline SInt32 ExtractValue(CInt64 value) {
+CW_INLINE SInt32 ExtractValue(CInt64 value) {
     return (SInt32) CInt64_GetULong(&value);
 }
 
diff --git a/compiler_and_linker/unsorted/IroLinearForm.c b/compiler_and_linker/unsorted/IroLinearForm.c
index 2ac1d0a..4941587 100644
--- a/compiler_and_linker/unsorted/IroLinearForm.c
+++ b/compiler_and_linker/unsorted/IroLinearForm.c
@@ -183,7 +183,7 @@ static void MarkArgs(IROLinear *linear) {
 }
 
 // assumed name, position
-static inline void MarkSubExpr(IROLinear *linear) {
+CW_INLINE void MarkSubExpr(IROLinear *linear) {
     int i;
 
     switch (linear->type) {
diff --git a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
index fe5d4bb..54e59c8 100644
--- a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
+++ b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
@@ -4,7 +4,7 @@
 #include "compiler/CInt64.h"
 
 // TODO: this should really be elsewhere (but where?)
-inline UInt32 gcd(UInt32 a, UInt32 b) {
+CW_INLINE UInt32 gcd(UInt32 a, UInt32 b) {
     UInt32 chk;
 
     if (!a)
@@ -207,20 +207,20 @@ static LocationSet stDummyLocationSet = {
 static LocationSet *stUnknownLs = &stDummyLocationSet;
 
 // forward decls
-inline StackElement *Stack_sub_48A5B0(Stack **stackPtr);
-inline void ObjectSet_RemoveAll(ObjectSet *procList);
-inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList);
-inline void LocationSet_Copy(LocationSet *dest, LocationSet *src);
-inline Boolean LocationSet_IsUnknown(LocationSet *ls);
-inline void LocationSetSet_RemoveAll(LocationSetSet *lss);
-inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src);
-inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf);
-inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src);
-inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc);
-inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src);
-inline void PTFList_RemoveAll(PTFList *ptfList);
-
-inline StackElement *StackElement_New(void) {
+CW_INLINE StackElement *Stack_sub_48A5B0(Stack **stackPtr);
+CW_INLINE void ObjectSet_RemoveAll(ObjectSet *procList);
+CW_INLINE void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList);
+CW_INLINE void LocationSet_Copy(LocationSet *dest, LocationSet *src);
+CW_INLINE Boolean LocationSet_IsUnknown(LocationSet *ls);
+CW_INLINE void LocationSetSet_RemoveAll(LocationSetSet *lss);
+CW_INLINE void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src);
+CW_INLINE void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf);
+CW_INLINE void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src);
+CW_INLINE void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc);
+CW_INLINE void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src);
+CW_INLINE void PTFList_RemoveAll(PTFList *ptfList);
+
+CW_INLINE StackElement *StackElement_New(void) {
     StackElement *stackElement = IRO_malloc(sizeof(StackElement));
     IRO_ASSERT(103, stackElement != NULL);
 #ifdef IRO_DEBUG
@@ -232,7 +232,7 @@ inline StackElement *StackElement_New(void) {
     return stackElement;
 }
 
-inline void StackElement_Delete(StackElement *stackElement) {
+CW_INLINE void StackElement_Delete(StackElement *stackElement) {
     IRO_ASSERT(117, stackElement != NULL);
     IRO_ASSERT(118, stackElement->proc == NULL);
     IRO_ASSERT(119, stackElement->ptf == NULL);
@@ -242,7 +242,7 @@ inline void StackElement_Delete(StackElement *stackElement) {
     IRO_free(stackElement);
 }
 
-inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialTransferFunction *ptf, ParamMappingFunction *map, IROLinear *funcCall) {
+CW_INLINE void StackElement_Init(StackElement *stackElement, Object *proc, PartialTransferFunction *ptf, ParamMappingFunction *map, IROLinear *funcCall) {
     IRO_ASSERT(131, stackElement != NULL);
     IRO_ASSERT(132, proc != NULL);
     IRO_ASSERT(133, ptf != NULL);
@@ -254,13 +254,13 @@ inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialT
     stackElement->funcCall = funcCall;
 }
 
-inline void StackElement_Copy(StackElement *dest, StackElement *src) {
+CW_INLINE void StackElement_Copy(StackElement *dest, StackElement *src) {
     IRO_ASSERT(145, dest != NULL);
     IRO_ASSERT(146, src != NULL);
     StackElement_Init(dest, src->proc, src->ptf, src->map, src->funcCall);
 }
 
-inline void StackElement_Term(StackElement *stackElement) {
+CW_INLINE void StackElement_Term(StackElement *stackElement) {
     IRO_ASSERT(156, stackElement != NULL);
 #ifdef IRO_DEBUG
     stackElement->proc = NULL;
@@ -270,38 +270,38 @@ inline void StackElement_Term(StackElement *stackElement) {
 #endif
 }
 
-inline void *StackElement_sub_48A780(StackElement *stackElement) {
+CW_INLINE void *StackElement_sub_48A780(StackElement *stackElement) {
     IRO_ASSERT(213, stackElement != NULL);
     return stackElement->proc;
 }
 
-inline Boolean StackRelated_sub_48A760(void *key1, void *key2) {
+CW_INLINE Boolean StackRelated_sub_48A760(void *key1, void *key2) {
     IRO_ASSERT(220, key1 != NULL);
     IRO_ASSERT(221, key2 != NULL);
     return key1 == key2;
 }
 
-inline Object *StackElement_proc(StackElement *stackElement) {
+CW_INLINE Object *StackElement_proc(StackElement *stackElement) {
     IRO_ASSERT(228, stackElement != NULL);
     return stackElement->proc;
 }
 
-inline PartialTransferFunction *StackElement_ptf(StackElement *stackElement) {
+CW_INLINE PartialTransferFunction *StackElement_ptf(StackElement *stackElement) {
     IRO_ASSERT(235, stackElement != NULL);
     return stackElement->ptf;
 }
 
-inline ParamMappingFunction *StackElement_map(StackElement *stackElement) {
+CW_INLINE ParamMappingFunction *StackElement_map(StackElement *stackElement) {
     IRO_ASSERT(242, stackElement != NULL);
     return stackElement->map;
 }
 
-inline IROLinear *StackElement_funcCall(StackElement *stackElement) {
+CW_INLINE IROLinear *StackElement_funcCall(StackElement *stackElement) {
     IRO_ASSERT(249, stackElement != NULL);
     return stackElement->funcCall;
 }
 
-inline Stack *Stack_New(void) {
+CW_INLINE Stack *Stack_New(void) {
     Stack *stack = IRO_malloc(sizeof(Stack));
     IRO_ASSERT(265, stack != NULL);
 #ifdef IRO_DEBUG
@@ -311,7 +311,7 @@ inline Stack *Stack_New(void) {
     return stack;
 }
 
-inline void Stack_Delete(Stack *stack) {
+CW_INLINE void Stack_Delete(Stack *stack) {
     IRO_ASSERT(277, stack != NULL);
     IRO_ASSERT(278, stack->top == NULL);
     IRO_ASSERT(279, stack->next == NULL);
@@ -319,13 +319,13 @@ inline void Stack_Delete(Stack *stack) {
     IRO_free(stack);
 }
 
-inline void Stack_Init(Stack *stack) {
+CW_INLINE void Stack_Init(Stack *stack) {
     IRO_ASSERT(289, stack != NULL);
     stack->top = NULL;
     stack->next = NULL;
 }
 
-inline void Stack_Term(Stack **stackPtr) {
+CW_INLINE void Stack_Term(Stack **stackPtr) {
     StackElement *stackElement;
 
     IRO_ASSERT(299, stackPtr != NULL);
@@ -338,7 +338,7 @@ inline void Stack_Term(Stack **stackPtr) {
     }
 }
 
-inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
+CW_INLINE void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
     StackElement *newElement;
     Stack *newStack;
 
@@ -354,21 +354,21 @@ inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
     *stackPtr = newStack;
 }
 
-inline StackElement *Stack_Top(Stack **stackPtr) {
+CW_INLINE StackElement *Stack_Top(Stack **stackPtr) {
     IRO_ASSERT(331, stackPtr != NULL);
     IRO_ASSERT(332, *stackPtr != NULL);
 
     return (*stackPtr)->top;
 }
 
-inline Stack *Stack_Next(Stack **stackPtr) {
+CW_INLINE Stack *Stack_Next(Stack **stackPtr) {
     IRO_ASSERT(343, stackPtr != NULL);
     IRO_ASSERT(344, *stackPtr != NULL);
 
     return (*stackPtr)->next;
 }
 
-inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
+CW_INLINE StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
     StackElement *stackElement;
 
     IRO_ASSERT(357, stackPtr != NULL);
@@ -386,7 +386,7 @@ inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
     return stackElement;
 }
 
-inline StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) {
+CW_INLINE StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) {
     Stack *stack;
 
     IRO_ASSERT(379, stackPtr != NULL);
@@ -402,7 +402,7 @@ inline StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) {
     return NULL;
 }
 
-inline ObjectSet *ObjectSet_New(void) {
+CW_INLINE ObjectSet *ObjectSet_New(void) {
     ObjectSet *procList;
 
     procList = IRO_malloc(sizeof(ObjectSet));
@@ -414,7 +414,7 @@ inline ObjectSet *ObjectSet_New(void) {
     return procList;
 }
 
-inline void ObjectSet_Delete(ObjectSet *procList) {
+CW_INLINE void ObjectSet_Delete(ObjectSet *procList) {
     IRO_ASSERT(451, procList != NULL);
     IRO_ASSERT(452, procList->proc == NULL);
     IRO_ASSERT(453, procList->otherProcs == NULL);
@@ -422,13 +422,13 @@ inline void ObjectSet_Delete(ObjectSet *procList) {
     IRO_free(procList);
 }
 
-inline void ObjectSet_Init(ObjectSet *procList) {
+CW_INLINE void ObjectSet_Init(ObjectSet *procList) {
     IRO_ASSERT(463, procList != NULL);
     procList->proc = NULL;
     procList->otherProcs = NULL;
 }
 
-inline void ObjectSet_Term(ObjectSet *procList) {
+CW_INLINE void ObjectSet_Term(ObjectSet *procList) {
     IRO_ASSERT(481, procList != NULL);
     ObjectSet_RemoveAll(procList);
 #ifdef IRO_DEBUG
@@ -437,7 +437,7 @@ inline void ObjectSet_Term(ObjectSet *procList) {
 #endif
 }
 
-inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void *), void *refcon) {
+CW_INLINE void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void *), void *refcon) {
     IRO_ASSERT(528, procList != NULL);
     IRO_ASSERT(529, action != NULL);
     IRO_ASSERT(530, refcon == NULL || refcon != NULL);
@@ -448,7 +448,7 @@ inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void
     }
 }
 
-inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
+CW_INLINE Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
     IRO_ASSERT(540, procList != NULL);
     IRO_ASSERT(541, proc != NULL);
     while (procList && procList->proc) {
@@ -459,12 +459,12 @@ inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
     return NULL;
 }
 
-inline Object *ObjectSet_FindFirst(ObjectSet *procList) {
+CW_INLINE Object *ObjectSet_FindFirst(ObjectSet *procList) {
     IRO_ASSERT(552, procList != NULL);
     return procList->proc;
 }
 
-inline int ObjectSet_Count(ObjectSet *procList) {
+CW_INLINE int ObjectSet_Count(ObjectSet *procList) {
     int count;
 
     IRO_ASSERT(561, procList != NULL);
@@ -478,7 +478,7 @@ inline int ObjectSet_Count(ObjectSet *procList) {
     return count;
 }
 
-inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
+CW_INLINE void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
     ObjectSet *newProcList;
 
     IRO_ASSERT(574, procList != NULL);
@@ -495,7 +495,7 @@ inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
     procList->proc = proc;
 }
 
-inline void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) {
+CW_INLINE void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) {
     IRO_ASSERT(592, procList != NULL);
     IRO_ASSERT(593, proc != NULL);
 
@@ -503,7 +503,7 @@ inline void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) {
         ObjectSet_sub_486800(procList, proc);
 }
 
-inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
+CW_INLINE void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
     ObjectSet *prev;
     ObjectSet *tmp;
 
@@ -539,28 +539,28 @@ inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
     }
 }
 
-inline void ObjectSet_RemoveAll(ObjectSet *procList) {
+CW_INLINE void ObjectSet_RemoveAll(ObjectSet *procList) {
     IRO_ASSERT(645, procList != NULL);
 
     while (procList && procList->proc)
         ObjectSet_Remove(procList, procList->proc);
 }
 
-inline void ObjectSet_AddSetAction(Object *proc, void *refcon) {
+CW_INLINE void ObjectSet_AddSetAction(Object *proc, void *refcon) {
     IRO_ASSERT(655, proc != NULL);
     IRO_ASSERT(656, refcon != NULL);
 
     ObjectSet_sub_4867D0(refcon, proc);
 }
 
-inline void ObjectSet_SimpleAddSetAction(Object *proc, void *refcon) {
+CW_INLINE void ObjectSet_SimpleAddSetAction(Object *proc, void *refcon) {
     IRO_ASSERT(663, proc != NULL);
     IRO_ASSERT(664, refcon != NULL);
 
     ObjectSet_sub_486800(refcon, proc);
 }
 
-inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
+CW_INLINE void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
     IRO_ASSERT(671, dest != NULL);
     IRO_ASSERT(672, src != NULL);
 
@@ -570,21 +570,21 @@ inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
         ObjectSet_ForEach(src, ObjectSet_SimpleAddSetAction, dest);
 }
 
-inline void ObjectSet_RemoveSetAction(Object *proc, void *refcon) {
+CW_INLINE void ObjectSet_RemoveSetAction(Object *proc, void *refcon) {
     IRO_ASSERT(682, proc != NULL);
     IRO_ASSERT(683, refcon != NULL);
 
     ObjectSet_Remove(refcon, proc);
 }
 
-inline void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) {
+CW_INLINE void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) {
     IRO_ASSERT(690, dest != NULL);
     IRO_ASSERT(691, src != NULL);
 
     ObjectSet_ForEach(src, ObjectSet_RemoveSetAction, dest);
 }
 
-inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
+CW_INLINE Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
     ObjectSet *scan;
 
     IRO_ASSERT(700, os1 != NULL);
@@ -606,7 +606,7 @@ inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
     return 1;
 }
 
-inline ExtendedParam *ExtendedParam_New(void) {
+CW_INLINE ExtendedParam *ExtendedParam_New(void) {
     ExtendedParam *ep = IRO_malloc(sizeof(ExtendedParam));
 
     IRO_ASSERT(755, ep != NULL);
@@ -616,14 +616,14 @@ inline ExtendedParam *ExtendedParam_New(void) {
     return ep;
 }
 
-inline void ExtendedParam_Delete(ExtendedParam *ep) {
+CW_INLINE void ExtendedParam_Delete(ExtendedParam *ep) {
     IRO_ASSERT(762, ep != NULL);
     IRO_ASSERT(763, ep->objectSet == NULL);
     IRO_DEBUG_CLEAR(ep, sizeof(ExtendedParam));
     IRO_free(ep);
 }
 
-inline void ExtendedParam_Init(ExtendedParam *ep, Object *obj) {
+CW_INLINE void ExtendedParam_Init(ExtendedParam *ep, Object *obj) {
     IRO_ASSERT(777, ep != NULL);
     IRO_ASSERT(778, obj != NULL);
     IRO_ASSERT(779, obj->extParam == NULL);
@@ -637,11 +637,11 @@ inline void ExtendedParam_Init(ExtendedParam *ep, Object *obj) {
     ep->x4 = stExtendedParamNum++;
 }
 
-inline void ExtendedParam_TermAction(Object *obj, void *refcon) {
+CW_INLINE void ExtendedParam_TermAction(Object *obj, void *refcon) {
     obj->extParam = NULL;
 }
 
-inline void ExtendedParam_Term(ExtendedParam *ep) {
+CW_INLINE void ExtendedParam_Term(ExtendedParam *ep) {
     IRO_ASSERT(800, ep != NULL);
 
     ObjectSet_ForEach(ep->objectSet, ExtendedParam_TermAction, NULL);
@@ -652,7 +652,7 @@ inline void ExtendedParam_Term(ExtendedParam *ep) {
 #endif
 }
 
-inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
+CW_INLINE Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
     IRO_ASSERT(841, ep1 != NULL);
     IRO_ASSERT(842, ep2 != NULL);
     IRO_ASSERT(843, ep1->objectSet != NULL);
@@ -664,13 +664,13 @@ inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
     return ep1->x4 == ep2->x4 && ObjectSet_sub_484FA0(ep1->objectSet, ep2->objectSet);
 }
 
-inline ExtendedParam *ExtendedParam_FindByObject(Object *obj) {
+CW_INLINE ExtendedParam *ExtendedParam_FindByObject(Object *obj) {
     IRO_ASSERT(856, obj != NULL);
 
     return obj->extParam;
 }
 
-inline void ExtendedParam_sub_4867B0(ExtendedParam *ep, Object *obj) {
+CW_INLINE void ExtendedParam_sub_4867B0(ExtendedParam *ep, Object *obj) {
     IRO_ASSERT(863, ep != NULL);
     IRO_ASSERT(864, ep->objectSet != NULL);
     IRO_ASSERT(865, obj != NULL);
@@ -679,11 +679,11 @@ inline void ExtendedParam_sub_4867B0(ExtendedParam *ep, Object *obj) {
     obj->extParam = ep;
 }
 
-inline void ExtendedParam_RemoveObjectSetAction(Object *object, void *refcon) {
+CW_INLINE void ExtendedParam_RemoveObjectSetAction(Object *object, void *refcon) {
     object->extParam = NULL;
 }
 
-inline void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) {
+CW_INLINE void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) {
     IRO_ASSERT(888, ep != NULL);
     IRO_ASSERT(889, ep->objectSet != NULL);
     IRO_ASSERT(890, objSet != NULL);
@@ -692,19 +692,19 @@ inline void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) {
     ObjectSet_ForEach(objSet, ExtendedParam_RemoveObjectSetAction, NULL);
 }
 
-inline ObjectSet *ExtendedParam_objectSet(ExtendedParam *ep) {
+CW_INLINE ObjectSet *ExtendedParam_objectSet(ExtendedParam *ep) {
     IRO_ASSERT(898, ep != NULL);
 
     return ep->objectSet;
 }
 
-inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
+CW_INLINE uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
     IRO_ASSERT(905, ep != NULL);
 
     return ep->x4;
 }
 
-inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
+CW_INLINE ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
     ExtendedParamSet *epList = IRO_malloc(sizeof(ExtendedParamSet));
 
     IRO_ASSERT(924, epList != NULL);
@@ -715,7 +715,7 @@ inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
     return epList;
 }
 
-inline void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) {
+CW_INLINE void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) {
     IRO_ASSERT(936, epList != NULL);
     IRO_ASSERT(937, epList->ep == NULL);
     IRO_ASSERT(938, epList->otherEps == NULL);
@@ -723,13 +723,13 @@ inline void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) {
     IRO_free(epList);
 }
 
-inline void InitsExtParamSet_sub_4876A0(ExtendedParamSet *epList) {
+CW_INLINE void InitsExtParamSet_sub_4876A0(ExtendedParamSet *epList) {
     IRO_ASSERT(948, epList != NULL);
     epList->ep = NULL;
     epList->otherEps = NULL;
 }
 
-inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
+CW_INLINE void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
     IRO_ASSERT(966, epList != NULL);
     ExtendedParamSet_RemoveAll(epList);
 #ifdef IRO_DEBUG
@@ -738,7 +738,7 @@ inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
 #endif
 }
 
-inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*action)(ExtendedParam *, void *), void *refcon) {
+CW_INLINE void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*action)(ExtendedParam *, void *), void *refcon) {
     IRO_ASSERT(1010, epList != NULL);
     IRO_ASSERT(1011, action != NULL);
 
@@ -748,7 +748,7 @@ inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*act
     }
 }
 
-inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedParam *ep) {
+CW_INLINE ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedParam *ep) {
     IRO_ASSERT(1022, epList != NULL);
     IRO_ASSERT(1023, ep != NULL);
 
@@ -761,7 +761,7 @@ inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedP
     return NULL;
 }
 
-inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep) {
+CW_INLINE void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep) {
     IRO_ASSERT(1056, epList != NULL);
     IRO_ASSERT(1057, ep != NULL);
 
@@ -776,7 +776,7 @@ inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep)
     epList->ep = ep;
 }
 
-inline void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep) {
+CW_INLINE void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep) {
     IRO_ASSERT(1076, epList != NULL);
     IRO_ASSERT(1077, ep != NULL);
 
@@ -784,7 +784,7 @@ inline void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep)
         ExtParamSet_sub_487660(epList, ep);
 }
 
-inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep) {
+CW_INLINE void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep) {
     ExtendedParamSet *prev;
     ExtendedParamSet *tmp;
 
@@ -820,14 +820,14 @@ inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep)
     }
 }
 
-inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
+CW_INLINE void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
     IRO_ASSERT(1129, epList != NULL);
 
     while (epList && epList->ep)
         ExtendedParamSet_Remove(epList, epList->ep);
 }
 
-inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
+CW_INLINE PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
     PAHeapBlock *hb = IRO_malloc(sizeof(PAHeapBlock));
 
     IRO_ASSERT(1225, hb != NULL);
@@ -837,20 +837,20 @@ inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
     return hb;
 }
 
-inline void InitUniqueHeapAlloc_sub_486410(PAHeapBlock *hb, IROLinear *nd) {
+CW_INLINE void InitUniqueHeapAlloc_sub_486410(PAHeapBlock *hb, IROLinear *nd) {
     IRO_ASSERT(1247, hb != NULL);
 
     hb->x0 = nd;
 }
 
-inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
+CW_INLINE Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
     IRO_ASSERT(1296, hb1 != NULL);
     IRO_ASSERT(1297, hb2 != NULL);
 
     return (hb1 == hb2) || (hb1->x0 == hb2->x0);
 }
 
-inline PALocalVar *PALocalVar_New(void) {
+CW_INLINE PALocalVar *PALocalVar_New(void) {
     PALocalVar *local = IRO_malloc(sizeof(PALocalVar));
 
     IRO_ASSERT(1333, local != NULL);
@@ -861,7 +861,7 @@ inline PALocalVar *PALocalVar_New(void) {
     return local;
 }
 
-inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
+CW_INLINE void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
     IRO_ASSERT(1357, local != NULL);
     IRO_ASSERT(1358, obj != NULL);
 
@@ -874,7 +874,7 @@ inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
     }
 }
 
-inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
+CW_INLINE void PALocalVar_InitByName(PALocalVar *local, char *name) {
     IRO_ASSERT(1372, local != NULL);
     IRO_ASSERT(1373, name != NULL);
 
@@ -883,7 +883,7 @@ inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
     strcpy(local->x4, name);
 }
 
-inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
+CW_INLINE Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
     IRO_ASSERT(1419, local1 == NULL || local1 != NULL);
     IRO_ASSERT(1420, local2 == NULL || local2 != NULL);
 
@@ -900,24 +900,24 @@ inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
     return local1->x0 == local2->x0;
 }
 
-inline void PALocalVar_SetSth_sub_4847C0(PALocalVar *local, Object *obj) {
+CW_INLINE void PALocalVar_SetSth_sub_4847C0(PALocalVar *local, Object *obj) {
     IRO_ASSERT(1436, local != NULL);
     IRO_ASSERT(1437, obj == NULL || obj != NULL);
 
     local->x0 = obj;
 }
 
-inline Object *PALocalVar_Get0_sub_4847E0(PALocalVar *local) {
+CW_INLINE Object *PALocalVar_Get0_sub_4847E0(PALocalVar *local) {
     IRO_ASSERT(1444, local != NULL);
     return local->x0;
 }
 
-inline char *PALocalVar_Get4_sub_4847D0(PALocalVar *local) {
+CW_INLINE char *PALocalVar_Get4_sub_4847D0(PALocalVar *local) {
     IRO_ASSERT(1451, local != NULL);
     return local->x4;
 }
 
-inline PAMemoryBlock *PAMemoryBlock_New(void) {
+CW_INLINE PAMemoryBlock *PAMemoryBlock_New(void) {
     PAMemoryBlock *mb = IRO_malloc(sizeof(PAMemoryBlock));
 
     IRO_ASSERT(1491, mb != NULL);
@@ -927,13 +927,13 @@ inline PAMemoryBlock *PAMemoryBlock_New(void) {
     return mb;
 }
 
-inline void PAMemoryBlock_Delete(PAMemoryBlock *mb) {
+CW_INLINE void PAMemoryBlock_Delete(PAMemoryBlock *mb) {
     IRO_ASSERT(1502, mb != NULL);
     IRO_ASSERT(1503, mb->kind == PAMEMORYBLOCKKIND_INVALID);
     IRO_free(mb);
 }
 
-inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *thing) {
+CW_INLINE void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *thing) {
     IRO_ASSERT(1513, mb != NULL);
     IRO_ASSERT(1514, thing == NULL || thing != NULL);
 
@@ -959,7 +959,7 @@ inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *
     }
 }
 
-inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
+CW_INLINE void PAMemoryBlock_Term(PAMemoryBlock *mb) {
     IRO_ASSERT(1552, mb != NULL);
 
 #ifdef IRO_DEBUG
@@ -967,7 +967,7 @@ inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
 #endif
 }
 
-inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
+CW_INLINE Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
     IRO_ASSERT(1657, mb1 == NULL || mb1 != NULL);
     IRO_ASSERT(1658, mb2 == NULL || mb2 != NULL);
 
@@ -994,13 +994,13 @@ inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
     }
 }
 
-inline PAMemoryBlockKind PAMemoryBlock_kind(PAMemoryBlock *mb) {
+CW_INLINE PAMemoryBlockKind PAMemoryBlock_kind(PAMemoryBlock *mb) {
     IRO_ASSERT(1692, mb != NULL);
 
     return mb->kind;
 }
 
-inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
+CW_INLINE void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
     IRO_ASSERT(1699, mb != NULL);
 
     switch (mb->kind) {
@@ -1020,7 +1020,7 @@ inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
     }
 }
 
-inline LocationSet *LocationSet_New(void) {
+CW_INLINE LocationSet *LocationSet_New(void) {
     LocationSet *ls = IRO_malloc(sizeof(LocationSet));
 
     IRO_ASSERT(1767, ls != NULL);
@@ -1033,7 +1033,7 @@ inline LocationSet *LocationSet_New(void) {
     return ls;
 }
 
-inline void LocationSet_Delete(LocationSet *ls) {
+CW_INLINE void LocationSet_Delete(LocationSet *ls) {
     IRO_ASSERT(1781, ls != NULL);
     IRO_ASSERT(1782, ls != stUnknownLs);
     IRO_ASSERT(1783, ls->block == NULL);
@@ -1044,7 +1044,7 @@ inline void LocationSet_Delete(LocationSet *ls) {
     IRO_free(ls);
 }
 
-inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64 field, UInt32 stride, Type *rtype) {
+CW_INLINE void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64 field, UInt32 stride, Type *rtype) {
     IRO_ASSERT(1796, ls != NULL);
     IRO_ASSERT(1797, ls != stUnknownLs);
     IRO_ASSERT(1798, block != NULL);
@@ -1055,7 +1055,7 @@ inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64
     ls->u.known.stride = stride;
 }
 
-inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
+CW_INLINE void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
     IRO_ASSERT(1809, ls != NULL);
     IRO_ASSERT(1810, ls != stUnknownLs);
     IRO_ASSERT(1811, rtype == NULL || rtype != NULL);
@@ -1073,7 +1073,7 @@ inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock
     }
 }
 
-inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
+CW_INLINE void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
     IRO_ASSERT(1829, src != NULL);
     IRO_ASSERT(1830, dest != NULL);
 
@@ -1094,7 +1094,7 @@ inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
     }
 }
 
-inline void LocationSet_Term(LocationSet *ls) {
+CW_INLINE void LocationSet_Term(LocationSet *ls) {
     IRO_ASSERT(1857, ls != NULL);
     IRO_ASSERT(1858, ls != stUnknownLs);
 
@@ -1110,7 +1110,7 @@ inline void LocationSet_Term(LocationSet *ls) {
 #endif
 }
 
-inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) {
+CW_INLINE Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) {
     Boolean isUnknown1, isUnknown2;
     PAMemoryBlock *restriction1, *restriction2;
 
@@ -1212,7 +1212,7 @@ inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet
     return 0;
 }
 
-inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
+CW_INLINE Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
     IRO_ASSERT(2080, ls1 != NULL);
     IRO_ASSERT(2081, ls2 != NULL);
 
@@ -1234,7 +1234,7 @@ inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
         );
 }
 
-inline Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2) {
+CW_INLINE Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2) {
     IRO_ASSERT(2119, ls1 != NULL);
     IRO_ASSERT(2120, ls2 != NULL);
 
@@ -1270,7 +1270,7 @@ inline Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2)
     return 0;
 }
 
-inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) {
+CW_INLINE Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) {
     Boolean unknown1;
     Boolean unknown2;
     PAMemoryBlock *restriction2;
@@ -1314,13 +1314,13 @@ inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet
         MemoryBlocks_Equal(ls1->block, ls2->block);
 }
 
-inline Boolean LocationSet_IsUnknown(LocationSet *ls) {
+CW_INLINE Boolean LocationSet_IsUnknown(LocationSet *ls) {
     IRO_ASSERT(2233, ls != NULL);
 
     return (ls == stUnknownLs) || (ls->block == stUnknownMb);
 }
 
-inline Boolean LocationSet_sub_48AF30(LocationSet *ls) {
+CW_INLINE Boolean LocationSet_sub_48AF30(LocationSet *ls) {
     return
         !LocationSet_IsUnknown(ls) &&
         (ls->u.known.stride == 0) &&
@@ -1329,7 +1329,7 @@ inline Boolean LocationSet_sub_48AF30(LocationSet *ls) {
         !PAMemoryBlock_thing(ls->block);
 }
 
-inline void LocationSet_SetRtype(LocationSet *ls, Type *rtype) {
+CW_INLINE void LocationSet_SetRtype(LocationSet *ls, Type *rtype) {
     IRO_ASSERT(2263, ls != NULL);
     IRO_ASSERT(2264, ls != stUnknownLs);
     IRO_ASSERT(2265, rtype != NULL);
@@ -1337,62 +1337,62 @@ inline void LocationSet_SetRtype(LocationSet *ls, Type *rtype) {
     ls->rtype = rtype;
 }
 
-inline void SetsLocationSetField_sub_4851B0(LocationSet *ls, CInt64 field) {
+CW_INLINE void SetsLocationSetField_sub_4851B0(LocationSet *ls, CInt64 field) {
     IRO_ASSERT(2272, ls != NULL);
     IRO_ASSERT(2273, !LocationSet_IsUnknown(ls));
 
     ls->u.known.field = field;
 }
 
-inline void SetsLocationSetStride_sub_4852D0(LocationSet *ls, SInt32 stride) {
+CW_INLINE void SetsLocationSetStride_sub_4852D0(LocationSet *ls, SInt32 stride) {
     IRO_ASSERT(2280, ls != NULL);
     IRO_ASSERT(2281, !LocationSet_IsUnknown(ls));
 
     ls->u.known.stride = stride;
 }
 
-inline PAMemoryBlock *LocationSet_block(LocationSet *ls) {
+CW_INLINE PAMemoryBlock *LocationSet_block(LocationSet *ls) {
     IRO_ASSERT(2298, ls != NULL);
 
     return ls->block;
 }
 
-inline Type *LocationSet_rtype(LocationSet *ls) {
+CW_INLINE Type *LocationSet_rtype(LocationSet *ls) {
     IRO_ASSERT(2306, ls != NULL);
     IRO_ASSERT(2307, ls != stUnknownLs);
 
     return ls->rtype;
 }
 
-inline CInt64 LocationSet_field(LocationSet *ls) {
+CW_INLINE CInt64 LocationSet_field(LocationSet *ls) {
     IRO_ASSERT(2314, ls != NULL);
     IRO_ASSERT(2315, !LocationSet_IsUnknown(ls));
 
     return ls->u.known.field;
 }
 
-inline UInt32 LocationSet_stride(LocationSet *ls) {
+CW_INLINE UInt32 LocationSet_stride(LocationSet *ls) {
     IRO_ASSERT(2322, ls != NULL);
     IRO_ASSERT(2323, !LocationSet_IsUnknown(ls));
 
     return ls->u.known.stride;
 }
 
-inline PAMemoryBlock *LocationSet_restriction(LocationSet *ls) {
+CW_INLINE PAMemoryBlock *LocationSet_restriction(LocationSet *ls) {
     IRO_ASSERT(2330, ls != NULL);
     IRO_ASSERT(2331, LocationSet_IsUnknown(ls));
 
     return ls->u.unknown.restriction;
 }
 
-inline LocationSet *LocationSet_bitfieldOf(LocationSet *ls) {
+CW_INLINE LocationSet *LocationSet_bitfieldOf(LocationSet *ls) {
     IRO_ASSERT(2338, ls != NULL);
     IRO_ASSERT(2339, LocationSet_IsUnknown(ls));
 
     return ls->u.unknown.bitfieldOf;
 }
 
-inline LocationSetSet *LocationSetSet_New(void) {
+CW_INLINE LocationSetSet *LocationSetSet_New(void) {
     LocationSetSet *lss = IRO_malloc(sizeof(LocationSetSet));
 
     IRO_ASSERT(2356, lss != NULL);
@@ -1404,7 +1404,7 @@ inline LocationSetSet *LocationSetSet_New(void) {
     return lss;
 }
 
-inline void LocationSetSet_Delete(LocationSetSet *lss) {
+CW_INLINE void LocationSetSet_Delete(LocationSetSet *lss) {
     IRO_ASSERT(2369, lss != NULL);
     IRO_ASSERT(2370, lss->loc == NULL);
     IRO_ASSERT(2371, lss->otherLocs == NULL);
@@ -1413,7 +1413,7 @@ inline void LocationSetSet_Delete(LocationSetSet *lss) {
     IRO_free(lss);
 }
 
-inline void LocationSetSet_Init(LocationSetSet *lss) {
+CW_INLINE void LocationSetSet_Init(LocationSetSet *lss) {
     IRO_ASSERT(2382, lss != NULL);
 
     lss->loc = NULL;
@@ -1421,7 +1421,7 @@ inline void LocationSetSet_Init(LocationSetSet *lss) {
     lss->count = 0;
 }
 
-inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
+CW_INLINE void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
     IRO_ASSERT(2391, dest != NULL);
     IRO_ASSERT(2392, src != NULL);
 
@@ -1431,7 +1431,7 @@ inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
     LocationSetSet_AddSet(dest, src);
 }
 
-inline void LocationSetSet_Term(LocationSetSet *lss) {
+CW_INLINE void LocationSetSet_Term(LocationSetSet *lss) {
     IRO_ASSERT(2402, lss != NULL);
 
     LocationSetSet_RemoveAll(lss);
@@ -1443,7 +1443,7 @@ inline void LocationSetSet_Term(LocationSetSet *lss) {
 #endif
 }
 
-inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationSet *, void *), void *refcon) {
+CW_INLINE void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationSet *, void *), void *refcon) {
     IRO_ASSERT(2446, lss != NULL);
     IRO_ASSERT(2447, action != NULL);
     IRO_ASSERT(2448, refcon == NULL || refcon != NULL);
@@ -1454,7 +1454,7 @@ inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationS
     }
 }
 
-inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
+CW_INLINE LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
     IRO_ASSERT(2458, lss != NULL);
     IRO_ASSERT(2459, ls != NULL);
 
@@ -1467,7 +1467,7 @@ inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
     return NULL;
 }
 
-inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
+CW_INLINE LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
     IRO_ASSERT(2470, lss != NULL);
 
     if (!lss->loc)
@@ -1482,19 +1482,19 @@ inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
     return NULL;
 }
 
-inline LocationSet *LocationSetSet_FindFirst(LocationSetSet *lss) {
+CW_INLINE LocationSet *LocationSetSet_FindFirst(LocationSetSet *lss) {
     IRO_ASSERT(2498, lss != NULL);
 
     return lss->loc;
 }
 
-inline int LocationSetSet_Count(LocationSetSet *lss) {
+CW_INLINE int LocationSetSet_Count(LocationSetSet *lss) {
     IRO_ASSERT(2505, lss != NULL);
 
     return lss->count;
 }
 
-inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemoryBlock *block) {
+CW_INLINE void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemoryBlock *block) {
     LocationSetSet *first;
     LocationSetSet *prev;
     LocationSetSet *next;
@@ -1541,7 +1541,7 @@ inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemor
     }
 }
 
-inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
+CW_INLINE void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
     IRO_ASSERT(2572, lss != NULL);
     IRO_ASSERT(2573, ls != NULL);
 
@@ -1583,7 +1583,7 @@ inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
     }
 }
 
-inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
+CW_INLINE void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
     IRO_ASSERT(2622, lss != NULL);
     IRO_ASSERT(2623, ls != NULL);
 
@@ -1594,7 +1594,7 @@ inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
     }
 }
 
-inline void LocationSetSet_AddUnknown(LocationSetSet *lss, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
+CW_INLINE void LocationSetSet_AddUnknown(LocationSetSet *lss, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
     LocationSet *ls;
 
     IRO_ASSERT(2643, lss != NULL);
@@ -1609,7 +1609,7 @@ inline void LocationSetSet_AddUnknown(LocationSetSet *lss, Type *rtype, PAMemory
     LocationSet_Delete(ls);
 }
 
-inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
+CW_INLINE void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
     LocationSetSet *prev;
     LocationSetSet *first;
     LocationSetSet *tmp;
@@ -1653,28 +1653,28 @@ inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
     }
 }
 
-inline void LocationSetSet_RemoveAll(LocationSetSet *lss) {
+CW_INLINE void LocationSetSet_RemoveAll(LocationSetSet *lss) {
     IRO_ASSERT(2707, lss != NULL);
 
     while (lss && lss->loc)
         LocationSetSet_Remove(lss, lss->loc);
 }
 
-inline void LocationSetSet_AddSetAction(LocationSet *ls, void *refcon) {
+CW_INLINE void LocationSetSet_AddSetAction(LocationSet *ls, void *refcon) {
     IRO_ASSERT(2717, ls != NULL);
     IRO_ASSERT(2718, refcon != NULL);
 
     LocationSetSet_Add((LocationSetSet *) refcon, ls);
 }
 
-inline void LocationSetSet_SimpleAddSetAction(LocationSet *ls, void *refcon) {
+CW_INLINE void LocationSetSet_SimpleAddSetAction(LocationSet *ls, void *refcon) {
     IRO_ASSERT(2725, ls != NULL);
     IRO_ASSERT(2726, refcon != NULL);
 
     LocationSetSet_SimpleAdd((LocationSetSet *) refcon, ls);
 }
 
-inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
+CW_INLINE void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
     IRO_ASSERT(2733, dest != NULL);
     IRO_ASSERT(2734, src != NULL);
 
@@ -1684,21 +1684,21 @@ inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
         LocationSetSet_ForEach(src, LocationSetSet_SimpleAddSetAction, dest);
 }
 
-inline void LocationSetSet_RemoveSetAction(LocationSet *ls, void *refcon) {
+CW_INLINE void LocationSetSet_RemoveSetAction(LocationSet *ls, void *refcon) {
     IRO_ASSERT(2744, ls != NULL);
     IRO_ASSERT(2745, refcon != NULL);
 
     LocationSetSet_Remove((LocationSetSet *) refcon, ls);
 }
 
-inline void LocationSetSet_sub_488700(LocationSetSet *dest, LocationSetSet *src) {
+CW_INLINE void LocationSetSet_sub_488700(LocationSetSet *dest, LocationSetSet *src) {
     IRO_ASSERT(2752, dest != NULL);
     IRO_ASSERT(2753, src != NULL);
 
     LocationSetSet_ForEach(src, LocationSetSet_RemoveSetAction, dest);
 }
 
-inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2) {
+CW_INLINE Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2) {
     IRO_ASSERT(2826, lss1 != NULL);
     IRO_ASSERT(2827, lss2 != NULL);
 
@@ -1716,7 +1716,7 @@ inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2)
     return 1;
 }
 
-inline ParamMapping *ParamMapping_New(void) {
+CW_INLINE ParamMapping *ParamMapping_New(void) {
     ParamMapping *pm = IRO_malloc(sizeof(ParamMapping));
 
     IRO_ASSERT(2885, pm != NULL);
@@ -1728,7 +1728,7 @@ inline ParamMapping *ParamMapping_New(void) {
     return pm;
 }
 
-inline void ParamMapping_Delete(ParamMapping *pm) {
+CW_INLINE void ParamMapping_Delete(ParamMapping *pm) {
     IRO_ASSERT(2898, pm != NULL);
     IRO_ASSERT(2899, pm->actual == NULL);
     IRO_ASSERT(2900, pm->formal == NULL);
@@ -1737,7 +1737,7 @@ inline void ParamMapping_Delete(ParamMapping *pm) {
     IRO_free(pm);
 }
 
-inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Object *formal, ExtendedParam *extended) {
+CW_INLINE void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Object *formal, ExtendedParam *extended) {
     IRO_ASSERT(2911, pm != NULL);
 
     pm->actual = actual;
@@ -1745,7 +1745,7 @@ inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Obje
     pm->extended = extended;
 }
 
-inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
+CW_INLINE void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
     IRO_ASSERT(2920, src != NULL);
     IRO_ASSERT(2921, dest != NULL);
 
@@ -1754,7 +1754,7 @@ inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
     dest->extended = src->extended;
 }
 
-inline void ParamMapping_Term(ParamMapping *pm) {
+CW_INLINE void ParamMapping_Term(ParamMapping *pm) {
     IRO_ASSERT(2933, pm != NULL);
 
 #ifdef IRO_DEBUG
@@ -1764,25 +1764,25 @@ inline void ParamMapping_Term(ParamMapping *pm) {
 #endif
 }
 
-inline void ParamMapping_SetExtended(ParamMapping *pm, ExtendedParam *ep) {
+CW_INLINE void ParamMapping_SetExtended(ParamMapping *pm, ExtendedParam *ep) {
     IRO_ASSERT(2992, pm != NULL);
 
     pm->extended = ep;
 }
 
-inline IROLinear *ParamMapping_actual(ParamMapping *pm) {
+CW_INLINE IROLinear *ParamMapping_actual(ParamMapping *pm) {
     IRO_ASSERT(2999, pm != NULL);
 
     return pm->actual;
 }
 
-inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
+CW_INLINE ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
     IRO_ASSERT(3011, pm != NULL);
 
     return pm->extended;
 }
 
-inline ParamMappingFunction *ParamMappingFunction_New(void) {
+CW_INLINE ParamMappingFunction *ParamMappingFunction_New(void) {
     ParamMappingFunction *pmf = IRO_malloc(sizeof(ParamMappingFunction));
 
     IRO_ASSERT(3026, pmf != NULL);
@@ -1793,7 +1793,7 @@ inline ParamMappingFunction *ParamMappingFunction_New(void) {
     return pmf;
 }
 
-inline void ParamMappingFunction_Delete(ParamMappingFunction *pmf) {
+CW_INLINE void ParamMappingFunction_Delete(ParamMappingFunction *pmf) {
     IRO_ASSERT(3039, pmf != NULL);
     IRO_ASSERT(3040, pmf->mapping == NULL);
     IRO_ASSERT(3041, pmf->otherMappings == NULL);
@@ -1801,14 +1801,14 @@ inline void ParamMappingFunction_Delete(ParamMappingFunction *pmf) {
     IRO_free(pmf);
 }
 
-inline void ParamMappingFunction_Init(ParamMappingFunction *pmf) {
+CW_INLINE void ParamMappingFunction_Init(ParamMappingFunction *pmf) {
     IRO_ASSERT(3050, pmf != NULL);
 
     pmf->mapping = NULL;
     pmf->otherMappings = NULL;
 }
 
-inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFunction *src) {
+CW_INLINE void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFunction *src) {
     IRO_ASSERT(3058, src != NULL);
     IRO_ASSERT(3059, dest != NULL);
 
@@ -1817,7 +1817,7 @@ inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFu
     ParamMappingFunction_AddAllMaybe_sub_487C50(dest, src);
 }
 
-inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
+CW_INLINE void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
     IRO_ASSERT(3068, pmf != NULL);
 
     ParamMappingFunction_RemoveAll(pmf);
@@ -1828,7 +1828,7 @@ inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
 #endif
 }
 
-inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMapping *, void *), void *refcon) {
+CW_INLINE void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMapping *, void *), void *refcon) {
     IRO_ASSERT(3111, pmf != NULL);
     IRO_ASSERT(3112, action != NULL);
     IRO_ASSERT(3113, refcon == NULL || refcon != NULL);
@@ -1839,7 +1839,7 @@ inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMappin
     }
 }
 
-inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFunction *pmf, Object *formal) {
+CW_INLINE ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFunction *pmf, Object *formal) {
     IRO_ASSERT(3123, pmf != NULL);
     IRO_ASSERT(3124, formal != NULL);
 
@@ -1852,7 +1852,7 @@ inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFuncti
     return NULL;
 }
 
-inline void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping) {
+CW_INLINE void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping) {
     ParamMapping *existing;
 
     IRO_ASSERT(3138, pmf != NULL);
@@ -1876,7 +1876,7 @@ inline void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping)
     }
 }
 
-inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping *mapping) {
+CW_INLINE void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping *mapping) {
     ParamMappingFunction *prev;
     ParamMappingFunction *tmp;
 
@@ -1915,28 +1915,28 @@ inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping
     }
 }
 
-inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf) {
+CW_INLINE void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf) {
     IRO_ASSERT(3213, pmf != NULL);
 
     while (pmf && pmf->mapping)
         ParamMappingFunction_Remove(pmf, pmf->mapping);
 }
 
-inline void ParamMappingFunction_AddFunctionAction(ParamMapping *mapping, void *refcon) {
+CW_INLINE void ParamMappingFunction_AddFunctionAction(ParamMapping *mapping, void *refcon) {
     IRO_ASSERT(3223, mapping != NULL);
     IRO_ASSERT(3224, refcon != NULL);
 
     Pmf_Add_sub_486610((ParamMappingFunction *) refcon, mapping);
 }
 
-inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src) {
+CW_INLINE void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src) {
     IRO_ASSERT(3231, dest != NULL);
     IRO_ASSERT(3232, src != NULL);
 
     pmf_sub_487C70(src, ParamMappingFunction_AddFunctionAction, dest);
 }
 
-inline PointsToEntry *PointsToEntry_New(void) {
+CW_INLINE PointsToEntry *PointsToEntry_New(void) {
     PointsToEntry *pte = IRO_malloc(sizeof(PointsToEntry));
 
     IRO_ASSERT(3288, pte != NULL);
@@ -1947,7 +1947,7 @@ inline PointsToEntry *PointsToEntry_New(void) {
     return pte;
 }
 
-inline void PointsToEntry_Delete(PointsToEntry *pte) {
+CW_INLINE void PointsToEntry_Delete(PointsToEntry *pte) {
     IRO_ASSERT(3300, pte != NULL);
     IRO_ASSERT(3301, pte->loc == NULL);
     IRO_ASSERT(3302, pte->locs == NULL);
@@ -1955,7 +1955,7 @@ inline void PointsToEntry_Delete(PointsToEntry *pte) {
     IRO_free(pte);
 }
 
-inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSetSet *locs) {
+CW_INLINE void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSetSet *locs) {
     IRO_ASSERT(3312, pte != NULL);
     IRO_ASSERT(3313, loc != NULL);
     IRO_ASSERT(3314, !LocationSet_IsUnknown(loc));
@@ -1968,14 +1968,14 @@ inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSet
     LocationSetSet_Copy(pte->locs, locs);
 }
 
-inline void PointsToEntry_Copy(PointsToEntry *dest, PointsToEntry *src) {
+CW_INLINE void PointsToEntry_Copy(PointsToEntry *dest, PointsToEntry *src) {
     IRO_ASSERT(3325, src != NULL);
     IRO_ASSERT(3326, dest != NULL);
 
     PointsToEntry_Init(dest, src->loc, src->locs);
 }
 
-inline void PointsToEntry_Term(PointsToEntry *pte) {
+CW_INLINE void PointsToEntry_Term(PointsToEntry *pte) {
     IRO_ASSERT(3333, pte != NULL);
 
     LocationSet_Term(pte->loc);
@@ -1989,7 +1989,7 @@ inline void PointsToEntry_Term(PointsToEntry *pte) {
 #endif
 }
 
-inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
+CW_INLINE Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
     IRO_ASSERT(3381, pte1 != NULL);
     IRO_ASSERT(3382, pte2 != NULL);
 
@@ -1999,19 +1999,19 @@ inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
     return LocationSets_Equal(pte1->loc, pte2->loc) && LocationSetSets_Equal(pte1->locs, pte2->locs);
 }
 
-inline LocationSet *PointsToEntry_loc(PointsToEntry *pte) {
+CW_INLINE LocationSet *PointsToEntry_loc(PointsToEntry *pte) {
     IRO_ASSERT(3407, pte != NULL);
 
     return pte->loc;
 }
 
-inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
+CW_INLINE LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
     IRO_ASSERT(3414, pte != NULL);
 
     return pte->locs;
 }
 
-inline PointsToFunction *PointsToFunction_New(void) {
+CW_INLINE PointsToFunction *PointsToFunction_New(void) {
     PointsToFunction *pointsToFunc = IRO_malloc(sizeof(PointsToFunction));
 
     IRO_ASSERT(3430, pointsToFunc != NULL);
@@ -2022,7 +2022,7 @@ inline PointsToFunction *PointsToFunction_New(void) {
     return pointsToFunc;
 }
 
-inline void PointsToFunction_Delete(PointsToFunction *pointsToFunc) {
+CW_INLINE void PointsToFunction_Delete(PointsToFunction *pointsToFunc) {
     IRO_ASSERT(3442, pointsToFunc != NULL);
     IRO_ASSERT(3443, pointsToFunc->pte == NULL);
     IRO_ASSERT(3444, pointsToFunc->otherPtes == NULL);
@@ -2030,14 +2030,14 @@ inline void PointsToFunction_Delete(PointsToFunction *pointsToFunc) {
     IRO_free(pointsToFunc);
 }
 
-inline void PointsToFunction_Init(PointsToFunction *pointsToFunc) {
+CW_INLINE void PointsToFunction_Init(PointsToFunction *pointsToFunc) {
     IRO_ASSERT(3454, pointsToFunc != NULL);
 
     pointsToFunc->pte = NULL;
     pointsToFunc->otherPtes = NULL;
 }
 
-inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src) {
+CW_INLINE void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src) {
     IRO_ASSERT(3462, src != NULL);
     IRO_ASSERT(3463, dest != NULL);
 
@@ -2046,7 +2046,7 @@ inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src)
     PointsToFunction_AddAllIGuess_sub_487D80(dest, src);
 }
 
-inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
+CW_INLINE void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
     IRO_ASSERT(3472, pointsToFunc != NULL);
 
     PointsToFunction_RemoveAll(pointsToFunc);
@@ -2057,7 +2057,7 @@ inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
 #endif
 }
 
-inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*action)(PointsToEntry *, void *), void *refcon) {
+CW_INLINE void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*action)(PointsToEntry *, void *), void *refcon) {
     IRO_ASSERT(3515, pointsToFunc != NULL);
     IRO_ASSERT(3516, action != NULL);
     IRO_ASSERT(3517, refcon == NULL || refcon != NULL);
@@ -2068,7 +2068,7 @@ inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*acti
     }
 }
 
-inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
+CW_INLINE PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
     IRO_ASSERT(3527, pointsToFunc != NULL);
     IRO_ASSERT(3528, ls != NULL);
 
@@ -2081,13 +2081,13 @@ inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *point
     return NULL;
 }
 
-inline PointsToEntry *PointsToFunction_FindFirst(PointsToFunction *pointsToFunc) {
+CW_INLINE PointsToEntry *PointsToFunction_FindFirst(PointsToFunction *pointsToFunc) {
     IRO_ASSERT(3539, pointsToFunc != NULL);
 
     return pointsToFunc->pte;
 }
 
-inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
+CW_INLINE PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
     IRO_ASSERT(3546, pointsToFunc != NULL);
     IRO_ASSERT(3547, ls != NULL);
 
@@ -2104,7 +2104,7 @@ inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsT
     return NULL;
 }
 
-inline PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls, Type *rtype) {
+CW_INLINE PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls, Type *rtype) {
     IRO_ASSERT(3565, pointsToFunc != NULL);
     IRO_ASSERT(3566, ls != NULL);
     IRO_ASSERT(3567, rtype != NULL);
@@ -2120,7 +2120,7 @@ inline PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunctio
     return NULL;
 }
 
-inline void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
+CW_INLINE void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     Type *rtype1;
     Type *rtype2;
     LocationSet *ls;
@@ -2179,7 +2179,7 @@ inline void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *points
     }
 }
 
-inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
+CW_INLINE Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     Boolean flag;
     Boolean isKnown;
     SInt32 stride;
@@ -2247,7 +2247,7 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
     return !flag;
 }
 
-inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
+CW_INLINE Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     PointsToEntry *newPTE;
 
     IRO_ASSERT(3741, pointsToFunc != NULL);
@@ -2266,7 +2266,7 @@ inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, Points
     return 1;
 }
 
-inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
+CW_INLINE Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     IRO_ASSERT(3766, pointsToFunc != NULL);
     IRO_ASSERT(3767, pte != NULL);
 
@@ -2284,7 +2284,7 @@ inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntr
     return 0;
 }
 
-inline Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
+CW_INLINE Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     LocationSet *ls;
 
     IRO_ASSERT(3793, pointsToFunc != NULL);
@@ -2301,7 +2301,7 @@ inline Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFun
     return 0;
 }
 
-inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
+CW_INLINE void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
     PointsToFunction *prev;
     PointsToFunction *tmp;
 
@@ -2341,28 +2341,28 @@ inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc,
     }
 }
 
-inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc) {
+CW_INLINE void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc) {
     IRO_ASSERT(3862, pointsToFunc != NULL);
 
     while (pointsToFunc && pointsToFunc->pte)
         PointsToFunction_RemoveByLocationSet(pointsToFunc, pointsToFunc->pte->loc);
 }
 
-inline void PointsToFunction_AddFunctionAction(PointsToEntry *pte, void *refcon) {
+CW_INLINE void PointsToFunction_AddFunctionAction(PointsToEntry *pte, void *refcon) {
     IRO_ASSERT(3872, pte != NULL);
     IRO_ASSERT(3873, refcon != NULL);
 
     PointsToFunction_Add((PointsToFunction *) refcon, pte);
 }
 
-inline void PointsToFunction_SimpleAddFunctionAction(PointsToEntry *pte, void *refcon) {
+CW_INLINE void PointsToFunction_SimpleAddFunctionAction(PointsToEntry *pte, void *refcon) {
     IRO_ASSERT(3880, pte != NULL);
     IRO_ASSERT(3881, refcon != NULL);
 
     PointsToFunction_SimpleAdd((PointsToFunction *) refcon, pte);
 }
 
-inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src) {
+CW_INLINE void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src) {
     IRO_ASSERT(3888, dest != NULL);
     IRO_ASSERT(3889, src != NULL);
 
@@ -2372,7 +2372,7 @@ inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, Poi
         PointsToFunction_ForEach(src, PointsToFunction_SimpleAddFunctionAction, dest);
 }
 
-inline void PointsToFunction_SortByExtendedParamNum(PointsToFunction *pointsToFunc) {
+CW_INLINE void PointsToFunction_SortByExtendedParamNum(PointsToFunction *pointsToFunc) {
     UInt32 value1;
     UInt32 value2;
     PointsToFunction *scan;
@@ -2417,7 +2417,7 @@ inline void PointsToFunction_SortByExtendedParamNum(PointsToFunction *pointsToFu
     }
 }
 
-inline Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) {
+CW_INLINE Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) {
     PointsToFunction *scan;
     PointsToEntry *pte;
 
@@ -2442,11 +2442,11 @@ inline Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsTo
     return 1;
 }
 
-inline Boolean PointsToFunctions_Match(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) {
+CW_INLINE Boolean PointsToFunctions_Match(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) {
     return 1;
 }
 
-inline PartialTransferFunction *PartialTransferFunction_New(void) {
+CW_INLINE PartialTransferFunction *PartialTransferFunction_New(void) {
     PartialTransferFunction *ptf = IRO_malloc(sizeof(PartialTransferFunction));
 
     IRO_ASSERT(4110, ptf != NULL);
@@ -2461,7 +2461,7 @@ inline PartialTransferFunction *PartialTransferFunction_New(void) {
     return ptf;
 }
 
-inline void PartialTransferFunction_Delete(PartialTransferFunction *ptf) {
+CW_INLINE void PartialTransferFunction_Delete(PartialTransferFunction *ptf) {
     IRO_ASSERT(4126, ptf != NULL);
     IRO_ASSERT(4127, ptf->initialPointsToFn == NULL);
     IRO_ASSERT(4128, ptf->finalPointsToFn == NULL);
@@ -2473,7 +2473,7 @@ inline void PartialTransferFunction_Delete(PartialTransferFunction *ptf) {
     IRO_free(ptf);
 }
 
-inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear *contextNd, PartialTransferFunction *contextPTF) {
+CW_INLINE void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear *contextNd, PartialTransferFunction *contextPTF) {
     IRO_ASSERT(4142, ptf != NULL);
     IRO_ASSERT(4143, contextNd != NULL);
     IRO_ASSERT(4144, contextPTF != NULL);
@@ -2494,7 +2494,7 @@ inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear
     ptf->context.ptf = contextPTF;
 }
 
-inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialTransferFunction *src) {
+CW_INLINE void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialTransferFunction *src) {
     IRO_ASSERT(4164, src != NULL);
     IRO_ASSERT(4165, dest != NULL);
 
@@ -2517,7 +2517,7 @@ inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialT
     dest->context = src->context;
 }
 
-inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
+CW_INLINE void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
     IRO_ASSERT(4190, ptf != NULL);
 
     PointsToFunction_Term(ptf->initialPointsToFn);
@@ -2544,25 +2544,25 @@ inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
 #endif
 }
 
-inline PointsToFunction *PartialTransferFunction_initialPointsToFn(PartialTransferFunction *ptf) {
+CW_INLINE PointsToFunction *PartialTransferFunction_initialPointsToFn(PartialTransferFunction *ptf) {
     IRO_ASSERT(4221, ptf != NULL);
 
     return ptf->initialPointsToFn;
 }
 
-inline PointsToFunction *PartialTransferFunction_finalPointsToFn(PartialTransferFunction *ptf) {
+CW_INLINE PointsToFunction *PartialTransferFunction_finalPointsToFn(PartialTransferFunction *ptf) {
     IRO_ASSERT(4227, ptf != NULL);
 
     return ptf->finalPointsToFn;
 }
 
-inline LocationSetSet *PTF_sub_48D750(PartialTransferFunction *ptf) {
+CW_INLINE LocationSetSet *PTF_sub_48D750(PartialTransferFunction *ptf) {
     IRO_ASSERT(4233, ptf != NULL);
 
     return ptf->funcModifies;
 }
 
-inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFunction *ptf) {
+CW_INLINE LocationSet *PartialTransferFunction_returnLocation(PartialTransferFunction *ptf) {
     IRO_ASSERT(4249, ptf != NULL);
 
     if (!ptf->returnLocation) {
@@ -2579,25 +2579,25 @@ inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFuncti
     return ptf->returnLocation;
 }
 
-inline IROLinear *PTF_sub_48B980(PartialTransferFunction *ptf) {
+CW_INLINE IROLinear *PTF_sub_48B980(PartialTransferFunction *ptf) {
     IRO_ASSERT(4265, ptf != NULL);
 
     return ptf->context.nd;
 }
 
-inline PartialTransferFunction *PTF_sub_48B970(PartialTransferFunction *ptf) {
+CW_INLINE PartialTransferFunction *PTF_sub_48B970(PartialTransferFunction *ptf) {
     IRO_ASSERT(4271, ptf != NULL);
 
     return ptf->context.ptf;
 }
 
-inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boolean value) {
+CW_INLINE void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boolean value) {
     IRO_ASSERT(4298, ptf != NULL);
 
     ptf->x10 = (value != 0) ? 1 : 0;
 }
 
-inline PTFList *PTFList_New(void) {
+CW_INLINE PTFList *PTFList_New(void) {
     PTFList *ptfList = IRO_malloc(sizeof(PTFList));
 
     IRO_ASSERT(4393, ptfList != NULL);
@@ -2608,7 +2608,7 @@ inline PTFList *PTFList_New(void) {
     return ptfList;
 }
 
-inline void PTFList_Delete(PTFList *ptfList) {
+CW_INLINE void PTFList_Delete(PTFList *ptfList) {
     IRO_ASSERT(4405, ptfList != NULL);
     IRO_ASSERT(4406, ptfList->ptf == NULL);
     IRO_ASSERT(4407, ptfList->otherPTFs == NULL);
@@ -2616,14 +2616,14 @@ inline void PTFList_Delete(PTFList *ptfList) {
     IRO_free(ptfList);
 }
 
-inline void PTFList_Init(PTFList *ptfList) {
+CW_INLINE void PTFList_Init(PTFList *ptfList) {
     IRO_ASSERT(4417, ptfList != NULL);
 
     ptfList->ptf = NULL;
     ptfList->otherPTFs = NULL;
 }
 
-inline void PTFList_Term(PTFList *ptfList) {
+CW_INLINE void PTFList_Term(PTFList *ptfList) {
     IRO_ASSERT(4435, ptfList != NULL);
 
     PTFList_RemoveAll(ptfList);
@@ -2634,7 +2634,7 @@ inline void PTFList_Term(PTFList *ptfList) {
 #endif
 }
 
-inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunction *, void *), void *refcon) {
+CW_INLINE void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunction *, void *), void *refcon) {
     IRO_ASSERT(4478, ptfList != NULL);
     IRO_ASSERT(4479, action != NULL);
     IRO_ASSERT(4480, refcon == NULL || refcon != NULL);
@@ -2645,7 +2645,7 @@ inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunc
     }
 }
 
-inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTransferFunction *ptf) {
+CW_INLINE PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTransferFunction *ptf) {
     IRO_ASSERT(4490, ptfList != NULL);
     IRO_ASSERT(4491, ptf != NULL);
 
@@ -2659,13 +2659,13 @@ inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTran
     return NULL;
 }
 
-inline PartialTransferFunction *PTFList_FindFirst(PTFList *ptfList) {
+CW_INLINE PartialTransferFunction *PTFList_FindFirst(PTFList *ptfList) {
     IRO_ASSERT(4502, ptfList != NULL);
 
     return ptfList->ptf;
 }
 
-inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
+CW_INLINE void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
     IRO_ASSERT(4511, ptfList != NULL);
     IRO_ASSERT(4512, ptf != NULL);
 
@@ -2680,7 +2680,7 @@ inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
     ptfList->ptf = ptf;
 }
 
-inline void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) {
+CW_INLINE void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) {
     IRO_ASSERT(4529, ptfList != NULL);
     IRO_ASSERT(4530, ptf != NULL);
 
@@ -2688,7 +2688,7 @@ inline void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) {
         PTFList_sub_48A080(ptfList, ptf);
 }
 
-inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
+CW_INLINE void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
     PTFList *prev;
     PTFList *tmp;
 
@@ -2725,7 +2725,7 @@ inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
     }
 }
 
-inline void PTFList_RemoveAll(PTFList *ptfList) {
+CW_INLINE void PTFList_RemoveAll(PTFList *ptfList) {
     IRO_ASSERT(4582, ptfList != NULL);
 
     while (ptfList && ptfList->ptf)
diff --git a/compiler_and_linker/unsorted/IroUtil.c b/compiler_and_linker/unsorted/IroUtil.c
index 53e6733..3ed6350 100644
--- a/compiler_and_linker/unsorted/IroUtil.c
+++ b/compiler_and_linker/unsorted/IroUtil.c
@@ -796,7 +796,7 @@ IROLinear *IRO_TempReference(Object *obj, IROList *list) {
     return ind;
 }
 
-inline IROLinear *LocateFatherHelper(IROLinear *linear, Boolean a, IROLinear ***b) {
+CW_INLINE IROLinear *LocateFatherHelper(IROLinear *linear, Boolean a, IROLinear ***b) {
     IROLinear *scan;
     SInt32 index;
     int i;