File ooRexx-4.2.0-gcc6.patch of Package ooRexx

Overview Repositories Revisions Requests Users Attributes Meta

File ooRexx-4.2.0-gcc6.patch of Package ooRexx (Revision 7e8d7215deb8b3a7c4eb977581f9c2a2)

Currently displaying revision 7e8d7215deb8b3a7c4eb977581f9c2a2 , Show latest

Index: b/interpreter/api/ThreadContextStubs.cpp
===================================================================
--- a/interpreter/api/ThreadContextStubs.cpp
+++ b/interpreter/api/ThreadContextStubs.cpp
@@ -576,7 +576,7 @@ RexxPackageObject RexxEntry GetRoutinePa
     catch (RexxNativeActivation *)
     {
     }
-    return false;
+    return NULLOBJECT;
 }
 
 
@@ -591,7 +591,7 @@ RexxPackageObject RexxEntry GetMethodPac
     catch (RexxNativeActivation *)
     {
     }
-    return false;
+    return NULLOBJECT;
 }
 
 
Index: b/api/oorexxapi.h
===================================================================
--- a/api/oorexxapi.h
+++ b/api/oorexxapi.h
@@ -3694,10 +3694,10 @@ END_EXTERN_C()
 #define argumentOmitted(i) (!argumentExists(i))
 
 
-#define __type(t)   ARGUMENT_TYPE_##t
+#define __rtype(t)   ARGUMENT_TYPE_##t
 #define __arg(p, t) arguments[p].value.value_##t
 #define __ret(t, v) arguments[0].value.value_##t = (v); return NULL;
-#define __adcl(t, n) __type(t) n
+#define __adcl(t, n) __rtype(t) n
 #define __tdcl(t)    REXX_VALUE_##t
 
 #define __methodstub(name) uint16_t * RexxEntry name (RexxMethodContext *context, ValueDescriptor *arguments)
@@ -3726,7 +3726,7 @@ END_EXTERN_C()
 
 #define RexxMethod0(returnType, name) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context);  \
+__rtype(returnType) name##_impl (RexxMethodContext * context);  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), REXX_ARGUMENT_TERMINATOR};    \
@@ -3743,13 +3743,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context)
+__rtype(returnType) name##_impl(RexxMethodContext *context)
 
 
 // method with one argument
 #define RexxMethod1(returnType ,name, t1, n1) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), REXX_ARGUMENT_TERMINATOR};    \
@@ -3766,13 +3766,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1))
 
 
 // method with two arguments
 #define RexxMethod2(returnType ,name, t1, n1, t2, n2) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), REXX_ARGUMENT_TERMINATOR};    \
@@ -3789,13 +3789,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2))
 
 
 // method with three arguments
 #define RexxMethod3(returnType ,name, t1, n1, t2, n2, t3, n3) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), REXX_ARGUMENT_TERMINATOR};    \
@@ -3812,13 +3812,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
 
 
 // method with four arguments
 #define RexxMethod4(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), REXX_ARGUMENT_TERMINATOR};    \
@@ -3835,13 +3835,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
 
 
 // method with five arguments
 #define RexxMethod5(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), REXX_ARGUMENT_TERMINATOR};    \
@@ -3858,13 +3858,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
 
 
 // method with six arguments
 #define RexxMethod6(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), REXX_ARGUMENT_TERMINATOR};    \
@@ -3881,13 +3881,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
 
 
 // method with seven arguments
 #define RexxMethod7(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), REXX_ARGUMENT_TERMINATOR};    \
@@ -3904,13 +3904,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
 
 
 // method with eight arguments
 #define RexxMethod8(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), REXX_ARGUMENT_TERMINATOR};    \
@@ -3927,13 +3927,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
 
 
 // method with nine arguments
 #define RexxMethod9(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), REXX_ARGUMENT_TERMINATOR};    \
@@ -3950,13 +3950,13 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
 
 
 // method with 10 arguments
 #define RexxMethod10(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9, t10, n10) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10));  \
+__rtype(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), __tdcl(t10), REXX_ARGUMENT_TERMINATOR};    \
@@ -3973,7 +3973,7 @@ __methodstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
+__rtype(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
 
 
 #define __functionstub(name) uint16_t * RexxEntry name(RexxCallContext *context, ValueDescriptor *arguments)
@@ -3990,7 +3990,7 @@ __type(returnType) name##_impl(RexxMetho
 
 #define RexxRoutine0(returnType, name) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context);  \
+__rtype(returnType) name##_impl (RexxCallContext * context);  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), REXX_ARGUMENT_TERMINATOR};    \
@@ -4007,13 +4007,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context)
+__rtype(returnType) name##_impl(RexxCallContext *context)
 
 
 // method with one argument
 #define RexxRoutine1(returnType ,name, t1, n1) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), REXX_ARGUMENT_TERMINATOR};    \
@@ -4030,13 +4030,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1))
 
 
 // method with two arguments
 #define RexxRoutine2(returnType ,name, t1, n1, t2, n2) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), REXX_ARGUMENT_TERMINATOR };    \
@@ -4053,13 +4053,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2))
 
 
 // method with three arguments
 #define RexxRoutine3(returnType ,name, t1, n1, t2, n2, t3, n3) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), REXX_ARGUMENT_TERMINATOR};    \
@@ -4076,13 +4076,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
 
 
 // method with four arguments
 #define RexxRoutine4(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), REXX_ARGUMENT_TERMINATOR};    \
@@ -4099,13 +4099,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
 
 
 // method with five arguments
 #define RexxRoutine5(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), REXX_ARGUMENT_TERMINATOR};    \
@@ -4122,13 +4122,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
 
 
 // method with six arguments
 #define RexxRoutine6(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), REXX_ARGUMENT_TERMINATOR};    \
@@ -4145,12 +4145,12 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
 
 // method with seven arguments
 #define RexxRoutine7(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7)); \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7)); \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), REXX_ARGUMENT_TERMINATOR};    \
@@ -4167,13 +4167,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
 
 
 // function with eight arguments
 #define RexxRoutine8(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), REXX_ARGUMENT_TERMINATOR};    \
@@ -4190,13 +4190,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
 
 
 // function with nine arguments
 #define RexxRoutine9(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), REXX_ARGUMENT_TERMINATOR};    \
@@ -4213,13 +4213,13 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
 
 
 // function with ten arguments
 #define RexxRoutine10(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9, t10, n10) \
 /* forward reference definition for method */ \
-__type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10));  \
+__rtype(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10));  \
                                \
 /* method signature definition */ \
 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), __tdcl(t10), REXX_ARGUMENT_TERMINATOR};    \
@@ -4236,7 +4236,7 @@ __functionstub(name) \
     return name##_types;     /* return the type signature */                      \
 } \
 /* the real target method code */  \
-__type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
+__rtype(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
 
 /******************************************************************************/
 /* Types (used in macro expansions and function prototypes)                   */
Index: b/interpreter/runtime/Interpreter.hpp
===================================================================
--- a/interpreter/runtime/Interpreter.hpp
+++ b/interpreter/runtime/Interpreter.hpp
@@ -119,7 +119,7 @@ public:
     static inline bool isBigEndian()
     {
         static  const  int mfcone=1;                 // constant 1
-        static  const  char *mfctop=(char *)&mfcone; // -> top byte
+        static  const  char *mfctop=(const char *)&mfcone; // -> top byte
         #define LITEND *mfctop             // named flag; 1=little-endian
 
         return LITEND == 0;

Places

File ooRexx-4.2.0-gcc6.patch of Package ooRexx (Revision 7e8d7215deb8b3a7c4eb977581f9c2a2)

Places