From e01a76a62b13ea8ae5df895f55d3b8b712719cf0 Mon Sep 17 00:00:00 2001 From: Jitka Plesnikova Date: Nov 15 2018 09:46:14 +0000 Subject: Add support for Octave 4.4 --- diff --git a/swig-3.0.12-Support-Octave-4.4.patch b/swig-3.0.12-Support-Octave-4.4.patch new file mode 100644 index 0000000..bb66edd --- /dev/null +++ b/swig-3.0.12-Support-Octave-4.4.patch @@ -0,0 +1,974 @@ +From e8e507bf0bae72e7f3bb798e326ec5d81b230205 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 23:26:06 +1000 +Subject: [PATCH 01/18] Lib/octave: fix function name passed to + unwind_protect::begin_frame() + +--- + Lib/octave/octruntime.swg | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index f5e687123c..96f7399f93 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -170,7 +170,7 @@ SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::st + frame.protect_var(discard_error_messages); discard_error_messages = true; + frame.protect_var(discard_warning_messages); discard_warning_messages = true; + #else +- unwind_protect::begin_frame("SWIG_Octave_LoadModule"); ++ unwind_protect::begin_frame("SWIG_Octave_InstallFunction"); + unwind_protect_int(error_state); error_state = 0; + unwind_protect_int(warning_state); warning_state = 0; + unwind_protect_bool(discard_error_messages); discard_error_messages = true; + +From a46909a414ee9a1fd3e1996066111774e852557e Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Tue, 31 Jan 2017 11:43:42 +1300 +Subject: [PATCH 02/18] Lib/octave: call octave::feval() instead of feval() for + Octave >= 4.4 + +--- + Lib/octave/octruntime.swg | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index 96f7399f93..e468eb49e0 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -139,7 +139,11 @@ SWIGINTERN bool SWIG_Octave_LoadModule(std::string name) { + #endif + #if SWIG_OCTAVE_PREREQ(4,2,0) + try { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::feval(name, octave_value_list(), 0); ++#else + feval(name, octave_value_list(), 0); ++#endif + retn = true; + } catch (octave::execution_exception&) { } + #else +@@ -181,7 +185,11 @@ SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::st + args.append(octloadfcn->fcn_file_name()); + #if SWIG_OCTAVE_PREREQ(4,2,0) + try { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::feval("autoload", args, 0); ++#else + feval("autoload", args, 0); ++#endif + retn = true; + } catch (octave::execution_exception&) { } + #else +@@ -351,7 +359,11 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + "__swig_atexit__; " + "atexit(\"__swig_atexit__\", false); " + "atexit(\"__swig_atexit__\")"); ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::feval("evalin", eval_args, 0); ++#else + feval("evalin", eval_args, 0); ++#endif + #endif + + octave_swig_ref::register_type(); + +From 358345db9eb875cb6b2bd51c5ed10efb3816d4f3 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 20:32:50 +1000 +Subject: [PATCH 03/18] Lib/octave: replace is_cell() with iscell() for Octave + >= 4.4 + +--- + Lib/octave/octcontainer.swg | 4 ++++ + Lib/octave/octprimtypes.swg | 8 +++++++- + Lib/octave/octrun.swg | 20 ++++++++++++++++++-- + Lib/octave/std_pair.i | 16 ++++++++++++++-- + 4 files changed, 43 insertions(+), 5 deletions(-) + +diff --git a/Lib/octave/octcontainer.swg b/Lib/octave/octcontainer.swg +index 9b6520739a..269ff75442 100644 +--- a/Lib/octave/octcontainer.swg ++++ b/Lib/octave/octcontainer.swg +@@ -567,7 +567,11 @@ namespace swig { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } ++%#if SWIG_OCTAVE_PREREQ(4,4,0) ++ } else if (obj.iscell()) { ++%#else + } else if (obj.is_cell()) { ++%#endif + try { + OctSequence_Cont octseq(obj); + if (seq) { +diff --git a/Lib/octave/octprimtypes.swg b/Lib/octave/octprimtypes.swg +index 663d1fe103..308fe64996 100644 +--- a/Lib/octave/octprimtypes.swg ++++ b/Lib/octave/octprimtypes.swg +@@ -214,7 +214,13 @@ SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val) + SWIGINTERN int + SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc) + { +- if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1) ++ if ( ++%#if SWIG_OCTAVE_PREREQ(4,4,0) ++ ov.iscell() ++%#else ++ ov.is_cell() ++%#endif ++ && ov.rows() == 1 && ov.columns() == 1) + ov = ov.cell_value()(0); + if (!ov.is_string()) + return SWIG_TypeError; +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index 57a888fb40..d6f75a7b5e 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -383,7 +383,11 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + return dim_vector(1,1); + + // Return value should be cell or matrix of integers ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ if (out.iscell()) { ++#else + if (out.is_cell()) { ++#endif + const Cell & c=out.cell_value(); + int ndim = c.rows(); + if (ndim==1 && c.columns()!=1) ndim = c.columns(); +@@ -1238,7 +1242,13 @@ namespace Swig { + } + + SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) { +- if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1) ++ if ( ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ ov.iscell() ++#else ++ ov.is_cell() ++#endif ++ && ov.rows() == 1 && ov.columns() == 1) + ov = ov.cell_value()(0); + return swig_value_deref(*ov.internal_rep()); + } +@@ -1357,7 +1367,13 @@ SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *ty + } + + SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) { +- if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1) ++ if ( ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ ov.iscell() ++#else ++ ov.is_cell() ++#endif ++ && ov.rows() == 1 && ov.columns() == 1) + ov = ov.cell_value()(0); + if (!ov.is_defined() || + (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) { +diff --git a/Lib/octave/std_pair.i b/Lib/octave/std_pair.i +index 2f3d4dfa40..2f307380e7 100644 +--- a/Lib/octave/std_pair.i ++++ b/Lib/octave/std_pair.i +@@ -38,7 +38,13 @@ + } + + static int asval(const octave_value& obj, std::pair *val) { +- if (obj.is_cell()) { ++ if ( ++%#if SWIG_OCTAVE_PREREQ(4,4,0) ++ obj.iscell() ++%#else ++ obj.is_cell() ++%#endif ++ ) { + Cell c=obj.cell_value(); + if (c.numel()<2) { + error("pair from Cell array requires at least two elements"); +@@ -96,7 +102,13 @@ + } + + static int asptr(const octave_value& obj, std::pair **val) { +- if (obj.is_cell()) { ++ if ( ++%#if SWIG_OCTAVE_PREREQ(4,4,0) ++ obj.iscell() ++%#else ++ obj.is_cell() ++%#endif ++ ) { + Cell c=obj.cell_value(); + if (c.numel()<2) { + error("pair from Cell array requires at least two elements"); + +From 6f0561eb5772a04162ac631951999698a466253b Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 20:33:21 +1000 +Subject: [PATCH 04/18] Lib/octave: replace is_numeric_type() with isnumeric() + for Octave >= 4.4 + +--- + Lib/octave/octrun.swg | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index d6f75a7b5e..f5d8b38988 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -405,7 +405,11 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + if (error_state) return dim_vector(1,1); + } + return d; ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ } else if (out.is_matrix_type() || out.isnumeric() ) { ++#else + } else if (out.is_matrix_type() || out.is_numeric_type() ) { ++#endif + if (out.rows()==1 || out.columns()==1) { + Array a = out.int_vector_value(); + if (error_state) return dim_vector(1,1); + +From 04357dca210a3e90e464e00c9ed1b71e38807723 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 03:52:59 +1000 +Subject: [PATCH 05/18] Lib/octave: replace is_bool_type() with islogical() for + Octave >= 4.4 + +--- + Lib/octave/octprimtypes.swg | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Lib/octave/octprimtypes.swg b/Lib/octave/octprimtypes.swg +index 308fe64996..1c9aa9089c 100644 +--- a/Lib/octave/octprimtypes.swg ++++ b/Lib/octave/octprimtypes.swg +@@ -18,7 +18,11 @@ SWIGINTERNINLINE octave_value + SWIGINTERN int + SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val) + { ++%#if SWIG_OCTAVE_PREREQ(4,4,0) ++ if (!ov.islogical()) ++%#else + if (!ov.is_bool_type()) ++%#endif + return SWIG_ERROR; + if (val) + *val = ov.bool_value(); + +From 931656bcbe7c2bf37bb5d831b47fab9a38695e91 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 21:52:28 +1000 +Subject: [PATCH 06/18] Lib/octave: 'octave_exit' not longer exists in Octave + >= 4.4 + +- Instead must register atexit() function, since Octave still + cannot clean up its memory usage on exit with SWIG modules +--- + Lib/octave/octruntime.swg | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index e468eb49e0..b2fde69c2f 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -320,6 +320,8 @@ static const char *const SWIG_name_usage = "-*- texinfo -*- \n\ + Loads the SWIG-generated module `" SWIG_name_d "'.\n\ + @end deftypefn"; + ++void __swig_atexit__(void) { ::_Exit(0); } ++ + DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + + static octave_swig_type* module_ns = 0; +@@ -330,7 +332,9 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + // version 3.4.*, but reappeared in 4.2.*, so turn on for all versions after 3.2.*. + // can be turned off with macro definition. + #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK +-#if SWIG_OCTAVE_PREREQ(3,2,0) ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ atexit(__swig_atexit__); ++#elif SWIG_OCTAVE_PREREQ(3,2,0) + octave_exit = ::_Exit; + #endif + #endif + +From df92ad6ebcb0995f04194b38ee19e0b7f08c730a Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 22:03:41 +1000 +Subject: [PATCH 07/18] Lib/octave: fix call to octave::call_stack::current() + for Octave >= 4.4 + +--- + Lib/octave/octruntime.swg | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index b2fde69c2f..d83a27f579 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -375,7 +375,12 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + SWIG_InitializeModule(0); + SWIG_PropagateClientData(); + ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack(); ++ octave_function *me = stack.current(); ++#else + octave_function *me = octave_call_stack::current(); ++#endif + + if (!SWIG_Octave_InstallFunction(me, "subclass")) { + return octave_value_list(); + +From ce67bce72e8b82c47295c320dd990d30d4c4bbde Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Thu, 10 May 2018 22:04:30 +1000 +Subject: [PATCH 08/18] Lib/octave: fix call to mlock() for Octave >= 4.4 + +--- + Lib/octave/octruntime.swg | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index d83a27f579..46faade9c1 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -447,10 +447,12 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + } + } + +-#if !SWIG_OCTAVE_PREREQ(3,2,0) +- mlock(me->name()); +-#else ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::interpreter::the_interpreter()->mlock(); ++#elif SWIG_OCTAVE_PREREQ(3,2,0) + mlock(); ++#else ++ mlock(me->name()); + #endif + + } + +From 84aab22f669e90609c417c39cf4d81809fa1c5b6 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Fri, 11 May 2018 15:31:26 +1000 +Subject: [PATCH 09/18] Lib/Octave: in Octave >= 4.4, assign reference to base + class in subclass + +- See Examples/octave/callback/runme.m: a.run() calls Octave callback, + but due to changes in behaviour to subsref() a.Callback.run() can no + longer be used to call C callback unless a.Callback actually exists; + subsrefs() just gets the "Callback" call whereas prior to Octave 4.4 + it would get both the "Callback" and "run" calls. So now a.Callback is + set to the original base class (with own=0) so that it can be accessed +--- + Lib/octave/octrun.swg | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index f5d8b38988..6e297d3885 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -484,8 +484,12 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + } + types.insert(types.end(), rhs.types.begin(), rhs.types.end()); + members.insert(rhs.members.begin(), rhs.members.end()); ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ assign(rhs.swig_type_name(), rhs.as_value()); ++#else + rhs.types.clear(); + rhs.members.clear(); ++#endif + } + + typedef member_map::const_iterator swig_member_const_iterator; + +From 94e8853e610cf545ba42bfa77d8ac1d659adb7a5 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 02:26:01 +1000 +Subject: [PATCH 10/18] Lib/octave: fix operator installation for Octave >= 4.4 + +--- + Lib/octave/octrun.swg | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index 6e297d3885..ae014f9bd6 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -1279,12 +1279,24 @@ SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \ + SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \ + return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \ + } ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++#define swigreg_unary_op(name) \ ++if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \ ++typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name); ++#else + #define swigreg_unary_op(name) \ + if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \ + octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name); ++#endif ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++#define swigreg_binary_op(name) \ ++if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \ ++typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name); ++#else + #define swigreg_binary_op(name) \ + if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \ + octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name); ++#endif + + swig_unary_op(not); + swig_unary_op(uplus); +@@ -1318,6 +1330,9 @@ octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig + swig_binary_op(el_or); + + SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info(); ++#endif + swigreg_unary_op(not); + swigreg_unary_op(uplus); + swigreg_unary_op(uminus); +@@ -1327,6 +1342,9 @@ octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig + swigreg_unary_op(decr); + } + SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info(); ++#endif + swigreg_binary_op(add); + swigreg_binary_op(sub); + swigreg_binary_op(mul); + +From d0b1105f3018516e4a94dd57e6bae83167bf2f1c Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 02:29:07 +1000 +Subject: [PATCH 11/18] Lib/octave: use new class for function member + dereference with Octave >= 4.4 + +--- + Lib/octave/octrun.swg | 80 +++++++++++++++++++++++++++++++++++++-- + Lib/octave/octruntime.swg | 30 +++++++++++++++ + 2 files changed, 106 insertions(+), 4 deletions(-) + +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index ae014f9bd6..45105e207d 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -151,6 +151,67 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + const swig_type_info **base; + }; + ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed ++ // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass ++#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args)) ++ class octave_swig_bound_func : public octave_function { ++ public: ++ ++ octave_swig_bound_func(void) : octave_function(), method(0), first_args() ++ { } ++ ++ octave_swig_bound_func(octave_function* _method, octave_value_list _first_args) ++ : octave_function("", ""), method(_method), first_args(_first_args) ++ { } ++ ++ octave_swig_bound_func(const octave_swig_bound_func& f) = delete; ++ ++ octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete; ++ ++ ~octave_swig_bound_func(void) = default; ++ ++ bool is_function(void) const { return true; } ++ ++ octave_function* function_value(bool = false) { return this; } ++ ++ octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) { ++ octave_value_list all_args; ++ all_args.append(first_args); ++ all_args.append(args); ++ return method->call(tw, nargout, all_args); ++ } ++ ++ octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) { ++ octave_value_list ovl = subsref(ops, idx, 1); ++ return ovl.length() ? ovl(0) : octave_value(); ++ } ++ ++ octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) { ++ assert(ops.size() > 0); ++ assert(ops.size() == idx.size()); ++ if (ops != "(") ++ error("invalid function call"); ++ octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator(); ++ return call(tw, nargout, *idx.begin()); ++ } ++ ++ protected: ++ ++ octave_function* method; ++ octave_value_list first_args; ++ ++ std::set dispatch_classes; ++ ++ private: ++ ++ DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA ++ }; ++ DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_bound_func, "octave_swig_bound_func", "octave_swig_bound_func"); ++#else ++#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func) ++#endif ++ + // octave_swig_type plays the role of both the shadow class and the class + // representation within Octave, since there is no support for classes. + // +@@ -323,13 +384,17 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + } + + octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) { +- if (m->second.is_defined()) +- return m->second; +- else if (m->first) { ++ if (m->second.is_defined()) { ++ if (m->second.is_function() || m->second.is_function_handle()) { ++ return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args); ++ } else { ++ return m->second; ++ } ++ } else if (m->first) { + if (m->first->get_method) + return m->first->get_method(args, 1); + else if (m->first->method) +- return octave_value(new octave_builtin(m->first->method)); ++ return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args); + } + error("undefined member"); + return octave_value_list(); +@@ -860,7 +925,14 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own); + octave_function *fcn = is_valid_function(symbol, std::string(), false); + if (!fcn) + return false; ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator(); ++ octave_value_list retval = fcn->call(tw, 1, args); ++ if (retval.length() == 1) ++ ret = retval(0); ++#else + ret = fcn->do_multi_index_op(1, args)(0); ++#endif + return true; + } + +diff --git a/Lib/octave/octruntime.swg b/Lib/octave/octruntime.swg +index 46faade9c1..f98bf4fe4e 100644 +--- a/Lib/octave/octruntime.swg ++++ b/Lib/octave/octruntime.swg +@@ -370,8 +370,38 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) { + #endif + #endif + ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ { ++ octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info(); ++ string_vector types = typeinfo.installed_type_names(); ++ bool register_octave_swig_ref = true; ++ bool register_octave_swig_packed = true; ++ bool register_octave_swig_bound_func = true; ++ for (int i = 0; i < types.numel(); ++i) { ++ if (types(i) == octave_swig_ref::static_type_name()) { ++ register_octave_swig_ref = false; ++ } ++ if (types(i) == octave_swig_packed::static_type_name()) { ++ register_octave_swig_packed = false; ++ } ++ if (types(i) == octave_swig_bound_func::static_type_name()) { ++ register_octave_swig_bound_func = false; ++ } ++ } ++ if (register_octave_swig_ref) { ++ octave_swig_ref::register_type(); ++ } ++ if (register_octave_swig_packed) { ++ octave_swig_packed::register_type(); ++ } ++ if (register_octave_swig_bound_func) { ++ octave_swig_bound_func::register_type(); ++ } ++ } ++#else + octave_swig_ref::register_type(); + octave_swig_packed::register_type(); ++#endif + SWIG_InitializeModule(0); + SWIG_PropagateClientData(); + + +From 6586616e23e499189b2acaf9e8244d9574cbf5b0 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 02:36:13 +1000 +Subject: [PATCH 12/18] Lib/octave: fix getting/setting global variables for + Octave >= 4.4 + +--- + Lib/octave/octrun.swg | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +diff --git a/Lib/octave/octrun.swg b/Lib/octave/octrun.swg +index 45105e207d..feed973cc8 100644 +--- a/Lib/octave/octrun.swg ++++ b/Lib/octave/octrun.swg +@@ -1504,14 +1504,30 @@ SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, cons + } + + SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table(); ++ return symtab.global_varval(name); ++#else + return get_global_value(name, true); ++#endif + } + + SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table(); ++ symtab.global_assign(name, value); ++#else + set_global_value(name, value); ++#endif + } + + SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) { ++#if SWIG_OCTAVE_PREREQ(4,4,0) ++ octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table(); ++ octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope(); ++ symscope.assign(name, symtab.global_varval(name)); ++ symscope.mark_global(name); ++#else + #if !SWIG_OCTAVE_PREREQ(3,2,0) + link_to_global_variable(curr_sym_tab->lookup(name, true)); + #else +@@ -1520,6 +1536,7 @@ SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) { + #endif + symbol_table::mark_global(name); + #endif ++#endif + } + + SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) { + +From a169eef3c0ee5436a09ce7bbd97ebaf189ffa35d Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Fri, 11 May 2018 22:22:42 +1000 +Subject: [PATCH 13/18] Examples/Makefile.in: unset OCTAVE_PATH when running + Octave for tests + +--- + Examples/Makefile.in | 2 +- + Examples/test-suite/octave/Makefile.in | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Examples/Makefile.in b/Examples/Makefile.in +index 8218f51224..58da8ec1dc 100644 +--- a/Examples/Makefile.in ++++ b/Examples/Makefile.in +@@ -463,7 +463,7 @@ octave_cpp: $(SRCDIR_SRCS) + # ----------------------------------------------------------------- + + octave_run: +- OCTAVE_HISTFILE=/dev/null $(RUNTOOL) $(OCTAVE) $(OCTAVE_SCRIPT) $(RUNPIPE) ++ env OCTAVE_PATH= OCTAVE_HISTFILE=/dev/null $(RUNTOOL) $(OCTAVE) $(OCTAVE_SCRIPT) $(RUNPIPE) + + # ----------------------------------------------------------------- + # Version display +diff --git a/Examples/test-suite/octave/Makefile.in b/Examples/test-suite/octave/Makefile.in +index f5ad0e8a52..3c8f3b165e 100644 +--- a/Examples/test-suite/octave/Makefile.in ++++ b/Examples/test-suite/octave/Makefile.in +@@ -65,7 +65,7 @@ CSRCS = octave_empty.c + # a file is found which has _runme.m appended after the testcase name. + run_testcase = \ + if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ +- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH OCTAVE_PATH=$(srcdir):$$OCTAVE_PATH $(RUNTOOL) $(OCTAVE) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ ++ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH OCTAVE_PATH=$(srcdir) OCTAVE_HISTFILE=/dev/null $(RUNTOOL) $(OCTAVE) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ + fi + + # Clean: remove the generated .m file + +From af97a312d41fa72ef2f6b86c6c8e858392f79330 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Tue, 31 Jan 2017 11:48:42 +1300 +Subject: [PATCH 14/18] Examples/octave/module_load/runme.m: do not use + duplicate function names + +--- + Examples/octave/module_load/runme.m | 24 ++++++++++++------------ + 1 file changed, 12 insertions(+), 12 deletions(-) + +diff --git a/Examples/octave/module_load/runme.m b/Examples/octave/module_load/runme.m +index 0e327efcdc..4069e9939d 100644 +--- a/Examples/octave/module_load/runme.m ++++ b/Examples/octave/module_load/runme.m +@@ -16,24 +16,24 @@ + + # load module in a function globally before base context + clear all; +-function testme ++function testme_1 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); + endfunction +-testme +-testme ++testme_1 ++testme_1 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); + clear all +-function testme ++function testme_2 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); + endfunction +-testme +-testme ++testme_2 ++testme_2 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); +@@ -44,24 +44,24 @@ + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); +-function testme ++function testme_3 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); + endfunction +-testme +-testme ++testme_3 ++testme_3 + clear all + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); +-function testme ++function testme_4 + swigexample; + assert(cvar.ivar == ifunc); + assert(exist("swigexample","var")); + endfunction +-testme +-testme ++testme_4 ++testme_4 + clear all + + # octave 3.0.5 randomly crashes on the remaining tests + +From 64ad3f0ca87dcd9d4a54692e7afdbc887b793268 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Fri, 11 May 2018 21:15:09 +1000 +Subject: [PATCH 15/18] Examples/octave/module_load/runme.m: update 'exist()' + statements for Octave >= 4.4 + +--- + Examples/octave/module_load/runme.m | 41 +++++++++++++++++++---------- + 1 file changed, 27 insertions(+), 14 deletions(-) + +diff --git a/Examples/octave/module_load/runme.m b/Examples/octave/module_load/runme.m +index 4069e9939d..beab1213b0 100644 +--- a/Examples/octave/module_load/runme.m ++++ b/Examples/octave/module_load/runme.m +@@ -5,60 +5,70 @@ + + # load module + clear all; ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + clear all ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + clear all + + # load module in a function globally before base context + clear all; + function testme_1 ++ assert(exist("swigexample") == 3); + swigexample; ++ assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +- assert(exist("swigexample","var")); + endfunction + testme_1 + testme_1 ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + clear all + function testme_2 ++ assert(exist("swigexample") == 3); + swigexample; ++ assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +- assert(exist("swigexample","var")); + endfunction + testme_2 + testme_2 ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + clear all + + # load module in a function globally after base context + clear all; ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + function testme_3 ++ assert(exist("swigexample") == 3); + swigexample; ++ assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +- assert(exist("swigexample","var")); + endfunction + testme_3 + testme_3 + clear all ++assert(exist("swigexample") == 3); + swigexample; ++assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +-assert(exist("swigexample","var")); + function testme_4 ++ assert(exist("swigexample") == 3); + swigexample; ++ assert(isglobal("swigexample")); + assert(cvar.ivar == ifunc); +- assert(exist("swigexample","var")); + endfunction + testme_4 + testme_4 +@@ -71,13 +81,16 @@ + + # load module with no cvar + clear all; ++who; ++assert(exist("swigexample2") == 3); + swigexample2; ++assert(isglobal("swigexample2")); + assert(swigexample2.ivar == ifunc); +-assert(exist("swigexample2","var")); +-assert(!isglobal("cvar")) ++assert(!exist("cvar", "var")); + clear all ++assert(exist("swigexample2") == 3); + swigexample2; ++assert(isglobal("swigexample2")); + assert(swigexample2.ivar == ifunc); +-assert(exist("swigexample2","var")); +-assert(!isglobal("cvar")) ++assert(!exist("cvar", "var")); + clear all + +From a2ab3d7b20feec5f46100d98712dd92cf4f9bc52 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 19:23:12 +1000 +Subject: [PATCH 16/18] Examples/test-suite/register_par.i: rename 'tree' to + 'swig_tree' + +- 'tree' is a declared symbol in Octave >= 4.4 headers +--- + Examples/test-suite/register_par.i | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Examples/test-suite/register_par.i b/Examples/test-suite/register_par.i +index b4172c0599..6438414559 100644 +--- a/Examples/test-suite/register_par.i ++++ b/Examples/test-suite/register_par.i +@@ -1,6 +5,10 @@ + %module register_par + ++%{ ++struct swig_tree; ++%} ++ + // bug # 924413 + %inline { +- void clear_tree_flags(register struct tree *tp, register int i) {} ++ void clear_tree_flags(register struct swig_tree *tp, register int i) {} + } + +From ebd0b52b3ec201bbd70391c106e541c859ceaaf9 Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 02:57:27 +1000 +Subject: [PATCH 17/18] .travis.yml: test against Octave 4.4 + +--- + .travis.yml | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/.travis.yml b/.travis.yml +index 54ec4c3f94..d0e1239cea 100644 +--- a/.travis.yml ++++ b/.travis.yml +@@ -94,6 +94,11 @@ matrix: + env: SWIGLANG=octave SWIGJOBS=-j2 VER=4.2 CPP11=1 + sudo: required + dist: trusty ++ - compiler: gcc ++ os: linux ++ env: SWIGLANG=octave SWIGJOBS=-j2 VER=4.4 CPP11=1 ++ sudo: required ++ dist: trusty + - compiler: gcc + os: linux + env: SWIGLANG=perl5 + +From 23e6f1329255a128bb702be0de77f17c47149ddf Mon Sep 17 00:00:00 2001 +From: Karl Wette +Date: Sat, 12 May 2018 22:31:31 +1000 +Subject: [PATCH 18/18] Update CHANGES.current + +--- + CHANGES.current | 4 ++++ + 1 file changed, 4 insertions(+) + +#diff --git a/CHANGES.current b/CHANGES.current +#index 0acfddc7da..3037b59281 100644 +#--- a/CHANGES.current +#+++ b/CHANGES.current +#@@ -7,6 +7,10 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/ +# Version 4.0.0 (in progress) +# =========================== +# +#+2018-05-12: kwwette +#+ [Octave] add support for version 4.4 +#+ - Should not introduce any user-visible incompatibilities +#+ +# 2018-05-11: wsfulton +# [C#, D, Java] Add support so that the %csmethodmodifiers, %dmethodmodifiers, +# %javamethodmodifiers can modify the method modifiers for the destructor wrappers diff --git a/swig.spec b/swig.spec index e4842bb..920d1b7 100644 --- a/swig.spec +++ b/swig.spec @@ -34,7 +34,7 @@ Summary: Connects C/C++/Objective C to some high-level programming languages Name: swig Version: 3.0.12 -Release: 21%{?dist} +Release: 22%{?dist} License: GPLv3+ and BSD URL: http://swig.sourceforge.net/ Source0: http://downloads.sourceforge.net/project/swig/swig/swig-%{version}/swig-%{version}.tar.gz @@ -61,12 +61,13 @@ Patch7: swig-3.0.12-Coverity-fix-issue-reported-for-SWIG_Python_FixMetho.patch Patch8: swig-3.0.12-Fix-Coverity-issue-reported-for-setslice-pycontainer.patch Patch9: swig-3.0.12-Coverity-fix-issue-reported-for-wrapper-argument-che.patch Patch10: swig-3.0.12-Coverity-fix-issue-reported-for-SWIG_Python_ConvertF.patch +Patch11: swig-3.0.12-Support-Octave-4.4.patch BuildRequires: perl-interpreter, pcre-devel %if %{python2lang} BuildRequires: python2-devel %endif -BuildRequires: python3-devel +BuildRequires: python%{python3_pkgversion}-devel BuildRequires: autoconf, automake, gawk, dos2unix BuildRequires: gcc-c++ BuildRequires: help2man @@ -169,6 +170,7 @@ in gdb. %patch8 -p1 %patch9 -p1 %patch10 -p1 +%patch11 -p1 for all in CHANGES README; do iconv -f ISO88591 -t UTF8 < $all > $all.new @@ -332,6 +334,9 @@ install -pm 644 Tools/swig.gdb %{buildroot}%{_datadir}/%{name}/gdb %{_datadir}/%{name}/gdb %changelog +* Thu Nov 15 2018 Jitka Plesnikova - 3.0.12-22 +- Add support for Octave 4.4 + * Sat Jul 14 2018 Fedora Release Engineering - 3.0.12-21 - Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild