jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into vadz-doxygen

Browse source 
* master:
  Add Octave 4.4 to Travis allow_failures
  Fixes for appveyor image changes
  Javascript test-suite Makefile parallel jobs
  Add changes entry for csconstruct, dconstruct and javaconstruct fix
  Fix lookup of csconstruct, dconstructor and javaconstruct typemaps
  Javascript %nspace fix in generated C++ code
  Add C++17 documentation chapter
  Add changes notes for C++17 nested namespaces support
  Test for invalid C++17 nested namespace aliases
  Test c++17 nested namespaces and %nspace
  Add c++17 nested namespaces runtime test for C#
  Add c++17 nested namespaces runtime test for Python
  Add support for c++17 nested namespaces
  Update CHANGES.current
  .travis.yml: test against Octave 4.4
  Examples/test-suite/register_par.i: rename 'tree' to 'swig_tree'
  Examples/octave/module_load/runme.m: update 'exist()' statements for Octave >= 4.4
  Examples/octave/module_load/runme.m: do not use duplicate function names
  Examples/Makefile.in: unset OCTAVE_PATH when running Octave for tests
  Lib/octave: fix getting/setting global variables for Octave >= 4.4
  Lib/octave: use new class for function member dereference with Octave >= 4.4
  Lib/octave: fix operator installation for Octave >= 4.4
  Lib/Octave: in Octave >= 4.4, assign reference to base class in subclass
  Lib/octave: fix call to mlock() for Octave >= 4.4
  Lib/octave: fix call to octave::call_stack::current() for Octave >= 4.4
  Lib/octave: 'octave_exit' not longer exists in Octave >= 4.4
  Lib/octave: replace is_bool_type() with islogical() for Octave >= 4.4
  Lib/octave: replace is_numeric_type() with isnumeric() for Octave >= 4.4
  Lib/octave: replace is_cell() with iscell() for Octave >= 4.4
  Lib/octave: call octave::feval() instead of feval() for Octave >= 4.4
  Lib/octave: fix function name passed to unwind_protect::begin_frame()
  C#, D, Java methodmodifiers on destructors
  Javascript assert.h - move to header section
  Appveyor cl compiler warning fixes during configure
  Java vector wrappers cast correction
  test-suite fixes (Java directors) for compilers that don't support varargs
  Go - use director.swg like other languages
  test-suite fixes (2) for compilers that don't support varargs
  Consistent spacing in generated exception specifications
  test-suite fixes for compilers that don't support vararg macros
  Enhance Travis testing to use gcc 8 and test C++17 and C17
  Enhance SWIG_isfinite for older standards: C++03/C++98/C89
  test-suite support for gcc-8 targeting C++11 and C++14
  Scilab portability fixes - remove use of strdup
  Scilab array overbounds fix handling char type exceptions
  test-suite fix for c++17 and throw macro
  Remove use of 'register' in C source
  test-suite support for C++17: switch testing of the deprecated C++17 'register' keyword from C++ to C
  Examples update to support C++17: exception specification throw removal
  Cosmetic syntax tweak using throw in Octave directors
  test-suite support for C++17 (Java): exception specification throw removal
  test-suite support for C++17: exception specification throw removal
  __cplusplus macro usage tweak
  Improve detection of Python's 2to3 tool
  Correct C shared library creation when specifing CC to configure
  Remove superfluous parens in generated Python scripts.
  [ci] guile 2.2 build no longer expected to fail
  guile - resstructure some configure tests
  Disable guile configuration if guile-config and guile report a different version
  Fix guile executable detection on early 2.0.x guile versions
  guile - drop GDB_INTERFACE related stuff
  guile - replace obsolete scm_listify with scm_list_n
  guile - use more reliable method of finding guile executable based on guile-config
  Fix go version matching in configure for go1.10
  [Python] Suppress new pycodestyle warning
  Add if-no-present action for jsv8inc arg
  Fix typo in help --with-jscoreinc and --with-jscorelib
  Fix off-by-one error
  * Makefile.in (configfiles): Update URLs for latest configfiles.
  Add changes entry for Ruby %alias fix for global functions
  [Ruby] Pass Qnil instead of NULL to rb_funcall()
  Fix typo
  Fix ruby %alias directive for native c functions
  Stop testing Python on Appveyor msys/mingw
  Fix -Wimplicit-fallthrough gcc-7.3 warning
This commit is contained in:
William S Fulton 2018-05-17 19:57:02 +01:00
commit 0cfd53cff7
136 changed files with 2767 additions and 1956 deletions
Download patch file Download diff file Expand all files Collapse all files

65
Lib/go/director.swg
View file

@ -6,6 +6,7 @@
* ----------------------------------------------------------------------------- */
#include <exception>
#include <map>
namespace Swig {
@ -13,3 +14,67 @@ namespace Swig {
};
}
/* Handle memory management for directors. */
namespace {
struct GCItem {
virtual ~GCItem() {}
};
struct GCItem_var {
GCItem_var(GCItem *item = 0) : _item(item) {
}
GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
~GCItem_var() {
delete _item;
}
GCItem* operator->() {
return _item;
}
private:
GCItem *_item;
};
template <typename Type>
struct GCItem_T : GCItem {
GCItem_T(Type *ptr) : _ptr(ptr) {
}
virtual ~GCItem_T() {
delete _ptr;
}
private:
Type *_ptr;
};
}
class Swig_memory {
public:
template <typename Type>
void swig_acquire_pointer(Type* vptr) {
if (vptr) {
swig_owner[vptr] = new GCItem_T<Type>(vptr);
}
}
private:
typedef std::map<void *, GCItem_var> swig_ownership_map;
swig_ownership_map swig_owner;
};
template <typename Type>
static void swig_acquire_pointer(Swig_memory** pmem, Type* ptr) {
if (!pmem) {
*pmem = new Swig_memory;
}
(*pmem)->swig_acquire_pointer(ptr);
}

69
Lib/go/goruntime.swg
View file

@ -346,75 +346,6 @@ type _swig_fnptr *byte
type _swig_memberptr *byte
%}
/* Handle memory management for directors. */
%insert(director) %{
#include <map>
namespace {
struct GCItem {
virtual ~GCItem() {}
};
struct GCItem_var {
GCItem_var(GCItem *item = 0) : _item(item) {
}
GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
~GCItem_var() {
delete _item;
}
GCItem* operator->() {
return _item;
}
private:
GCItem *_item;
};
template <typename Type>
struct GCItem_T : GCItem {
GCItem_T(Type *ptr) : _ptr(ptr) {
}
virtual ~GCItem_T() {
delete _ptr;
}
private:
Type *_ptr;
};
}
class Swig_memory {
public:
template <typename Type>
void swig_acquire_pointer(Type* vptr) {
if (vptr) {
swig_owner[vptr] = new GCItem_T<Type>(vptr);
}
}
private:
typedef std::map<void *, GCItem_var> swig_ownership_map;
swig_ownership_map swig_owner;
};
template <typename Type>
static void swig_acquire_pointer(Swig_memory** pmem, Type* ptr) {
if (!pmem) {
*pmem = new Swig_memory;
}
(*pmem)->swig_acquire_pointer(ptr);
}
%}
/* For directors we need C++ to track a Go pointer. Since we can't
pass a Go pointer into C++, we use a map to track the pointers on
the Go side. */

4
Lib/guile/guile_scm.swg
View file

@ -26,10 +26,10 @@
else { \
if (!gswig_list_p) { \
gswig_list_p = 1; \
gswig_result = scm_listify(gswig_result, object, SCM_UNDEFINED); \
gswig_result = scm_list_n(gswig_result, object, SCM_UNDEFINED); \
} \
else \
gswig_result = scm_append(scm_listify(gswig_result, scm_listify(object, SCM_UNDEFINED), SCM_UNDEFINED)); \
gswig_result = scm_append(scm_list_n(gswig_result, scm_list_n(object, SCM_UNDEFINED), SCM_UNDEFINED)); \
}
%}

6
Lib/guile/guile_scm_run.swg
View file

@ -24,6 +24,8 @@ scm_module_variable (SCM module, SCM sym)
return scm_sym2var (sym, scm_module_lookup_closure (module), SCM_BOOL_F);
}
#define scm_to_utf8_string scm_to_locale_string
#define scm_from_utf8_string scm_from_locale_string
#endif
#if SCM_MAJOR_VERSION >= 2
@ -40,10 +42,6 @@ typedef struct swig_guile_clientdata {
SCM goops_class;
} swig_guile_clientdata;
#if SCM_MAJOR_VERSION <= 2
#define scm_to_utf8_string scm_to_locale_string
#define scm_from_utf8_string scm_from_locale_string
#endif
#define SWIG_scm2str(s) \
SWIG_Guile_scm2newstr(s, NULL)
#define SWIG_str02scm(str) \

5
Lib/guile/guilemain.i
View file

@ -12,11 +12,6 @@
extern "C" {
#endif
/* Debugger interface (don't change the order of the following lines) */
#define GDB_TYPE SCM
#include <libguile/gdb_interface.h>
GDB_INTERFACE;
static void
inner_main(void *closure, int argc, char **argv)
{

16
Lib/guile/typemaps.i
View file

@ -69,13 +69,13 @@
%typemap(throws) SWIGTYPE {
$&ltype temp = new $ltype($1);
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(SWIG_NewPointerObj(temp, $&descriptor, 1),
scm_list_n(SWIG_NewPointerObj(temp, $&descriptor, 1),
SCM_UNDEFINED));
}
%typemap(throws) SWIGTYPE & {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(SWIG_NewPointerObj(&$1, $descriptor, 1),
scm_list_n(SWIG_NewPointerObj(&$1, $descriptor, 1),
SCM_UNDEFINED));
}
@ -87,13 +87,13 @@
%typemap(throws) SWIGTYPE * {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
scm_list_n(SWIG_NewPointerObj($1, $descriptor, 1),
SCM_UNDEFINED));
}
%typemap(throws) SWIGTYPE [] {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
scm_list_n(SWIG_NewPointerObj($1, $descriptor, 1),
SCM_UNDEFINED));
}
@ -176,7 +176,7 @@
%typemap(varout) enum SWIGTYPE { $result = scm_from_long((int)$1); }
%typemap(throws) enum SWIGTYPE {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(scm_from_long((int)$1), SCM_UNDEFINED));
scm_list_n(scm_from_long((int)$1), SCM_UNDEFINED));
}
/* The SIMPLE_MAP_WITH_EXPR macro below defines the whole set of
@ -225,7 +225,7 @@
%typemap(throws) C_NAME {
C_NAME swig_c_value = $1;
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(C_TO_SCM_EXPR, SCM_UNDEFINED));
scm_list_n(C_TO_SCM_EXPR, SCM_UNDEFINED));
}
%enddef
@ -269,7 +269,7 @@
/* Throw typemap */
%typemap(throws) C_NAME {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(C_TO_SCM($1), SCM_UNDEFINED));
scm_list_n(C_TO_SCM($1), SCM_UNDEFINED));
}
%enddef
@ -344,7 +344,7 @@ SIMPLE_MAP(unsigned long long, scm_to_ulong_long, scm_from_ulong_long, integer);
%typemap(throws) char * {
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
scm_listify(SWIG_str02scm($1), SCM_UNDEFINED));
scm_list_n(SWIG_str02scm($1), SCM_UNDEFINED));
}
/* Void */

10
Lib/java/std_vector.i
View file

@ -114,7 +114,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) {
}
void doAdd(jint index, const value_type& value) throw (std::out_of_range) {
const jint size = static_cast<std::vector< CTYPE >::size_type>(self->size());
jint size = static_cast<jint>(self->size());
if (0 <= index && index <= size) {
self->insert(self->begin() + index, value);
} else {
@ -123,7 +123,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) {
}
value_type doRemove(jint index) throw (std::out_of_range) {
const jint size = static_cast<std::vector< CTYPE >::size_type>(self->size());
jint size = static_cast<jint>(self->size());
if (0 <= index && index < size) {
CTYPE const old_value = (*self)[index];
self->erase(self->begin() + index);
@ -134,7 +134,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) {
}
CREF_TYPE doGet(jint index) throw (std::out_of_range) {
const jint size = static_cast<std::vector< CTYPE >::size_type>(self->size());
jint size = static_cast<jint>(self->size());
if (index >= 0 && index < size)
return (*self)[index];
else
@ -142,7 +142,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) {
}
value_type doSet(jint index, const value_type& value) throw (std::out_of_range) {
const jint size = static_cast<std::vector< CTYPE >::size_type>(self->size());
jint size = static_cast<jint>(self->size());
if (index >= 0 && index < size) {
CTYPE const old_value = (*self)[index];
(*self)[index] = value;
@ -153,7 +153,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) {
}
void doRemoveRange(jint fromIndex, jint toIndex) throw (std::out_of_range) {
const jint size = static_cast<std::vector< CTYPE >::size_type>(self->size());
jint size = static_cast<jint>(self->size());
if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
self->erase(self->begin() + fromIndex, self->begin() + toIndex);
} else {

6
Lib/javascript/v8/javascriptinit.swg
View file

@ -1,6 +1,8 @@
%insert(init) %{
%insert(header) %{
#include <assert.h>
%}
%insert(init) %{
SWIGRUNTIME void
SWIG_V8_SetModule(void *, swig_module_info *swig_module) {

6
Lib/octave/director.swg
View file

@ -51,7 +51,7 @@ namespace Swig {
public:
static void raise(const char *msg) {
// ... todo
throw(DirectorException());
throw DirectorException();
}
static void raise(const octave_value &ov, const char *msg) {
@ -64,7 +64,7 @@ namespace Swig {
public:
static void raise(const char *msg) {
// ... todo
throw(DirectorTypeMismatchException());
throw DirectorTypeMismatchException();
}
static void raise(const octave_value &ov, const char *msg) {
@ -77,7 +77,7 @@ namespace Swig {
public:
static void raise(const char *msg) {
// ... todo
throw(DirectorPureVirtualException());
throw DirectorPureVirtualException();
}
static void raise(const octave_value &ov, const char *msg) {

4
Lib/octave/octcontainer.swg
View file

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

12
Lib/octave/octprimtypes.swg
View file

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

143
Lib/octave/octrun.swg
View file

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

63
Lib/octave/octruntime.swg
View file

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

16
Lib/octave/std_pair.i
View file

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

2
Lib/scilab/sciexception.swg
View file

@ -43,7 +43,7 @@
}
%typemap(throws, noblock=1) char, char& {
char obj[1];
char obj[2];
sprintf(obj, "%c", (char)$1);
SWIG_Scilab_Raise_Ex(obj, "$type", $descriptor);
}

7
Lib/scilab/scirun.swg
View file

@ -49,8 +49,13 @@ static char *SWIG_Scilab_GetFuncName(void) {
static void SWIG_Scilab_SetFuncName(char *funcName) {
if (SwigFuncName != NULL) {
free(SwigFuncName);
SwigFuncName = NULL;
}
if (funcName) {
SwigFuncName = (char *)malloc(strlen(funcName) + 1);
if (SwigFuncName)
strcpy(SwigFuncName, funcName);
}
SwigFuncName = strdup(funcName);
}
/* Api context management functions */

8
Lib/typemaps/fragments.swg
View file

@ -102,7 +102,7 @@
/* isfinite() is a macro for C99 */
# if defined(isfinite)
# define SWIG_isfinite(X) (isfinite(X))
# elif defined __cplusplus && __cplusplus >= 201103L
# elif defined(__cplusplus) && __cplusplus >= 201103L
/* Use a template so that this works whether isfinite() is std::isfinite() or
* in the global namespace. The reality seems to vary between compiler
* versions.
@ -118,6 +118,12 @@ inline int SWIG_isfinite_func(T x) {
return isfinite(x);
}
# define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
# define SWIG_isfinite(X) (__builtin_isfinite(X))
# elif defined(__clang__) && defined(__has_builtin)
# if __has_builtin(__builtin_isfinite)
# define SWIG_isfinite(X) (__builtin_isfinite(X))
# endif
# elif defined(_MSC_VER)
# define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)