pool/ooRexx
SHA256
4
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adding entries on changelog about removed patches.

Browse Source 
OBS-URL: https://build.opensuse.org/package/show/devel:languages:misc/ooRexx?expand=0&rev=187
This commit is contained in:
Erico Mendonca 2025-03-04 23:05:14 +00:00 committed by Git OBS Bridge
commit 65f2007faf
13 changed files with 939 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.gitattributes vendored Normal file
View File

@ -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

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
.osc

3
debian.tar.gz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:b662e4a91bca146fcb20311926a8d416d80a2261d490606ca3a10da7d774967d
size 2790

407
ooRexx-4.2.0-gcc6.patch Normal file
View File

@ -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;

3
ooRexx-4.2.0.tar.bz2 Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:916a56f8ffa4e7eab53b4a7a3bb3ba33de83dfdb62cbb3f03917afff7080523c
size 1292665

21
ooRexx-chdir-setgroups.patch Normal file
View File

@ -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);
}

18
ooRexx-rpmlintrc Normal file
View File

@ -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.<version>
# 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")

185
ooRexx.changes Normal file
View File

@ -0,0 +1,185 @@
-------------------------------------------------------------------
Thu Feb 27 03:27:41 UTC 2025 - Erico Mendonca <erico.mendonca@suse.com>
- 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 <erico.mendonca@suse.com>
- New build for 5.0.0 with latest released tarball.
-------------------------------------------------------------------
Mon Feb 26 12:39:29 UTC 2024 - Dominique Leuenberger <dimstar@opensuse.org>
- Use %patch -P N instead of deprecated %patchN.
-------------------------------------------------------------------
Fri Oct 15 18:39:48 UTC 2021 - Erico Mendonca <erico.mendonca@suse.com>
- bsc#1191085: re-adding rc* service sbin links with macros.
-------------------------------------------------------------------
Sat Oct 9 16:14:31 UTC 2021 - Erico Mendonca <erico.mendonca@suse.com>
- bsc#1191085: removing rc* service sbin links for UsrMerge compatibility.
-------------------------------------------------------------------
Sat Jun 5 20:47:10 UTC 2021 - Erico Mendonca <erico.mendonca@suse.com>
- Fixing build on latest tumbleweed by forcing C11 mode.
-------------------------------------------------------------------
Wed May 5 19:46:11 UTC 2021 - Erico Mendonca <erico.mendonca@suse.com>
- boo#1185665: moving the RPM macros to the proper directory.
-------------------------------------------------------------------
Thu Oct 11 18:39:12 UTC 2018 - Erico Mendonca <erico.mendonca@suse.com>
- 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.

17
ooRexx.dsc Normal file
View File

@ -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 <emendonca@suse.com>
Uploaders: Perry Werneck <perry.werneck@gmail.com>
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

192
ooRexx.spec Normal file
View File

@ -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

3
oorexx-5.0.0-12583.tar.gz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:fd94d09cfbcfb3499973b38f2c84a0dd0adebf46db5e037fb65d2557cfb87cd1
size 6398458

51
set_default_rexx_path.patch Normal file
View File

@ -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

15
systemd-fixes.patch Normal file
View File

@ -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