diff --git a/Lib/scilab/scicontainer.swg b/Lib/scilab/scicontainer.swg index a1e9b059f..ee740173e 100644 --- a/Lib/scilab/scicontainer.swg +++ b/Lib/scilab/scicontainer.swg @@ -1,7 +1,7 @@ /* ----------------------------------------------------------------------------- * scicontainer.swg * - * Scilab list <-> C++ container wrapper (Based on Octave wrapper) + * Scilab list <-> C++ container wrapper * * This wrapper, and its iterator, allows a general use (and reuse) of * the mapping between C++ and Scilab, thanks to the C++ templates. @@ -15,177 +15,32 @@ #include %} - #if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS) # if !defined(SWIG_EXPORT_ITERATOR_METHODS) # define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS # endif #endif + +// #define (SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS) +// if defined: sequences in return are converted from/to Scilab lists or matrices +// if not defined: sequences are passed from/to Scilab as pointers + +%{ +#define SWIG_STD_NOASSIGN_STL +%} + %include +%include -// The Scilab C++ Wrap - -%insert(header) %{ +%{ #include %} %include -%fragment(SWIG_Traits_frag(SciObject),"header",fragment="StdTraits") { -namespace swig { - template <> struct traits { - typedef value_category category; - static const char* type_name() { return "SciObject"; } - }; - - template <> struct traits_from { - typedef SciObject value_type; - static SciObject from(const value_type& val) { - return val; - } - }; - - template <> - struct traits_check { - static bool check(const SciObject&) { - return true; - } - }; - - template <> struct traits_asval { - typedef SciObject value_type; - static int asval(const SciObject& obj, value_type *val) { - if (val) *val = obj; - return SWIG_OK; - } - }; -} -} - -%fragment("SciSequence_Base","header",fragment="") -{ -%#include - -namespace std { - template <> - struct less : public binary_function - { - bool - operator()(const SciObject& v, const SciObject& w) const - { - //SciObject res = do_binary_op(SciObject::op_le,v,w); - return true;//res.is_true(); - } - }; -} - -namespace swig { - inline size_t - check_index(ptrdiff_t i, size_t size, bool insert = false) { - if ( i < 0 ) { - if ((size_t) (-i) <= size) - return (size_t) (i + size); - } else if ( (size_t) i < size ) { - return (size_t) i; - } else if (insert && ((size_t) i == size)) { - return size; - } - - throw std::out_of_range("index out of range"); - } - - inline size_t - slice_index(ptrdiff_t i, size_t size) { - if ( i < 0 ) { - if ((size_t) (-i) <= size) { - return (size_t) (i + size); - } else { - throw std::out_of_range("index out of range"); - } - } else { - return ( (size_t) i < size ) ? ((size_t) i) : size; - } - } - - template - inline typename Sequence::iterator - getpos(Sequence* self, Difference i) { - typename Sequence::iterator pos = self->begin(); - std::advance(pos, check_index(i,self->size())); - return pos; - } - - template - inline typename Sequence::const_iterator - cgetpos(const Sequence* self, Difference i) { - typename Sequence::const_iterator pos = self->begin(); - std::advance(pos, check_index(i,self->size())); - return pos; - } - - template - inline Sequence* - getslice(const Sequence* self, Difference i, Difference j) { - typename Sequence::size_type size = self->size(); - typename Sequence::size_type ii = swig::check_index(i, size); - typename Sequence::size_type jj = swig::slice_index(j, size); - - if (jj > ii) { - typename Sequence::const_iterator vb = self->begin(); - typename Sequence::const_iterator ve = self->begin(); - std::advance(vb,ii); - std::advance(ve,jj); - return new Sequence(vb, ve); - } else { - return new Sequence(); - } - } - - template - inline void - setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) { - typename Sequence::size_type size = self->size(); - typename Sequence::size_type ii = swig::check_index(i, size, true); - typename Sequence::size_type jj = swig::slice_index(j, size); - if (jj < ii) jj = ii; - size_t ssize = jj - ii; - if (ssize <= v.size()) { - typename Sequence::iterator sb = self->begin(); - typename InputSeq::const_iterator vmid = v.begin(); - std::advance(sb,ii); - std::advance(vmid, jj - ii); - self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end()); - } else { - typename Sequence::iterator sb = self->begin(); - typename Sequence::iterator se = self->begin(); - std::advance(sb,ii); - std::advance(se,jj); - self->erase(sb,se); - self->insert(sb, v.begin(), v.end()); - } - } - - template - inline void - delslice(Sequence* self, Difference i, Difference j) { - typename Sequence::size_type size = self->size(); - typename Sequence::size_type ii = swig::check_index(i, size, true); - typename Sequence::size_type jj = swig::slice_index(j, size); - if (jj > ii) { - typename Sequence::iterator sb = self->begin(); - typename Sequence::iterator se = self->begin(); - std::advance(sb,ii); - std::advance(se,jj); - self->erase(sb,se); - } - } -} -} - -%fragment("SciSequence_Cont","header", +%fragment("SciSequence_Cont", "header", fragment="StdTraits", - fragment="SciSequence_Base", fragment="SciSwigIterator_T") { %#include @@ -193,43 +48,46 @@ namespace swig { namespace swig { template - struct SciSequence_Ref // * Scilab can't support these, because of how assignment works + struct SciSequence_Ref { SciSequence_Ref(const SciObject& seq, int index) : _seq(seq), _index(index) { + if (traits_as_sequence::get(_seq, &_piSeqAddr) != SWIG_OK) + { + throw std::invalid_argument("Cannot getl sequence data."); + } } operator T () const { - // swig::SwigVar_PyObject item = SciSequence_GetItem(_seq, _index); - SciObject item; // * todo - try { - return swig::as(item, true); - } catch (std::exception& e) { - char msg[1024]; - sprintf(msg, "in sequence element %d ", _index); - if (!Scilab_Error_Occurred()) { - %type_error(swig::type_name()); - } - SWIG_Scilab_AddErrorMsg(msg); - SWIG_Scilab_AddErrorMsg(e.what()); - throw; + try + { + T value; + if (traits_asval_sequenceitem::asval(_seq, _piSeqAddr, _index, &value) == SWIG_OK) + { + return value; + } + } + catch (std::exception& e) + { + SWIG_Scilab_AddErrorMsg(e.what()); } } SciSequence_Ref& operator=(const T& v) { - // SciSequence_SetItem(_seq, _index, swig::from(v)); - // * todo + // TODO return *this; } - private: - SciObject _seq; - int _index; + private: + SciObject _seq; + int _index; + void *_piSeqAddr; }; + template struct SciSequence_ArrowProxy { @@ -349,14 +207,6 @@ namespace swig SciSequence_Cont(const SciObject& seq) : _seq(seq) { - // * assert that we have map type etc. - /* - if (!SciSequence_Check(seq)) { - throw std::invalid_argument("a sequence is expected"); - } - _seq = seq; - Py_INCREF(_seq); - */ } ~SciSequence_Cont() @@ -365,8 +215,15 @@ namespace swig size_type size() const { - // return static_cast(SciSequence_Size(_seq)); - return 0; // * todo + int iSeqSize; + if (traits_as_sequence::size(_seq, &iSeqSize) == SWIG_OK) + { + return iSeqSize; + } + else + { + return 0; + } } bool empty() const @@ -404,28 +261,9 @@ namespace swig return const_reference(_seq, n); } - bool check(bool set_err = true) const - { - int s = size(); - for (int i = 0; i < s; ++i) { - // swig::SwigVar_PyObject item = SciSequence_GetItem(_seq, i); - SciObject item; // * todo - if (!swig::check(item)) { - if (set_err) { - char msg[1024]; - sprintf(msg, "in sequence element %d", i); - SWIG_Error(SWIG_RuntimeError, msg); - } - return false; - } - } - return true; - } - private: SciObject _seq; }; - } } @@ -491,30 +329,6 @@ namespace swig %swig_sequence_iterator(%arg(Sequence)) %swig_container_methods(%arg(Sequence)) - %fragment("SciSequence_Base"); - - %extend { - value_type pop() throw (std::out_of_range) { - if (self->size() == 0) - throw std::out_of_range("pop from empty container"); - Sequence::value_type x = self->back(); - self->pop_back(); - return x; - } - - value_type __paren__(difference_type i) throw (std::out_of_range) { - return *(swig::cgetpos(self, i)); - } - - void __paren_asgn__(difference_type i, value_type x) throw (std::out_of_range) { - *(swig::getpos(self,i)) = x; - } - - void append(value_type x) { - self->push_back(x); - } - } - %enddef %define %swig_sequence_methods(Sequence...) @@ -531,20 +345,21 @@ namespace swig %fragment("StdSequenceTraits","header", fragment="StdTraits", - fragment="SciSequence_Cont") + fragment="SciSequence_Cont", + fragment=SWIG_Traits_SequenceItem_frag(ptr)) { namespace swig { template inline void - assign(const SciSeq& sciseq, Seq* seq) { + assign(const SciSeq& sciSeq, Seq* seq) { %#ifdef SWIG_STD_NOASSIGN_STL typedef typename SciSeq::value_type value_type; - typename SciSeq::const_iterator it = sciseq.begin(); - for (;it != sciseq.end(); ++it) { + typename SciSeq::const_iterator it = sciSeq.begin(); + for (;it != sciSeq.end(); ++it) { seq->insert(seq->end(),(value_type)(*it)); } %#else - seq->assign(sciseq.begin(), sciseq.end()); + seq->assign(sciSeq.begin(), sciSeq.end()); %#endif } @@ -553,9 +368,41 @@ namespace swig { typedef Seq sequence; typedef T value_type; - static int asptr(const SciObject& obj, sequence **seq) { - // TODO: convert input Scilab list (or pointer) to sequence. - return SWIG_ERROR; + static int asptr(const SciObject& obj, sequence **seq) + { + swig_type_info *typeInfo = swig::type_info(); + if (typeInfo) + { + sequence *p; + if (SWIG_ConvertPtr(obj, (void**)&p, typeInfo, 0) == SWIG_OK) + { + if (seq) + *seq = p; + return SWIG_OLDOBJ; + } + } + + if (traits_as_sequence::check(obj) == SWIG_OK) + { + try + { + SciSequence_Cont sciSeq(obj); + if (seq) + { + *seq = new sequence(); + assign(sciSeq, *seq); + return SWIG_NEWOBJ; + } + else + { + return true; + } + } + catch (std::exception& e) + { + SWIG_Scilab_AddErrorMsg(e.what()); + } + } } }; @@ -566,15 +413,39 @@ namespace swig { typedef typename Seq::size_type size_type; typedef typename sequence::const_iterator const_iterator; - static SciObject from(const sequence& seq) { -#ifdef SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS - swig_type_info *desc = swig::type_info(); - if (desc && desc->clientdata) { - return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + static SciObject from(const sequence& seq) + { + %#ifdef SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS + swig_type_info *typeInfo = swig::type_info(); + if (typeInfo) + { + return SWIG_NewPointerObj(new sequence(seq), typeInfo, SWIG_POINTER_OWN); + } + %#endif + + try + { + void *data; + size_type size = seq.size(); + if (traits_from_sequence::create(size, &data) == SWIG_OK) { + const_iterator it; + int index = 0; + for (it = seq.begin(); it != seq.end(); ++it) + { + traits_from_sequenceitem::from(data, index, *it); + index++; + } + return traits_from_sequence::set(size, data); + } + else + { + return 0; + } + } + catch (std::exception& e) + { + SWIG_Scilab_AddErrorMsg(e.what()); } -#endif - // TODO: return a Scilab list from the sequence. - return (SciObject)0; } }; } diff --git a/Lib/scilab/scilist.swg b/Lib/scilab/scilist.swg new file mode 100644 index 000000000..fc73d463a --- /dev/null +++ b/Lib/scilab/scilist.swg @@ -0,0 +1,78 @@ +/* + * Scilab list related functions + * + */ + +%fragment("SWIG_ScilabList", "header") +{ +SWIGINTERN int +SWIG_GetScilabList(SciObject _obj, int **_piListAddr) +{ + SciErr sciErr; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, _piListAddr); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + return SWIG_OK; +} + +SWIGINTERN int +SWIG_GetScilabListSize(SciObject _obj, int *_piListSize) +{ + SciErr sciErr; + int *piListAddr; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piListAddr); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + sciErr = getListItemNumber(pvApiCtx, piListAddr, _piListSize); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + return SWIG_OK; +} + + +SWIGINTERN int +SWIG_CheckScilabList(SciObject _obj) +{ + SciErr sciErr; + int *piListAddr; + int iType; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piListAddr); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + sciErr = getVarType(pvApiCtx, piListAddr, &iType); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + if ((iType != sci_list) && (iType != sci_tlist) && (iType != sci_mlist)) + { + Scierror(999, _("%s: Wrong type for input argument #%d: A list is expected.\n"), fname, _obj); + return SWIG_ERROR; + } + + return SWIG_OK; +} + +} + diff --git a/Lib/scilab/scisequence.swg b/Lib/scilab/scisequence.swg new file mode 100644 index 000000000..c889f1a18 --- /dev/null +++ b/Lib/scilab/scisequence.swg @@ -0,0 +1,153 @@ +/* + * + * Scilab sequence conversions + * + */ + +#define SWIG_Traits_Sequence_frag(Type) %fragment_name(AsVal_Traits_Sequence, Type) + +#define SWIG_AsCheck_Sequence_frag(Type...) %fragment_name(AsCheck_Sequence, Type) +#define SWIG_AsCheck_Sequence_dec(Type...) %symbol_name(AsCheck_Sequence, Type) +#define SWIG_AsGet_Sequence_frag(Type...) %fragment_name(AsGet_Sequence, Type) +#define SWIG_AsGet_Sequence_dec(Type...) %symbol_name(AsGet_Sequence, Type) +#define SWIG_AsSize_Sequence_frag(Type...) %fragment_name(AsSize_Sequence, Type) +#define SWIG_AsSize_Sequence_dec(Type...) %symbol_name(AsSize_Sequence, Type) +#define SWIG_FromCreate_Sequence_frag(Type...) %fragment_name(FromCreate_Sequence, Type) +#define SWIG_FromCreate_Sequence_dec(Type...) %symbol_name(FromCreate_Sequence, Type) +#define SWIG_FromSet_Sequence_frag(Type...) %fragment_name(FromSet_Sequence, Type) +#define SWIG_FromSet_Sequence_dec(Type...) %symbol_name(FromSet_Sequence, Type) + +#define SWIG_Traits_SequenceItem_frag(Type) %fragment_name(AsVal_Traits_SequenceItem, Type) +#define SWIG_AsVal_SequenceItem_frag(Type...) %fragment_name(AsVal_SequenceItem, Type) +#define SWIG_AsVal_SequenceItem_dec(Type...) %symbol_name(AsVal_SequenceItem, Type) +#define SWIG_From_SequenceItem_frag(Type...) %fragment_name(From_SequenceItem, Type) +#define SWIG_From_SequenceItem_dec(Type...) %symbol_name(From_SequenceItem, Type) + + +%include +%include +%include +%include + +// +// Sequence conversion +// + +%fragment(SWIG_Traits_Sequence_frag(ptr), "header", + fragment=SWIG_AsCheck_Sequence_frag(ptr), + fragment=SWIG_AsGet_Sequence_frag(ptr), + fragment=SWIG_AsSize_Sequence_frag(ptr), + fragment=SWIG_FromCreate_Sequence_frag(ptr), + fragment=SWIG_FromSet_Sequence_frag(ptr)) { + +namespace swig { + template struct traits_as_sequence { + static int check(SciObject obj) { + return SWIG_AsCheck_Sequence_dec(ptr)(obj); + } + static int get(SciObject obj, void **sequence) { + return SWIG_AsGet_Sequence_dec(ptr)(obj, (int **)sequence); + } + static int size(SciObject obj, int *size) { + return SWIG_AsSize_Sequence_dec(ptr)(obj, size); + } + }; + template struct traits_from_sequence { + static int create(int size, void **sequence) { + return SWIG_FromCreate_Sequence_dec(ptr)(size, (int ***)sequence); + } + static SciObject set(int size, void *sequence) { + return SWIG_FromSet_Sequence_dec(ptr)(size, (int **)sequence); + } + }; +} +} + +%define %traits_sequence(CppType, ScilabType) + %fragment(SWIG_Traits_Sequence_frag(CppType), "header", + fragment=SWIG_Traits_Sequence_frag(ptr), + fragment=SWIG_AsCheck_Sequence_frag(CppType), + fragment=SWIG_AsGet_Sequence_frag(CppType), + fragment=SWIG_AsSize_Sequence_frag(CppType), + fragment=SWIG_FromCreate_Sequence_frag(CppType), + fragment=SWIG_FromSet_Sequence_frag(CppType)) { + +namespace swig { + template <> struct traits_as_sequence { + static int check(SciObject obj) { + return SWIG_AsCheck_Sequence_dec(CppType)(obj); + } + static int get(SciObject obj, void **sequence) { + return SWIG_AsGet_Sequence_dec(CppType)(obj, (ScilabType **)sequence); + } + static int size(SciObject obj, int *size) { + return SWIG_AsSize_Sequence_dec(CppType)(obj, size); + } + }; + template <> struct traits_from_sequence { + static int create(int size, void **sequence) { + return SWIG_FromCreate_Sequence_dec(CppType)(size, (ScilabType **)sequence); + } + static SciObject set(int size, void *sequence) { + return SWIG_FromSet_Sequence_dec(CppType)(size, (ScilabType *)sequence); + } + }; +} +} +%enddef + + +// +// Sequence item conversion +// + +%fragment(SWIG_Traits_SequenceItem_frag(ptr), "header", + fragment=SWIG_AsVal_SequenceItem_frag(ptr), + fragment=SWIG_From_SequenceItem_frag(ptr)) { + +namespace swig { + template struct traits_asval_sequenceitem { + static int asval(SciObject obj, void *pSequence, int iItemIndex, T *pItemValue) { + return SWIG_AsVal_SequenceItem_dec(ptr)(obj, (int *)pSequence, iItemIndex, (int **)pItemValue); + } + }; + template struct traits_from_sequenceitem { + static int from(void *pSequence, int iItemIndex, T itemValue) { + return SWIG_From_SequenceItem_dec(ptr)((int **)pSequence, iItemIndex, (int*)itemValue); + } + }; +} +} + +%define %traits_sequenceitem(CppType, ScilabType) + %fragment(SWIG_Traits_SequenceItem_frag(CppType), "header", + fragment=SWIG_Traits_SequenceItem_frag(ptr), + fragment=SWIG_AsVal_SequenceItem_frag(CppType), + fragment=SWIG_From_SequenceItem_frag(CppType)) { + +namespace swig { + template <> struct traits_asval_sequenceitem { + static int asval(SciObject obj, void *pSequence, int iItemIndex, CppType *pItemValue) { + return SWIG_AsVal_SequenceItem_dec(CppType)(obj, (ScilabType *)pSequence, iItemIndex, pItemValue); + } + }; + template <> struct traits_from_sequenceitem { + static int from(void *pSequence, int iItemIndex, CppType itemValue) { + return SWIG_From_SequenceItem_dec(CppType)((ScilabType *)pSequence, iItemIndex, itemValue); + } + }; +} +} +%enddef + +%define %add_traits_sequence(CppType, ScilabType) + %traits_sequence(CppType, ScilabType); + %fragment(SWIG_Traits_Sequence_frag(CppType)); + %traits_sequenceitem(CppType, ScilabType); + %fragment(SWIG_Traits_SequenceItem_frag(CppType)); +%enddef + +%add_traits_sequence(int, int); +%add_traits_sequence(double, double); +%add_traits_sequence(std::string, char*); + diff --git a/Lib/scilab/scisequencedouble.swg b/Lib/scilab/scisequencedouble.swg new file mode 100644 index 000000000..cc07f6a39 --- /dev/null +++ b/Lib/scilab/scisequencedouble.swg @@ -0,0 +1,103 @@ +/* + * + * Scilab matrix of double <-> C++ double container + * + */ + +%include + +%fragment(SWIG_AsCheck_Sequence_frag(double), "header", + fragment="SWIG_SciDouble_AsDoubleArrayAndSize") { + +SWIGINTERN int +SWIG_AsCheck_Sequence_dec(double)(SciObject _obj) { + SciErr sciErr; + int *piAddrVar; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + if (isDoubleType(pvApiCtx, piAddrVar)) + { + return SWIG_OK; + } + else + { + Scierror(999, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFname(), _obj); + return SWIG_ERROR; + } +} +} + +%fragment(SWIG_AsGet_Sequence_frag(double), "header", + fragment="SWIG_SciDouble_AsDoubleArrayAndSize") { + +SWIGINTERN int +SWIG_AsGet_Sequence_dec(double)(SciObject _obj, double **_pSequence) { + int iMatrixRowCount; + int iMatrixColCount; + return (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname())); +} +} + +%fragment(SWIG_AsSize_Sequence_frag(double), "header", + fragment="SWIG_SciDouble_AsDoubleArrayAndSize") { + +SWIGINTERN int +SWIG_AsSize_Sequence_dec(double)(SciObject _obj, int *_piSize) { + double *pdblMatrix; + int iMatrixRowCount; + int iMatrixColCount; + if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { + if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { + Scierror(999, _("%s: Wrong size for input argument #%d: A double vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); + return SWIG_ERROR; + } + *_piSize = iMatrixRowCount * iMatrixColCount; + return SWIG_OK; + } + return SWIG_ERROR; +} +} + +%fragment(SWIG_FromCreate_Sequence_frag(double), "header") { + +SWIGINTERN int +SWIG_FromCreate_Sequence_dec(double)(int _size, double **_sequence) { + *_sequence = new double[_size]; + return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; +} +} + +%fragment(SWIG_FromSet_Sequence_frag(double), "header", + fragment="SWIG_SciDouble_FromDoubleArrayAndSize") { + +SWIGINTERN SciObject +SWIG_FromSet_Sequence_dec(double)(int _size, double *_sequence) { + SciObject obj = SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); + delete (double *)_sequence; + return obj; +} +} + +%fragment(SWIG_AsVal_SequenceItem_frag(double), "header") { + +SWIGINTERN int +SWIG_AsVal_SequenceItem_dec(double)(SciObject _obj, double *_pSequence, int _iItemIndex, double *_pItemValue) { + *_pItemValue = _pSequence[_iItemIndex]; + return SWIG_OK; +} +} + +%fragment(SWIG_From_SequenceItem_frag(double), "header") { + +SWIGINTERN int +SWIG_From_SequenceItem_dec(double)(double *_pSequence, int _iItemIndex, double _itemValue) { + _pSequence[_iItemIndex] = _itemValue; + return SWIG_OK; +} +} + diff --git a/Lib/scilab/scisequenceint.swg b/Lib/scilab/scisequenceint.swg new file mode 100644 index 000000000..f4e4427d8 --- /dev/null +++ b/Lib/scilab/scisequenceint.swg @@ -0,0 +1,102 @@ +/* + * + * Scilab matrix of int <-> C++ int container + * + */ + +%include + +%fragment(SWIG_AsCheck_Sequence_frag(int), "header", + fragment="SWIG_SciInt32_AsIntArrayAndSize") { + +SWIGINTERN int +SWIG_AsCheck_Sequence_dec(int)(SciObject _obj) { + SciErr sciErr; + int *piAddrVar; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + if (isIntegerType(pvApiCtx, piAddrVar)) + { + return SWIG_OK; + } + else + { + Scierror(999, _("%s: Wrong type for input argument #%d: An integer is expected.\n"), SWIG_Scilab_GetFname(), _obj); + return SWIG_ERROR; + } +} +} + +%fragment(SWIG_AsGet_Sequence_frag(int), "header", + fragment="SWIG_SciInt32_AsIntArrayAndSize") { + +SWIGINTERN int +SWIG_AsGet_Sequence_dec(int)(SciObject _obj, int **_pSequence) { + int iMatrixRowCount; + int iMatrixColCount; + return (SWIG_SciInt32_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname())); +} +} + +%fragment(SWIG_AsSize_Sequence_frag(int), "header", + fragment="SWIG_SciInt32_AsIntArrayAndSize") { + +SWIGINTERN int +SWIG_AsSize_Sequence_dec(int)(SciObject _obj, int *_piSize) { + int *piMatrix; + int iMatrixRowCount; + int iMatrixColCount; + if (SWIG_SciInt32_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { + if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { + Scierror(999, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); + return SWIG_ERROR; + } + *_piSize = iMatrixRowCount * iMatrixColCount; + return SWIG_OK; + } + return SWIG_ERROR; +} +} + +%fragment(SWIG_FromCreate_Sequence_frag(int), "header") { + +SWIGINTERN int +SWIG_FromCreate_Sequence_dec(int)(int _size, int **_sequence) { + *_sequence = new int[_size]; + return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; +} +} + +%fragment(SWIG_FromSet_Sequence_frag(int), "header", + fragment="SWIG_SciInt32_FromIntArrayAndSize") { + +SWIGINTERN SciObject +SWIG_FromSet_Sequence_dec(int)(int _size, int *_sequence) { + SciObject obj = SWIG_SciInt32_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); + delete (int *)_sequence; + return obj; +} +} + +%fragment(SWIG_AsVal_SequenceItem_frag(int), "header") { + +SWIGINTERN int +SWIG_AsVal_SequenceItem_dec(int)(SciObject _obj, int *_pSequence, int _iItemIndex, int *_pItemValue) { + *_pItemValue = _pSequence[_iItemIndex]; + return SWIG_OK; +} +} + +%fragment(SWIG_From_SequenceItem_frag(int), "header") { + +SWIGINTERN int +SWIG_From_SequenceItem_dec(int)(int *_pSequence, int _iItemIndex, int _itemValue) { + _pSequence[_iItemIndex] = _itemValue; + return SWIG_OK; +} +} diff --git a/Lib/scilab/scisequencepointer.swg b/Lib/scilab/scisequencepointer.swg new file mode 100644 index 000000000..f68b2969c --- /dev/null +++ b/Lib/scilab/scisequencepointer.swg @@ -0,0 +1,121 @@ +/* + * + * Scilab list of pointer <-> C++ pointer container + * + */ + +%include + +%fragment(SWIG_AsCheck_Sequence_frag(ptr), "header", + fragment="SWIG_ScilabList") { + +SWIGINTERN int +SWIG_AsCheck_Sequence_dec(ptr)(SciObject _obj) { + return SWIG_CheckScilabList(_obj); +} +} + +%fragment(SWIG_AsGet_Sequence_frag(ptr), "header", + fragment="SWIG_ScilabList") { + +SWIGINTERN int +SWIG_AsGet_Sequence_dec(ptr)(SciObject _obj, int **_piSequence) { + return SWIG_GetScilabList(_obj, _piSequence); +} +} + +%fragment(SWIG_AsSize_Sequence_frag(ptr), "header", + fragment="SWIG_ScilabList") { + +SWIGINTERN int +SWIG_AsSize_Sequence_dec(ptr)(SciObject _obj, int *_piSize) { + return SWIG_GetScilabListSize(_obj, _piSize); +} +} + +%fragment(SWIG_FromCreate_Sequence_frag(ptr), "header") { + +SWIGINTERN int +SWIG_FromCreate_Sequence_dec(ptr)(int _size, int ***_sequence) { + *_sequence = new int*[_size]; + return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; +} +} + +%fragment(SWIG_FromSet_Sequence_frag(ptr), "header") { + +SWIGINTERN SciObject +SWIG_FromSet_Sequence_dec(ptr)(int _size, int **_sequence) { + SciErr sciErr; + int *piListAddr; + + int iVarOut = nbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition(); + + sciErr = createList(pvApiCtx, iVarOut, _size, &piListAddr); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + for (int i=0; i<_size; i++) + { + sciErr = createPointerInList(pvApiCtx, iVarOut, piListAddr, i + 1, (void *)_sequence[i]); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + } + delete (int*)_sequence; + return iVarOut; +} +} + +%fragment(SWIG_AsVal_SequenceItem_frag(ptr), "header") { + +SWIGINTERN int +SWIG_AsVal_SequenceItem_dec(ptr)(SciObject _obj, int* _piSequence, int _itemIndex, int **_pItemValue) +{ + SciErr sciErr; + int *piItemAddr; + int iType; + + sciErr = getListItemAddress(pvApiCtx, _piSequence, _itemIndex + 1, &piItemAddr); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + sciErr = getVarType(pvApiCtx, piItemAddr, &iType); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + if (iType != sci_pointer) + { + Scierror(999, _("%s: Wrong type for input argument #%d: A pointer is expected at list item #%d.\n"), fname, _obj, _itemIndex + 1); + return SWIG_ERROR; + } + + sciErr = getPointerInList(pvApiCtx, _piSequence, _itemIndex + 1, (void **)_pItemValue); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + return SWIG_OK; +} +} + +%fragment(SWIG_From_SequenceItem_frag(ptr), "header") { + +SWIGINTERN int +SWIG_From_SequenceItem_dec(ptr)(int **_pSequence, int _iItemIndex, int *_itemValue) { + _pSequence[_iItemIndex] = _itemValue; +} +} diff --git a/Lib/scilab/scisequencestring.swg b/Lib/scilab/scisequencestring.swg new file mode 100644 index 000000000..bde797728 --- /dev/null +++ b/Lib/scilab/scisequencestring.swg @@ -0,0 +1,97 @@ +/* + *char + * Scilab matrix of string <-> C++ std::string container + * + */ + +%include + +%fragment(SWIG_AsCheck_Sequence_frag(std::string), "header", + fragment="SwigScilabStringToCharPtrArrayAndSize") { + +SWIGINTERN int +SWIG_AsCheck_Sequence_dec(std::string)(SciObject _obj) { + SciErr sciErr; + int *piAddrVar; + + sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + + if (isStringType(pvApiCtx, piAddrVar)) + { + return SWIG_OK; + } + else + { + Scierror(999, _("%s: Wrong type for input argument #%d: A string is expected.\n"), SWIG_Scilab_GetFname(), _obj); + return SWIG_ERROR; + } +} +} + +%fragment(SWIG_AsGet_Sequence_frag(std::string), "header", + fragment="SwigScilabStringToCharPtrArrayAndSize") { + +SWIGINTERN int +SWIG_AsGet_Sequence_dec(std::string)(SciObject _obj, char ***_pSequence) { + int iSize; + return (SwigScilabStringToCharPtrArrayAndSize(pvApiCtx, _obj, _pSequence, &iSize, SWIG_Scilab_GetFname())); +} +} + +%fragment(SWIG_AsSize_Sequence_frag(std::string), "header", + fragment="SwigScilabStringToCharPtrArrayAndSize") { + +SWIGINTERN int +SWIG_AsSize_Sequence_dec(std::string)(SciObject _obj, int *_piSize) { + char **pstMatrix; + if (SwigScilabStringToCharPtrArrayAndSize(pvApiCtx, _obj, &pstMatrix, _piSize, SWIG_Scilab_GetFname()) == SWIG_OK) { + return SWIG_OK; + } + return SWIG_ERROR; +} +} + +%fragment(SWIG_FromCreate_Sequence_frag(std::string), "header") { + +SWIGINTERN int +SWIG_FromCreate_Sequence_dec(std::string)(int _size, char ***_sequence) { + *_sequence = new char*[_size]; + return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; +} +} + +%fragment(SWIG_FromSet_Sequence_frag(std::string), "header", + fragment="SwigScilabStringFromCharPtrArray") { + +SWIGINTERN SciObject +SWIG_FromSet_Sequence_dec(std::string)(int _size, char **_sequence) { + SciObject obj = SwigScilabStringFromCharPtrArray(pvApiCtx, SWIG_Scilab_GetOutputPosition(), _sequence, _size); + delete (char **)_sequence; + return obj; +} +} + +%fragment(SWIG_AsVal_SequenceItem_frag(std::string), "header") { + +SWIGINTERN int +SWIG_AsVal_SequenceItem_dec(std::string)(SciObject _obj, char **_pSequence, int _iItemIndex, std::string *_pItemValue) { + *_pItemValue = std::string(_pSequence[_iItemIndex]); + return SWIG_OK; +} +} + +%fragment(SWIG_From_SequenceItem_frag(std::string), "header") { + +SWIGINTERN int +SWIG_From_SequenceItem_dec(std::string)(char **_pSequence, int _iItemIndex, std::string _itemValue) { + char *pChar = new char(_itemValue.size() + 1); + strcpy(pChar, _itemValue.c_str()); + _pSequence[_iItemIndex] = pChar; + return SWIG_OK; +} +} +