Merge pull request #1256 from kwwette/octave

[Octave] Add support for version 4.4
2018-05-17 14:08:57 +10:00 · 2018-05-17 14:08:57 +10:00 · 12c66f9b7d
commit 12c66f9b7d
parent fecc4f246e e66827be7d
11 changed files with 276 additions and 44 deletions
--- 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
--- 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-15: kwwette
+            [Octave] add support for version 4.4
+            - Should not introduce any user-visible incompatibilities
+
 2018-05-15: wsfulton
            [C#, D, Java] Fix lookup of csconstruct, dconstruct and javaconstruct typemaps.
            The C++ namespace was previously ignored when looking up the typemap.
--- 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
--- a/Examples/octave/module_load/runme.m
+++ b/Examples/octave/module_load/runme.m
@ -5,63 +5,73 @@ endif

 # 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
+function testme_1
+  assert(exist("swigexample") == 3);
  swigexample;
+  assert(isglobal("swigexample"));
  assert(cvar.ivar == ifunc);
-  assert(exist("swigexample","var"));
 endfunction
-testme
-testme
+testme_1
+testme_1
+assert(exist("swigexample") == 3);
 swigexample;
+assert(isglobal("swigexample"));
 assert(cvar.ivar == ifunc);
-assert(exist("swigexample","var"));
 clear all
-function testme
+function testme_2
+  assert(exist("swigexample") == 3);
  swigexample;
+  assert(isglobal("swigexample"));
  assert(cvar.ivar == ifunc);
-  assert(exist("swigexample","var"));
 endfunction
-testme
-testme
+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
+function testme_3
+  assert(exist("swigexample") == 3);
  swigexample;
+  assert(isglobal("swigexample"));
  assert(cvar.ivar == ifunc);
-  assert(exist("swigexample","var"));
 endfunction
-testme
-testme
+testme_3
+testme_3
 clear all
+assert(exist("swigexample") == 3);
 swigexample;
+assert(isglobal("swigexample"));
 assert(cvar.ivar == ifunc);
-assert(exist("swigexample","var"));
-function testme
+function testme_4
+  assert(exist("swigexample") == 3);
  swigexample;
+  assert(isglobal("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
@ -71,13 +81,16 @@ endif

 # 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
--- 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
--- a/Examples/test-suite/register_par.i
+++ b/Examples/test-suite/register_par.i
@ -1,10 +1,10 @@
 %module register_par

 %{
-struct tree;
+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) {}
 }
--- 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<value_type> octseq(obj);
 	  if (seq) {
--- 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();
@ -214,7 +218,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;
--- 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<std::string> 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();
@ -383,7 +448,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();
@ -401,7 +470,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<int> a = out.int_vector_value();
           if (error_state) return dim_vector(1,1);
@ -476,8 +549,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;
@ -848,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;
    }

@ -1238,7 +1322,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());
  }
@ -1261,12 +1351,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);
@ -1300,6 +1402,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);
@ -1309,6 +1414,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);
@ -1357,7 +1465,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) ) {
@ -1390,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
@ -1406,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) {
--- 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
@ -170,7 +174,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;
@ -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
@ -312,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;
@ -322,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
@ -351,15 +363,54 @@ 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

+#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();

+#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();
@ -426,10 +477,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

  }
--- 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<T,U> *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<T,U> **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");