and exception specifications for native types.
Now the raised exception contains the string value as the exception
message instead of just the C/C++ type of the exception.
R exceptions were completely swallowed beforehand
For implementing full move semantics when passing parameters by value.
Based on SWIGTYPE && and std::unique_ptr typemaps which implement move
semantics.
Added for all languages, but untested for: Go, Ocaml, R, Scilab (and
unlikely to be fully functional for same reasons as for std::unique_ptr
support).
Issue #999
SWIG has always marshalled the null matrix into a NULL pointer; this remains
and now we have consistency in representing a NULL pointer.
This is a pre-requisite for a pending commit to fully support std::unique_ptr.
Avoid using reserved identifiers such as `_DOHINT_H` (fixes#1989),
fix cases where the name doesn't match the filename, and make the naming
more consistent and less likely to collide with include guards in other
headers.
The directorin typemaps in the director methods now use std::move on the
input parameter when copying the object from the stack to the heap prior
to the callback into the target language, thereby taking advantage of
move semantics if available.
- This reverts commit 931656bcbe
- Since atexit() does not pass along the desired exit status,
__swig_atexit__() always exits with status zero, regardless
of whether Octave completed successfully or raised an error.
- This means the success/failure of Octave scripts which load
SWIG modules cannot be determined by other programs, which
makes them unusable.
- Instead, provide a Octave function swig_exit() which calls
::_Exit() with a given exit status. This way at least a
clean exit from Octave can be guaranteed for future versions
if the seg-fault problem is not fixed.
- The {DECLARE|DEFINE}_OV_TYPEID_FUNCTIONS_AND_DATA declarations
attached to this class cause a seg-fault in the module_load
Octave example. Removing these declarations fixes the seg-fault.
- While cause of seg-fault is unknown, note that (in Octave 5.1.0)
the declaration of octave_function, which is the base class for
octave_swig_bound_func, does not use these declarations. So it's
possible they simply are not required for this type of subclass.
The type long may be 4 bytes but swig_this() must return the address of
the object as an integer. Using size_t ensures that the return type can
store a pointer.
With octave 4.4 the function
virtual bool octave_base_value::is_object() const
was renamed to
virtual bool octave_base_value::isobject() const
As noted in CHANGES "2012-03-26: xavier98", is_object() must return true
for swig types whereas octave_base_value::is_object returns false per
default.
- 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
- Remove python code from octave's std_basic_string.i
- Correctly return an error to fix error handling when using std::basic_string in
overloaded methods - issue #1171.
Add director.swg for Go as was completely absent.
This is just the start of a common exception handling approach to directors.
An exception thrown in a Java director method will be propogated back to
Java via a C++ DirectorException.
DirectorException throws typemap for Java is fully working, all other languages need work.
DirectorException throws typemap for Perl added just to fix compilation errors.
Add director_exception_catches test.
The directorin typemaps will now generate a temporary variable
(specified after the type), such as:
%typemap(directorin) MyType (MyType *temp) { ... use temp ... }
The shared_ptr director typemaps have been fixed for use in functions
that take more than one parameter.
Modify the Python and Ruby director shared_ptr typemaps to be language neutral.
Port the director modifications to other scripting languages that
have shared_ptr support - Octave, R and Scilab. Scilab shared_ptr
support is not fully working and needs work though.
