From 65f2007faf7cafa3c7a4b8007b987c5aa5acc34cc28582bf859148c372fa2029 Mon Sep 17 00:00:00 2001 From: Erico Mendonca Date: Tue, 4 Mar 2025 23:05:14 +0000 Subject: [PATCH] Adding entries on changelog about removed patches. OBS-URL: https://build.opensuse.org/package/show/devel:languages:misc/ooRexx?expand=0&rev=187 --- .gitattributes | 23 ++ .gitignore | 1 + debian.tar.gz | 3 + ooRexx-4.2.0-gcc6.patch | 407 +++++++++++++++++++++++++++++++++++ ooRexx-4.2.0.tar.bz2 | 3 + ooRexx-chdir-setgroups.patch | 21 ++ ooRexx-rpmlintrc | 18 ++ ooRexx.changes | 185 ++++++++++++++++ ooRexx.dsc | 17 ++ ooRexx.spec | 192 +++++++++++++++++ oorexx-5.0.0-12583.tar.gz | 3 + set_default_rexx_path.patch | 51 +++++ systemd-fixes.patch | 15 ++ 13 files changed, 939 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 debian.tar.gz create mode 100644 ooRexx-4.2.0-gcc6.patch create mode 100644 ooRexx-4.2.0.tar.bz2 create mode 100644 ooRexx-chdir-setgroups.patch create mode 100644 ooRexx-rpmlintrc create mode 100644 ooRexx.changes create mode 100644 ooRexx.dsc create mode 100644 ooRexx.spec create mode 100644 oorexx-5.0.0-12583.tar.gz create mode 100644 set_default_rexx_path.patch create mode 100644 systemd-fixes.patch diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/debian.tar.gz b/debian.tar.gz new file mode 100644 index 0000000..317a6f8 --- /dev/null +++ b/debian.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b662e4a91bca146fcb20311926a8d416d80a2261d490606ca3a10da7d774967d +size 2790 diff --git a/ooRexx-4.2.0-gcc6.patch b/ooRexx-4.2.0-gcc6.patch new file mode 100644 index 0000000..59dd31d --- /dev/null +++ b/ooRexx-4.2.0-gcc6.patch @@ -0,0 +1,407 @@ +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; diff --git a/ooRexx-4.2.0.tar.bz2 b/ooRexx-4.2.0.tar.bz2 new file mode 100644 index 0000000..0b4f8dd --- /dev/null +++ b/ooRexx-4.2.0.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:916a56f8ffa4e7eab53b4a7a3bb3ba33de83dfdb62cbb3f03917afff7080523c +size 1292665 diff --git a/ooRexx-chdir-setgroups.patch b/ooRexx-chdir-setgroups.patch new file mode 100644 index 0000000..48dacc5 --- /dev/null +++ b/ooRexx-chdir-setgroups.patch @@ -0,0 +1,21 @@ +Index: b/extensions/platform/unix/rxunixsys/rxunixsys.cpp +=================================================================== +--- a/extensions/platform/unix/rxunixsys/rxunixsys.cpp ++++ b/extensions/platform/unix/rxunixsys/rxunixsys.cpp +@@ -180,7 +180,7 @@ RexxRoutine1(RexxObjectPtr, + SysSetuid, + int, uid) + { +- ++ setgroups(0, NULL); + return context->WholeNumberToObject((wholenumber_t)setuid((uid_t)uid)); + } + +@@ -549,6 +549,7 @@ RexxRoutine1(int, + SysChroot, + CSTRING, path1) + { ++ chdir("/"); + return chroot(path1); + } + diff --git a/ooRexx-rpmlintrc b/ooRexx-rpmlintrc new file mode 100644 index 0000000..37a75ca --- /dev/null +++ b/ooRexx-rpmlintrc @@ -0,0 +1,18 @@ +# These are NOT devel files, but extensions from the main interpreter. +# REXX applications can load extensions via the SysLoadFuncs function. Most REXX applications can deal with the normal .so. +# scheme fine, but some older applications (especially older C-compiled extensions) try to load the .so by name. +addFilter("devel-file-in-non-devel-package.*libhostemu.so") +addFilter("devel-file-in-non-devel-package.*librexx.so") +addFilter("devel-file-in-non-devel-package.*librxmath.so") +addFilter("devel-file-in-non-devel-package.*librexxapi.so") +addFilter("devel-file-in-non-devel-package.*librxregexp.so") +addFilter("devel-file-in-non-devel-package.*librxunixsys.so") +addFilter("devel-file-in-non-devel-package.*liborxncurses.so") +addFilter("devel-file-in-non-devel-package.*librxsock.so") + +# the .rex files are not regular unix scripts +addFilter("E: script-without-shebang") + +# unfortunately historically ooRexx loads class libraries from .cls files in the PATH +# a patch was sent to upstream back in 4.x to load these from /usr/share/ooRexx, but it appears it was ignored for 5.x +addFilter("W: non-executable-in-bin") diff --git a/ooRexx.changes b/ooRexx.changes new file mode 100644 index 0000000..b3b7e02 --- /dev/null +++ b/ooRexx.changes @@ -0,0 +1,185 @@ +------------------------------------------------------------------- +Thu Feb 27 03:27:41 UTC 2025 - Erico Mendonca + +- Renaming package to ooRexx to keep in sync with previous package. +- ooRexx-chdir-setgroups.patch: not needed for version 5.0 codebase +- set_default_rexx_path.patch: not needed for version 5.0 codebase +- systemd-fixes.patches: not needed for version 5.0 codebase +------------------------------------------------------------------- +Mon Dec 30 19:08:40 UTC 2024 - Erico Mendonca + +- New build for 5.0.0 with latest released tarball. + +------------------------------------------------------------------- +Mon Feb 26 12:39:29 UTC 2024 - Dominique Leuenberger + +- Use %patch -P N instead of deprecated %patchN. + +------------------------------------------------------------------- +Fri Oct 15 18:39:48 UTC 2021 - Erico Mendonca + +- bsc#1191085: re-adding rc* service sbin links with macros. + +------------------------------------------------------------------- +Sat Oct 9 16:14:31 UTC 2021 - Erico Mendonca + +- bsc#1191085: removing rc* service sbin links for UsrMerge compatibility. + +------------------------------------------------------------------- +Sat Jun 5 20:47:10 UTC 2021 - Erico Mendonca + +- Fixing build on latest tumbleweed by forcing C11 mode. + +------------------------------------------------------------------- +Wed May 5 19:46:11 UTC 2021 - Erico Mendonca + +- boo#1185665: moving the RPM macros to the proper directory. + +------------------------------------------------------------------- +Thu Oct 11 18:39:12 UTC 2018 - Erico Mendonca + +- Part of the GCC6 fixes broke the SysFileSearch() function. The pointer comparison +to '\0' needs to be done in the rexxutil library, as the result is returned via a null-delimited string. +Thus, the -fpermissive flag needs to be added. + +------------------------------------------------------------------- +Wed Jun 27 14:57:02 UTC 2018 - erico.mendonca@suse.com + +- boo#1083875: removing unneeded attributes from /etc/alternatives entries. + +------------------------------------------------------------------- +Tue Jun 26 19:29:10 UTC 2018 - erico.mendonca@suse.com + +- boo#1083875: update-alternatives support re-done to avoid conflicts with Regina REXX. + +------------------------------------------------------------------- +Wed Mar 14 17:40:26 UTC 2018 - erico.mendonca@suse.com + +- boo#1083875: adding update-alternatives support. + +------------------------------------------------------------------- +Wed Dec 6 17:26:42 UTC 2017 - erico.mendonca@suse.com + +- ooRexx-4.2.0-gcc6.patch: Updated to fix compilation errors on rexxutil with GCC6. + +------------------------------------------------------------------- +Tue Jan 3 19:44:31 UTC 2017 - erico.mendonca@suse.com + +- boo#1017668: killing leftover "rexximage" process. + +------------------------------------------------------------------- +Thu Dec 22 12:38:00 UTC 2016 - perry.werneck@gmail.com + +- ooRexx 4.2 depends on libstdc++6; fixing this on deb packages. + +------------------------------------------------------------------- +Fri Dec 2 21:23:39 UTC 2016 - erico.mendonca@suse.com + +- boo#1012847: removing systemd preset file. + +------------------------------------------------------------------- +Sun Jul 3 04:39:26 UTC 2016 - i@marguerite.su + +- add patch ooRexx-4.2.0-gcc6.patch, fixed boo#985384 + * 'false' is not convertible to a pointer in c++11, use + 'NULL' instead. + * fixed name clash with gcc 6 cmath + * upstream bug: https://sourceforge.net/p/oorexx/bugs/1380/ (fixed) + * drop next release +- build with '-O0' instead of '-O2' to avoid segmentation fault. + found by upstream in the same bug report but not yet fixed +- add patch ooRexx-chdir-setgroups.patch + * chdir before chroot and setgroups before setuid + +------------------------------------------------------------------- +Wed Jul 22 18:32:07 UTC 2015 - emendonca@suse.com + +- systemd-fixes.patch: Adds more fixes for the rxapid systemd service/preset as per SUSE's packaging guidelines. RXAPID now starts automatically as a systemd preset. +- Fixing wrong upstream permissions on REXX class files. + +------------------------------------------------------------------- +Tue Jul 21 20:18:49 UTC 2015 - perry.werneck@gmail.com + +- Fixing up debian/Ubuntu build errors. +- Seens like .dsc just allow only one maintainer. + +------------------------------------------------------------------- +Tue Jul 21 18:04:23 UTC 2015 - emendonca@suse.com + +- Fixing up debian build warnings and errors. +- Using autoreconf instead of bootstrap. +- Removing linefeed conversions, fixed upstream. +- Using latest 4.2.0 sources from Sourceforge. + +------------------------------------------------------------------- +Tue Mar 3 20:48:06 UTC 2015 - emendonca@suse.com + +- Interpreter library links to .so files must be on the main package, as some older REXX applications load the SO by name. + +------------------------------------------------------------------- +Fri Feb 20 14:12:48 UTC 2015 - emendonca@suse.com + +- Fixing BuildRequires for SLE12, as xalan-c is not available anymore. + +------------------------------------------------------------------- +Thu Jan 22 23:54:44 UTC 2015 - emendonca@suse.com + +- Debian dsc file with wrong source archive name. + +------------------------------------------------------------------- +Fri Jan 9 19:42:51 UTC 2015 - emendonca@suse.com +- Links to some .so files were missing in the final RPM. +- Wrong link to /sbin/rcooRexx, should link to /usr/sbin/service as per packaging guidelines. +- Resolving conflicts. +------------------------------------------------------------------- +Thu Dec 18 17:04:58 UTC 2014 - emendonca@suse.com + +- rcooRexx should only be included with systemd-enabled systems. This was preventing a proper build on older systems. +------------------------------------------------------------------- +Wed Nov 19 18:00:41 UTC 2014 - emendonca@suse.com + +- Fixing systemd versus init.d dependencies. +------------------------------------------------------------------- +Thu Oct 9 12:13:45 UTC 2014 - emendonca@suse.com + +- new version 4.2.0 +- A list of the bugs fixed upstream can be found at http://sourceforge.net/projects/oorexx/files/oorexx/4.2.0/CHANGES.txt/download +- removed fixes-rpmlint.patch, as it is no longer necessary (fixed upstream). +- removed update_init_script.patch, as it is no longer necessary (fixed upstream). +------------------------------------------------------------------- +Thu Jul 31 16:11:50 UTC 2014 - dimstar@opensuse.org + +- Rename rpmlintrc to %{name}-rpmlintrc. +- Follow the packaging guidelines. +------------------------------------------------------------------- +Mon Dec 9 13:34:00 UTC 2013 - perry.werneck@gmail.com + +- Updating to ooRexx 4.2.0 beta +------------------------------------------------------------------- +Thu Jul 11 16:09:48 UTC 2013 - emendonca@suse.com + +- New version based on 4.1.3. Lots of fixes for correct building as per SUSE's guidelines. A list of the bugs fixed upstream can be found at http://sourceforge.net/projects/oorexx/files/oorexx/4.1.3/CHANGES/download . +------------------------------------------------------------------- +Tue Apr 9 23:36:55 UTC 2013 - emendonca@suse.com + +- SPEC formatting tweaks. +------------------------------------------------------------------- +Mon Apr 8 03:16:45 UTC 2013 - emendonca@suse.com + +- adding exception for rpmlint. Build date in the interpreter is historical, cannot remove. +------------------------------------------------------------------- +Sun Apr 7 00:09:58 UTC 2013 - emendonca@suse.com + +- cleanups for Factory. +------------------------------------------------------------------- +Tue Oct 16 2012 emendonca@suse.com + +- adding patches and spec fixes necessary for correct building. +------------------------------------------------------------------- +Tue Oct 16 23:28:15 UTC 2012 - emendonca@suse.com + +- adding patches and spec fixes necessary for correct building. +------------------------------------------------------------------- +Fri Oct 12 19:14:14 UTC 2012 - emendonca@suse.com + +- initial build based on release version 4.1.1 from oorexx.org. diff --git a/ooRexx.dsc b/ooRexx.dsc new file mode 100644 index 0000000..fe69e94 --- /dev/null +++ b/ooRexx.dsc @@ -0,0 +1,17 @@ +Debtransform-Tar: ooRexx-4.2.0.tar.bz2 +Debtransform-Files-Tar: debian.tar.gz +Format: 1.0 +Source: oorexx +Version: 4.2.0-1 +Binary: oorexx +Maintainer: Erico Mendonca +Uploaders: Perry Werneck +Homepage: http://www.oorexx.org/ +Architecture: any +Build-Depends: debhelper (>= 7), autotools-dev, automake, autoconf, libtool, bison, patch, tofrodos, gettext, lsb-base +Standards-Version: 3.9.1.0 +DEBTRANSFORM-RELEASE: 1 +Files: + 00000000000000000000000000000000 000000 ooRexx-4.2.0.tar.bz2 + 00000000000000000000000000000000 000000 debian.tar.gz + diff --git a/ooRexx.spec b/ooRexx.spec new file mode 100644 index 0000000..bbd4202 --- /dev/null +++ b/ooRexx.spec @@ -0,0 +1,192 @@ +# +# spec file for package oorexx +# +# Copyright (c) 2024 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + +%define _rexxpath %{_datadir}/ooRexx +Name: ooRexx +Version: 5.0.0 +Release: 0 +Summary: Open Object REXX +License: CPL-1.0 +Group: Development/Languages/Other +URL: https://www.rexxla.org +Source: https://master.dl.sourceforge.net/project/oorexx/oorexx/5.0.0/oorexx-5.0.0-12583.tar.gz +BuildRequires: cmake +BuildRequires: gcc-c++ +BuildRequires: ncurses-devel +Requires(post): %{_sbindir}/update-alternatives +Requires(postun): %{_sbindir}/update-alternatives +Obsoletes: ooRexx <= 4.2.0 +Provides: ooRexx = %{version} + +%description +Open Object Rexx is an object-oriented scripting language. The language is designed for both beginners and experienced Rexx programmers. It is easy to learn and use, and provides an excellent vehicle to enter the +world of object-oriented programming without much effort. + +It extends the procedural way of Rexx programming with object-oriented features that allow you to gradually change your programming style as you learn more about objects. + +For more information on ooRexx, visit http://www.oorexx.org/ +For more information on Rexx, visit http://www.rexxla.org/ + +%package devel +Summary: Open Object REXX development files +Group: Development/Languages/Other +BuildArch: noarch + +%package -n liboorexx4 +Summary: Open Object REXX libraries +Group: Development/Languages/Other + +%description devel +Development files for Open Object Rexx. These are intended for developing REXX extensions only. + +%description -n liboorexx4 +Library files for Open Object Rexx. + +%prep +mkdir -p src build +tar -C src -xvzf %{SOURCE0} + +%build +cd build +# FIXME: you should use the %%cmake macros +cmake -S ../src -DORX_REXXPATH=%{_rexxpath} -DORX_SHEBANG=%{_bindir}/rexx -DBUILD_RPM=1 -DCMAKE_INSTALL_PREFIX=%{_prefix} +%make_build -O -j 2 + +%install +cd build +%make_install + +# create a pkgconfig file +mkdir -p %{buildroot}%{_datadir}/pkgconfig +cat > %{buildroot}%{_datadir}/pkgconfig/%{name}.pc << EOF +prefix=%{_prefix} +exec_prefix=%{_prefix} +libdir=%{_libdir} +includedir=%{_includedir} + +%{name}_binary_version=%{version} +%{name}_major=$(echo %{version} | cut -d. -f1) +%{name}_minor=$(echo %{version} | cut -d. -f2) + +Name: %{name} +Description: Open Object Rexx +Version: %{version} +Libs: -L\${libdir} -lrexx -lrexxapi +Cflags: -I\${includedir} +EOF + +mkdir -p %{buildroot}%{_sysconfdir}/rpm +cat > %{buildroot}%{_sysconfdir}/rpm/oorexx.macros << EOF +%{_ooRexx} $(echo %{version} | cut -d. -f1) +%{_rexxclassdir} %{_rexxpath} +%{_rexxlibdir} %{_libdir} +EOF + +# adding update-alternatives support (boo#1083875) +mkdir -p %{buildroot}%{_sysconfdir}/alternatives + +# rexxc and rxsubcom need to be renamed upstream! rexx and rxqueue are okay already. +mv %{buildroot}/%{_bindir}/rexx %{buildroot}/%{_bindir}/rexx-oorexx +mv %{buildroot}/%{_bindir}/rexxc %{buildroot}/%{_bindir}/rexxc-oorexx +mv %{buildroot}/%{_bindir}/rxsubcom %{buildroot}/%{_bindir}/rxsubcom-oorexx +mv %{buildroot}/%{_bindir}/rxqueue %{buildroot}/%{_bindir}/rxqueue-oorexx + +ln -s %{_sysconfdir}/alternatives/rexx %{buildroot}%{_bindir}/rexx +ln -s %{_sysconfdir}/alternatives/rexxc %{buildroot}%{_bindir}/rexxc +ln -s %{_sysconfdir}/alternatives/rxqueue %{buildroot}%{_bindir}/rxqueue +ln -s %{_sysconfdir}/alternatives/rxsubcom %{buildroot}%{_bindir}/rxsubcom + +# removing binary samples to avoid OBS warnings +rm %{buildroot}%{_datadir}/ooRexx/samples/api/c++/callsample/{runRexxProgram,stackOverflow} +rm %{buildroot}%{_datadir}/ooRexx/samples/api/c++/external/libexternal*so +rm %{buildroot}%{_datadir}/ooRexx/samples/api/classic/callrexx/callrexx* +rm %{buildroot}%{_datadir}/ooRexx/samples/api/classic/rexxapi*/librexxapi*.so + +%check + +%post +update-alternatives --install %{_bindir}/rexx rexx %{_bindir}/rexx-oorexx 20 +update-alternatives --install %{_bindir}/rexxc rexxc %{_bindir}/rexxc-oorexx 20 +update-alternatives --install %{_bindir}/rxqueue rxqueue %{_bindir}/rxqueue-oorexx 20 +update-alternatives --install %{_bindir}/rxsubcom rxsubcom %{_bindir}/rxsubcom-oorexx 20 + +%postun +if [ ! -f %{_bindir}/rexx-oorexx ] ; then + update-alternatives --remove rexx %{_bindir}/rexx-oorexx +fi + +if [ ! -f %{_bindir}/rexxc-oorexx ] ; then + update-alternatives --remove rexxc %{_bindir}/rexxc-oorexx +fi + +if [ ! -f %{_bindir}/rxqueue-oorexx ] ; then + update-alternatives --remove rxqueue %{_bindir}/rxqueue-oorexx +fi + +if [ ! -f %{_bindir}/rxsubcom-oorexx ] ; then + update-alternatives --remove rxsubcom %{_bindir}/rxsubcom-oorexx +fi + +%post -n liboorexx4 -p /sbin/ldconfig +%postun -n liboorexx4 -p /sbin/ldconfig + +%changelog +%files +%dir %{_datadir}/icons/hicolor +%dir %{_datadir}/icons/hicolor/48x48 +%dir %{_datadir}/icons/hicolor/48x48/apps +%dir %{_datadir}/ooRexx + +%{_mandir}/man1/* +%{_datadir}/applications/* +%{_datadir}/icons/hicolor/48x48/apps/* + +%{_libdir}/rexx.img +%{_bindir}/rexxtry.rex +%{_bindir}/rxapi +%{_bindir}/rexx-oorexx +%{_bindir}/rexxc-oorexx +%{_bindir}/rxqueue-oorexx +%{_bindir}/rxsubcom-oorexx +%{_bindir}/*cls + +%ghost %{_bindir}/rexx +%ghost %{_bindir}/rexxc +%ghost %{_bindir}/rxqueue +%ghost %{_bindir}/rxsubcom + +%ghost %attr(0755,root,root) %{_sysconfdir}/alternatives/rexx +%ghost %attr(0755,root,root) %{_sysconfdir}/alternatives/rexxc +%ghost %attr(0755,root,root) %{_sysconfdir}/alternatives/rxqueue +%ghost %attr(0755,root,root) %{_sysconfdir}/alternatives/rxsubcom +%ghost %attr(0644,root,root) %{_sysconfdir}/alternatives/rexx.1 +%ghost %attr(0644,root,root) %{_sysconfdir}/alternatives/rexxc.1 +%ghost %attr(0644,root,root) %{_sysconfdir}/alternatives/rxqueue.1 +%ghost %attr(0644,root,root) %{_sysconfdir}/alternatives/rxsubcom.1 + +%files -n liboorexx4 +%{_libdir}/lib* + +%files devel +%config %{_sysconfdir}/rpm/* +%{_includedir}/* +%{_datadir}/pkgconfig/* + +%dir %{_datadir}/ooRexx/samples +%{_datadir}/ooRexx/samples/* + +%changelog diff --git a/oorexx-5.0.0-12583.tar.gz b/oorexx-5.0.0-12583.tar.gz new file mode 100644 index 0000000..56ff85c --- /dev/null +++ b/oorexx-5.0.0-12583.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd94d09cfbcfb3499973b38f2c84a0dd0adebf46db5e037fb65d2557cfb87cd1 +size 6398458 diff --git a/set_default_rexx_path.patch b/set_default_rexx_path.patch new file mode 100644 index 0000000..6c497ec --- /dev/null +++ b/set_default_rexx_path.patch @@ -0,0 +1,51 @@ +diff -Naur ooRexx-4.2.0/interpreter/platform/unix/SysInterpreterInstance.cpp ooRexx-4.2.0/interpreter/platform/unix/SysInterpreterInstance.cpp +--- ooRexx-4.2.0.original/interpreter/platform/unix/SysInterpreterInstance.cpp 2014-02-24 08:09:32.619362812 -0300 ++++ ooRexx-4.2.0/interpreter/platform/unix/SysInterpreterInstance.cpp 2014-02-24 08:10:33.049257168 -0300 +@@ -124,6 +124,13 @@ + size_t parentSize = parentDir == NULL ? 0 : strlen(parentDir); + size_t extensionSize = extensionPath == NULL ? 0 : strlen(extensionPath); + ++#ifdef PKGDATADIR ++ if(!rexxPath) ++ { ++ rexxPath=PKGDATADIR; ++ rexxPathSize = strlen(rexxPath); ++ } ++#endif // PKGDATADIR + + // enough room for separators and a terminating null + path = (char *)SystemInterpreter::allocateResultMemory(sysPathSize + rexxPathSize + parentSize + extensionSize + 16); +diff -Naur ooRexx-4.2.0/Makefile.am ooRexx-4.2.0/Makefile.am +--- ooRexx-4.2.0.original/Makefile.am 2014-02-24 08:09:32.738358662 -0300 ++++ ooRexx-4.2.0/Makefile.am 2014-02-24 08:12:33.408072613 -0300 +@@ -156,7 +156,8 @@ + -DOOREXX_COPY_YEAR=\"$(ORX_COPY_YEAR)\" \ + -DORX_SYS_STR=\"@ORX_SYS_STR@\" \ + -DORX_CATDIR=\"$(catdir)\" \ +- -DORX_SHARED_LIBRARY_EXT=\"@ORX_SHARED_LIBRARY_EXT@\" ++ -DORX_SHARED_LIBRARY_EXT=\"@ORX_SHARED_LIBRARY_EXT@\" \ ++ -DPKGDATADIR=\"$(pkgdatadir)\" + + messageXML = $(build_messages_dir)/rexxmsg.xml + +@@ -1086,13 +1087,13 @@ + $(install_sh_SCRIPT) rexx.cat $(DESTDIR)$(catdir)/rexx.cat; \ + fi + $(install_sh_SCRIPT) $(build_os_platform_dir)/oorexx-config $(DESTDIR)$(prefix)/bin/oorexx-config +- $(install_sh_SCRIPT) $(build_extensions_rxregexp_dir)/rxregexp.cls $(DESTDIR)$(prefix)/bin/rxregexp.cls +- $(install_sh_SCRIPT) $(build_extensions_rxftp_dir)/rxftp.cls $(DESTDIR)$(prefix)/bin/rxftp.cls +- $(install_sh_SCRIPT) $(build_extensions_csvstream_dir)/csvStream.cls $(DESTDIR)$(prefix)/bin/csvStream.cls +- $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/socket.cls $(DESTDIR)$(prefix)/bin/socket.cls +- $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/streamsocket.cls $(DESTDIR)$(prefix)/bin/streamsocket.cls +- $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/mime.cls $(DESTDIR)$(prefix)/bin/mime.cls +- $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/smtp.cls $(DESTDIR)$(prefix)/bin/smtp.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxregexp_dir)/rxregexp.cls $(DESTDIR)$(pkgdatadir)/rxregexp.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxftp_dir)/rxftp.cls $(DESTDIR)$(pkgdatadir)/rxftp.cls ++ $(install_sh_SCRIPT) $(build_extensions_csvstream_dir)/csvStream.cls $(DESTDIR)$(pkgdatadir)/csvStream.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/socket.cls $(DESTDIR)$(pkgdatadir)/socket.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/streamsocket.cls $(DESTDIR)$(pkgdatadir)/streamsocket.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/mime.cls $(DESTDIR)$(pkgdatadir)/mime.cls ++ $(install_sh_SCRIPT) $(build_extensions_rxsock_dir)/smtp.cls $(DESTDIR)$(pkgdatadir)/smtp.cls + if test "$(ORX_SYS_STR)" != "AIX" -a "$(ORX_SYS_STR)" != "MACOSX"; then \ + $(install_sh_SCRIPT) $(rexxapi_server_unix_dir)/rxapid $(DESTDIR)$(prefix)/bin/rxapid; \ + fi diff --git a/systemd-fixes.patch b/systemd-fixes.patch new file mode 100644 index 0000000..5cbbaf8 --- /dev/null +++ b/systemd-fixes.patch @@ -0,0 +1,15 @@ +--- platform/unix/rxapid.service 2013-12-21 15:47:12.667492000 -0200 ++++ platform/unix/rxapid.service.new 2015-07-22 14:27:01.188725317 -0300 +@@ -1,6 +1,5 @@ + [Unit] + Description=ooRexx rxapi service +-After=syslog.target + After=network.target + + [Service] +@@ -11,4 +10,4 @@ + Restart=on-abort + + [Install] +-WantedBy=multi-user.target.wants ++WantedBy=multi-user.target