Attack of the Clones 93/17493/12
Cedric Delamarre [Tue, 24 Nov 2015 11:09:39 +0000 (12:09 +0100)]
 * check types ref before modify it
 * use more polymorphism stuff
 * clone return this type instead of InternalType

Change-Id: I1a267a1eabc5b8a40592c7292c37cf7fcdedb072

74 files changed:
scilab/modules/api_scilab/includes/api_variable.hxx
scilab/modules/api_scilab/src/cpp/api_internal_error.hxx
scilab/modules/api_scilab/src/cpp/api_list_cpp.cpp
scilab/modules/api_scilab/src/cpp/template/api_boolean.hpp
scilab/modules/api_scilab/src/cpp/template/api_cell.hpp
scilab/modules/api_scilab/src/cpp/template/api_handle.hpp
scilab/modules/api_scilab/src/cpp/template/api_list.hpp
scilab/modules/ast/includes/ast/debuggervisitor.hxx
scilab/modules/ast/includes/symbol/variables.hxx
scilab/modules/ast/includes/types/arrayof.hxx
scilab/modules/ast/includes/types/bool.hxx
scilab/modules/ast/includes/types/cell.hxx
scilab/modules/ast/includes/types/double.hxx
scilab/modules/ast/includes/types/function.hxx
scilab/modules/ast/includes/types/graphichandle.hxx
scilab/modules/ast/includes/types/implicitlist.hxx
scilab/modules/ast/includes/types/int.hxx
scilab/modules/ast/includes/types/internal.hxx
scilab/modules/ast/includes/types/library.hxx
scilab/modules/ast/includes/types/list.hxx
scilab/modules/ast/includes/types/listdelete.hxx
scilab/modules/ast/includes/types/listinsert.hxx
scilab/modules/ast/includes/types/listoperation.hxx
scilab/modules/ast/includes/types/listundefined.hxx
scilab/modules/ast/includes/types/macro.hxx
scilab/modules/ast/includes/types/macrofile.hxx
scilab/modules/ast/includes/types/mlist.hxx
scilab/modules/ast/includes/types/pointer.hxx
scilab/modules/ast/includes/types/polynom.hxx
scilab/modules/ast/includes/types/sparse.hxx
scilab/modules/ast/includes/types/string.hxx
scilab/modules/ast/includes/types/struct.hxx
scilab/modules/ast/includes/types/threadId.hxx
scilab/modules/ast/includes/types/tlist.hxx
scilab/modules/ast/includes/types/types.hxx
scilab/modules/ast/includes/types/types_tools.hxx
scilab/modules/ast/includes/types/user.hxx
scilab/modules/ast/includes/types/void.hxx
scilab/modules/ast/src/cpp/ast/run_OpExp.hpp
scilab/modules/ast/src/cpp/ast/visitor_common.cpp
scilab/modules/ast/src/cpp/types/arrayof.cpp
scilab/modules/ast/src/cpp/types/bool.cpp
scilab/modules/ast/src/cpp/types/cell.cpp
scilab/modules/ast/src/cpp/types/double.cpp
scilab/modules/ast/src/cpp/types/function.cpp
scilab/modules/ast/src/cpp/types/graphichandle.cpp
scilab/modules/ast/src/cpp/types/implicitlist.cpp
scilab/modules/ast/src/cpp/types/library.cpp
scilab/modules/ast/src/cpp/types/list.cpp
scilab/modules/ast/src/cpp/types/listdelete.cpp
scilab/modules/ast/src/cpp/types/listinsert.cpp
scilab/modules/ast/src/cpp/types/listoperation.cpp
scilab/modules/ast/src/cpp/types/listundefined.cpp
scilab/modules/ast/src/cpp/types/macro.cpp
scilab/modules/ast/src/cpp/types/macrofile.cpp
scilab/modules/ast/src/cpp/types/polynom.cpp
scilab/modules/ast/src/cpp/types/sparse.cpp
scilab/modules/ast/src/cpp/types/string.cpp
scilab/modules/ast/src/cpp/types/struct.cpp
scilab/modules/ast/src/cpp/types/threadId.cpp
scilab/modules/ast/src/cpp/types/tlist.cpp
scilab/modules/ast/src/cpp/types/types_tools.cpp
scilab/modules/ast/src/cpp/types/void.cpp
scilab/modules/ast/tests/unit_tests/newtype.hxx
scilab/modules/core/sci_gateway/cpp/sci_what.cpp
scilab/modules/external_objects/src/cpp/EOType.hxx
scilab/modules/fftw/src/cpp/fftw_common.hxx
scilab/modules/fileio/sci_gateway/cpp/sci_mfprintf.cpp
scilab/modules/linear_algebra/src/cpp/scischur.cpp
scilab/modules/scicos/sci_gateway/cpp/sci_callblk.cpp
scilab/modules/scicos/src/cpp/extractblklist.cpp
scilab/modules/scicos/src/cpp/view_scilab/BaseAdapter.hxx
scilab/modules/signal_processing/src/cpp/signalprocessingfunctions.cpp
scilab/modules/xcos/sci_gateway/cpp/sci_xcosCellCreated.cpp

index 953d0bf..84ab484 100644 (file)
@@ -333,7 +333,7 @@ public :
     {
         if (this->data)
         {
-            return this->data->setComplex(_bComplex);
+            this->data->setComplex(_bComplex);
         }
     }
 
index 2434400..67bcc21 100644 (file)
@@ -9,4 +9,9 @@
 * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 */
 
+#ifndef __API_INTERNAL_ERROR_HXX__
+#define __API_INTERNAL_ERROR_HXX__
+
 void scilab_setInternalError(scilabEnv env, const std::wstring& name, const std::wstring& msg);
+
+#endif /* !__API_INTERNAL_ERROR_HXX__ */
index 47f9b5b..6119abf 100644 (file)
@@ -110,7 +110,7 @@ bool TList::set(const std::wstring& _sKey, Variable* _pV)
 {
     if (data)
     {
-        return ((types::TList*)data)->set(_sKey, (types::InternalType*)_pV->getReturnVariable());
+        return ((types::TList*)data)->set(_sKey, (types::InternalType*)_pV->getReturnVariable()) != nullptr;
     }
 
     return false;
index 780e96a..2afd922 100644 (file)
 
 #include "gatewaystruct.hxx"
 #include "bool.hxx"
-#include "api_internal_error.hxx"
 
 extern "C"
 {
 #include "api_scilab.h"
 }
 
+#include "api_internal_error.hxx"
+
 /* Scilab 6 API*/
 scilabVar API_PROTO(createBooleanMatrix)(scilabEnv env, int dim, int* const dims)
 {
@@ -127,7 +128,7 @@ scilabStatus API_PROTO(setBooleanArray)(scilabEnv env, scilabVar var, int* const
     }
 #endif
 
-    bool bset = b->set(vals);
+    bool bset = b->set(vals) != nullptr;
 #ifdef __API_SCILAB_SAFE__
     if (bset == false)
     {
index 5638604..dfd32a5 100644 (file)
@@ -114,7 +114,7 @@ scilabStatus API_PROTO(setCellValue)(scilabEnv env, scilabVar var, int* index, s
     }
 #endif
     int i = c->getIndex(index);
-    bool bset = c->set(i, (types::InternalType*)val);
+    bool bset = c->set(i, (types::InternalType*)val) != nullptr;
 #ifdef __API_SCILAB_SAFE__
     if (bset == false)
     {
@@ -137,7 +137,7 @@ scilabStatus API_PROTO(setCell2dValue)(scilabEnv env, scilabVar var, int row, in
     }
 #endif
     int i = c->getIndex(index);
-    bool bset = c->set(i, (types::InternalType*)val);
+    bool bset = c->set(i, (types::InternalType*)val) != nullptr;
 #ifdef __API_SCILAB_SAFE__
     if (bset == false)
     {
index d8d428a..d3caa12 100644 (file)
@@ -109,7 +109,7 @@ scilabStatus API_PROTO(setHandleArray)(scilabEnv env, scilabVar var, const long
     }
 #endif
 
-    bool bset = h->set(vals);
+    bool bset = h->set(vals) != nullptr;
 #ifdef __API_SCILAB_SAFE__
     if (bset == false)
     {
index 1d17af7..765e3b4 100644 (file)
@@ -95,7 +95,7 @@ scilabStatus API_PROTO(setListItem)(scilabEnv env, scilabVar var, int index, con
     }
 #endif
  
-    bool ret = l->set(index, (types::InternalType*)val);
+    bool ret = l->set(index, (types::InternalType*)val) != nullptr;
     return ret ? STATUS_OK : STATUS_ERROR;
 }
 
@@ -150,7 +150,7 @@ scilabStatus API_PROTO(setTListField)(scilabEnv env, scilabVar var, const wchar_
         fields->set(fields->getSize() - 1, field);
     }
 
-    bool ret = l->set(field, (types::InternalType*)val);
+    bool ret = l->set(field, (types::InternalType*)val) != nullptr;
     return ret ? STATUS_OK : STATUS_ERROR;
 }
 
@@ -203,7 +203,7 @@ scilabStatus API_PROTO(setMListField)(scilabEnv env, scilabVar var, const wchar_
         fields->set(fields->getSize() - 1, field);
     }
 
-    bool ret = l->set(field, (types::InternalType*)val);
+    bool ret = l->set(field, (types::InternalType*)val) != nullptr;
     return ret ? STATUS_OK : STATUS_ERROR;
 }
 
index 3316ab5..2ed6222 100644 (file)
@@ -15,6 +15,7 @@
 
 #include "runvisitor.hxx"
 #include "printvisitor.hxx"
+#include "types_tools.hxx"
 
 extern "C"
 {
index 6331828..d076df6 100644 (file)
@@ -20,6 +20,7 @@
 #include "internal.hxx"
 #include "double.hxx"
 #include "dynlib_ast.h"
+#include "callable.hxx"
 
 namespace symbol
 {
index 7fdd719..c671b7b 100644 (file)
 #include <sstream>
 #include <cstdio>
 #include "types.hxx"
-#include "types_tools.hxx"
 #include "scilabexception.hxx"
 #include "inspector.hxx"
-#include "scilabWrite.hxx"
 
 extern "C"
 {
@@ -35,14 +33,6 @@ extern "C"
 namespace types
 {
 
-//commom function
-EXTERN_AST int computeTuples(int* _piCountDim, int _iDims, int _iCurrentDim, int* _piIndex);
-EXTERN_AST InternalType* createEmptyDouble();
-EXTERN_AST InternalType* createDoubleVector(int _iSize);
-EXTERN_AST int getIntValueFromDouble(InternalType* _pIT, int _iPos);
-EXTERN_AST double* getDoubleArrayFromDouble(InternalType* _pIT);
-EXTERN_AST bool checkArgValidity(typed_list& _pArg);
-
 static int get_max_size(int* _piDims, int _iDims);
 
 /*    template<typename T>
@@ -178,10 +168,7 @@ protected :
 
     virtual T               getNullValue() = 0;
     virtual ArrayOf<T>*     createEmpty(int _iDims, int* _piDims, bool _bComplex = false) = 0;
-    virtual InternalType*   createEmpty()
-    {
-        return createEmptyDouble();
-    }
+    virtual GenericType*    createEmpty();
 
     virtual T               copyValue(T _data) = 0;
     virtual T*              allocData(int _iSize) = 0;
@@ -226,8 +213,15 @@ public :
         return m_pImgData != NULL;
     }
 
-    virtual void setComplex(bool _bComplex)
+    virtual ArrayOf<T>* setComplex(bool _bComplex)
     {
+        typedef ArrayOf<T>* (ArrayOf<T>::*setcplx_t)(bool);
+        ArrayOf<T>* pIT = checkRef(this, (setcplx_t)&ArrayOf<T>::setComplex, _bComplex);
+        if (pIT != this)
+        {
+            return pIT;
+        }
+
         if (_bComplex == false)
         {
             if (m_pImgData != NULL)
@@ -243,21 +237,30 @@ public :
                 memset(m_pImgData, 0x00, sizeof(T) * m_iSize);
             }
         }
+
+        return this;
     }
 
-    virtual bool set(int _iPos, T _data)
+    virtual ArrayOf<T>* set(int _iPos, T _data)
     {
         if (m_pRealData == NULL || _iPos >= m_iSize)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*set_t)(int, T);
+        ArrayOf<T>* pIT = checkRef(this, (set_t)&ArrayOf<T>::set, _iPos, _data);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         deleteData(m_pRealData[_iPos]);
         m_pRealData[_iPos] = copyValue(_data);
-        return true;
+        return this;
     }
 
-    virtual bool set(int _iRows, int _iCols, T _data)
+    virtual ArrayOf<T>* set(int _iRows, int _iCols, T _data)
     {
         //            int piIndexes[2];
         //            piIndexes[0] = _iRows;
@@ -266,11 +269,18 @@ public :
         return set(_iCols * getRows() + _iRows, _data);
     }
 
-    virtual bool set(T* _pdata)
+    virtual ArrayOf<T>* set(T* _pdata)
     {
         if (m_pRealData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*set_t)(T*);
+        ArrayOf<T>* pIT = checkRef(this, (set_t)&ArrayOf<T>::set, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0 ; i < m_iSize ; i++)
@@ -278,14 +288,21 @@ public :
             deleteData(m_pRealData[i]);
             m_pRealData[i] = copyValue(_pdata[i]);
         }
-        return true;
+        return this;
     }
 
-    virtual bool set(const T* _pdata)
+    virtual ArrayOf<T>* set(const T* _pdata)
     {
         if (m_pRealData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*set_t)(const T*);
+        ArrayOf<T>* pIT = checkRef(this, (set_t)&ArrayOf<T>::set, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0 ; i < m_iSize ; i++)
@@ -293,7 +310,8 @@ public :
             deleteData(m_pRealData[i]);
             m_pRealData[i] = copyValue(_pdata[i]);
         }
-        return true;
+
+        return this;
     }
 
     inline T* get() const
@@ -317,50 +335,74 @@ public :
     }
 
     /*internal function to manage img part*/
-    bool setImg(int _iPos, T _data)
+    ArrayOf<T>* setImg(int _iPos, T _data)
     {
         if (m_pImgData == NULL || _iPos >= m_iSize)
         {
-            return false;
+            return NULL;
         }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*setimg_t)(int, T);
+        ArrayOf<T>* pIT = checkRef(this, (setimg_t)&ArrayOf<T>::setImg, _iPos, _data);
+        if (pIT != this)
+        {
+            return pIT;
+        }
+
         m_pImgData[_iPos] = copyValue(_data);
-        return true;
+        return this;
     }
 
 
-    bool setImg(int _iRows, int _iCols, T _data)
+    ArrayOf<T>* setImg(int _iRows, int _iCols, T _data)
     {
         int piIndexes[2] = {_iRows, _iCols};
         return setImg(getIndex(piIndexes), copyValue(_data));
     }
 
-    bool setImg(T* _pdata)
+    ArrayOf<T>* setImg(T* _pdata)
     {
         if (m_pImgData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*setimg_t)(T*);
+        ArrayOf<T>* pIT = checkRef(this, (setimg_t)&ArrayOf<T>::setImg, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0 ; i < m_iSize ; i++)
         {
             m_pImgData[i] = copyValue(_pdata[i]);
         }
-        return true;
+
+        return this;
     }
 
 
-    bool setImg(const T* _pdata)
+    ArrayOf<T>* setImg(const T* _pdata)
     {
         if (m_pImgData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef ArrayOf<T>* (ArrayOf<T>::*setimg_t)(const T*);
+        ArrayOf<T>* pIT = checkRef(this, (setimg_t)&ArrayOf<T>::setImg, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0 ; i < m_iSize ; i++)
         {
             m_pImgData[i] = copyValue(_pdata[i]);
         }
-        return true;
+
+        return this;
     }
 
     inline T* getImg() const
@@ -383,12 +425,14 @@ public :
         return getImg(getIndex(piIndexes));
     }
 
-    InternalType* insert(typed_list* _pArgs, InternalType* _pSource);
-    static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
-    virtual bool append(int _iRows, int _iCols, InternalType* _poSource);
-    InternalType* remove(typed_list* _pArgs);
-    InternalType* extract(typed_list* _pArgs);
-    bool resize(int* _piDims, int _iDims);
+    virtual ArrayOf<T>* insert(typed_list* _pArgs, InternalType* _pSource);
+    virtual ArrayOf<T>* append(int _iRows, int _iCols, InternalType* _poSource);
+    virtual ArrayOf<T>* resize(int* _piDims, int _iDims);
+
+    // return a GenericType because of [] wich is a types::Double (can't be a ArrayOf<char>)
+    virtual GenericType* remove(typed_list* _pArgs);
+    virtual GenericType* extract(typed_list* _pArgs);
+    virtual GenericType* insertNew(typed_list* _pArgs);
 
     virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e) override;
     virtual bool isInvokable() const;
@@ -396,53 +440,16 @@ public :
     virtual int getInvokeNbIn();
     virtual int getInvokeNbOut();
 
-    bool reshape(int _iNewRows, int _iNewCols)
+    virtual ArrayOf<T>* reshape(int _iNewRows, int _iNewCols)
     {
         int piDims[2] = {_iNewRows, _iNewCols};
         return reshape(piDims, 2);
     }
 
-    bool reshape(int* _piDims, int _iDims)
-    {
-        int iNewSize = get_max_size(_piDims, _iDims);
-        if (iNewSize != m_iSize)
-        {
-            return false;
-        }
-
-        for (int i = 0 ; i < _iDims ; i++)
-        {
-            m_piDims[i] = _piDims[i];
-        }
-
-        if (_iDims == 1)
-        {
-            m_piDims[1] = 1;
-            _iDims++;
-        }
-
-        int iDims = _iDims;
-        for (int i = iDims - 1; i >= 2; --i)
-        {
-            if (m_piDims[i] == 1)
-            {
-                _iDims--;
-            }
-            else
-            {
-                break;
-            }
-        }
+    virtual ArrayOf<T>* reshape(int* _piDims, int _iDims);
 
-        m_iRows = m_piDims[0];
-        m_iCols = m_piDims[1];
-        m_iSize = iNewSize;
-        m_iDims = _iDims;
 
-        return true;
-    }
-
-    bool resize(int _iNewRows, int _iNewCols)
+    virtual ArrayOf<T>* resize(int _iNewRows, int _iNewCols)
     {
         int piDims[2] = {_iNewRows, _iNewCols};
         return resize(piDims, 2);
@@ -465,10 +472,7 @@ public :
         return idx;
     }
 
-    void getIndexes(int _iIndex, int* _piIndexes)
-    {
-        getIndexesWithDims(_iIndex, _piIndexes, m_piDims, m_iDims);
-    }
+    void getIndexes(int _iIndex, int* _piIndexes);
 
     ArrayOf<T>* getColumnValues(int _iPos)
     {
index 7efaee9..b32c289 100644 (file)
@@ -46,7 +46,7 @@ public:
     Bool(int _iRows, int _iCols, int **_piData);
     ~Bool();
 
-    InternalType*           clone();
+    Bool*                   clone();
 
 
     /*zero or one set filler*/
index dd13e28..52d39e3 100644 (file)
@@ -63,15 +63,13 @@ public :
     ** Clone
     ** Create a new List and Copy all values.
     */
-    InternalType*       clone();
+    Cell*               clone();
 
-    bool                set(int _iRows, int _iCols, InternalType* _pIT);
-    bool                set(int _iRows, int _iCols, const InternalType* _pIT);
-    bool                set(int _iIndex, InternalType* _pIT);
-    bool                set(int _iIndex, const InternalType* _pIT);
-    bool                set(InternalType** _pIT);
-
-    bool                append(int _iRows, int _iCols, Cell *_poSource);
+    Cell*               set(int _iRows, int _iCols, InternalType* _pIT);
+    Cell*               set(int _iRows, int _iCols, const InternalType* _pIT);
+    Cell*               set(int _iIndex, InternalType* _pIT);
+    Cell*               set(int _iIndex, const InternalType* _pIT);
+    Cell*               set(InternalType** _pIT);
 
     bool                operator==(const InternalType& it);
     bool                operator!=(const InternalType& it);
index 1cff17f..2f291ab 100644 (file)
@@ -60,10 +60,10 @@ public :
     void                        whoAmI();
     bool                        isEmpty();
 
-    InternalType*               clone();
+    Double*                     clone();
     bool                        fillFromCol(int _iCols, Double *_poSource);
     bool                        fillFromRow(int _iRows, Double *_poSource);
-    bool                        append(int _iRows, int _iCols, InternalType* _poSource);
+    Double*                     append(int _iRows, int _iCols, InternalType* _poSource);
 
     //bool                        append(int _iRows, int _iCols, Double *_poSource);
 
@@ -135,10 +135,10 @@ public :
     inline ScilabId             getId(void)
     {
         return isIdentity() ? isComplex() ? IdIdentityComplex : IdIdentity
-               : isEmpty() ? IdEmpty
+       : isEmpty() ? IdEmpty
                : isComplex() ? isScalar() ? IdScalarDoubleComplex
                : IdDoubleComplex
-               : isScalar() ? IdScalarDouble
+       : isScalar() ? IdScalarDouble
                : IdDouble;
     }
 
@@ -251,48 +251,71 @@ public :
 
     virtual ast::Exp*           getExp(const Location& loc);
 
-    virtual bool set(int _iPos, double _data)
+    virtual Double* set(int _iPos, double _data)
     {
         if (_iPos >= m_iSize)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef Double* (Double::*set_t)(int, double);
+        Double* pIT = checkRef(this, (set_t)&Double::set, _iPos, _data);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         m_pRealData[_iPos] = _data;
-        return true;
+        return this;
     }
 
-    virtual bool set(int _iRows, int _iCols, double _data)
+    virtual Double* set(int _iRows, int _iCols, double _data)
     {
         return set(_iCols * getRows() + _iRows, _data);
     }
 
-    virtual bool set(double* _pdata)
+    virtual Double* set(double* _pdata)
     {
         if (m_pRealData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef Double* (Double::*set_t)(double*);
+        Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0; i < m_iSize; i++)
         {
             m_pRealData[i] = _pdata[i];
         }
-        return true;
+
+        return this;
     }
 
-    virtual bool set(const double* _pdata)
+    virtual Double* set(const double* _pdata)
     {
         if (m_pRealData == NULL)
         {
-            return false;
+            return NULL;
+        }
+
+        typedef Double* (Double::*set_t)(const double*);
+        Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
+        if (pIT != this)
+        {
+            return pIT;
         }
 
         for (int i = 0; i < m_iSize; i++)
         {
             m_pRealData[i] = _pdata[i];
         }
-        return true;
+
+        return this;
     }
 
 
index e33e543..044d201 100644 (file)
@@ -55,7 +55,7 @@ public :
     ~Function();
 
     //FIXME : Should not return NULL
-    InternalType*           clone();
+    virtual Function*       clone();
 
     static Function*        createFunction(const std::wstring& _wstName, GW_FUNC _pFunc, const std::wstring& _wstModule);
     static Function*        createFunction(const std::wstring& _wstName, GW_FUNC_OPT _pFunc, const std::wstring& _wstModule);
@@ -128,7 +128,7 @@ public :
     OptFunction(const std::wstring& _wstName, GW_FUNC_OPT _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
 
     Callable::ReturnValue   call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
-    InternalType*           clone();
+    OptFunction*            clone();
 
     GW_FUNC_OPT             getFunc()
     {
@@ -148,7 +148,7 @@ public:
     WrapFunction(const std::wstring& _wstName, OLDGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
 
     Callable::ReturnValue   call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
-    InternalType*           clone();
+    WrapFunction*           clone();
 
     OLDGW_FUNC              getFunc()
     {
@@ -167,7 +167,7 @@ public:
     WrapCFunction(const std::wstring& _wstName, GW_C_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
 
     Callable::ReturnValue   call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
-    InternalType*           clone();
+    WrapCFunction*          clone();
 
     GW_C_FUNC               getFunc()
     {
@@ -186,7 +186,7 @@ public :
     WrapMexFunction(const std::wstring& _wstName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
 
     Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
-    InternalType*           clone();
+    WrapMexFunction*        clone();
 
     MEXGW_FUNC              getFunc()
     {
index a038819..35f5067 100644 (file)
@@ -27,7 +27,7 @@ public :
 
     virtual                 ~GraphicHandle();
 
-    InternalType*           clone();
+    GraphicHandle*          clone();
 
     void                    whoAmI();
 
index 970893f..2bc808f 100644 (file)
@@ -55,7 +55,7 @@ public :
     virtual ~ImplicitList();
     ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd);
 
-    InternalType* clone();
+    ImplicitList* clone();
 
     inline ScilabType getType(void)
     {
index f038518..a3c2c2a 100644 (file)
@@ -87,7 +87,7 @@ public :
 #endif
     }
 
-    InternalType* clone()
+    Int<T>* clone()
     {
         Int<T> *pbClone = new Int<T>(GenericType::getDims(), GenericType::getDimsArray());
         pbClone->set(ArrayOf<T>::get());
index 288a21b..f537b04 100644 (file)
@@ -221,6 +221,28 @@ public :
     virtual InternalType*           clone(void) = 0;
     virtual ast::Exp*               getExp(const Location& /*loc*/);
 
+    template <typename T, typename F, typename ... A>
+    T* checkRef(T* _pIT, F f, A ... a)
+    {
+        if (getRef() > 1)
+        {
+            // A types:: content in more than one Scilab variable
+            // must be cloned before to be modified.
+            T* pClone = _pIT->clone()->template getAs<T>();
+            T* pIT = (pClone->*f)(a...);
+            if (pIT == NULL)
+            {
+                pClone->killMe();
+            }
+
+            return pIT;
+        }
+
+        return _pIT;
+    }
+
+
+
 #ifdef _SCILAB_DEBUGREF_
     inline void _killme(const char * f, int l)
     {
index 1025ced..a5a4357 100644 (file)
@@ -52,7 +52,7 @@ public :
     }
 
     bool toString(std::wostringstream& ostr);
-    InternalType* clone();
+    Library* clone();
     bool isAssignable()
     {
         return true;
index 0ea48ea..eba5daa 100644 (file)
@@ -48,13 +48,13 @@ public :
     ** append(InternalType *_typedValue)
     ** Append the given value to the end of the List
     */
-    void                            append(InternalType *_typedValue);
+    List*                           append(InternalType *_typedValue);
 
     /**
     ** Clone
     ** Create a new List and Copy all values.
     */
-    InternalType*                   clone();
+    virtual List*                   clone();
 
     bool                            toString(std::wostringstream& ostr);
 
@@ -63,7 +63,7 @@ public :
         return true;
     }
 
-    InternalType*                   insert(typed_list* _pArgs, InternalType* _pSource);
+    List*                           insert(typed_list* _pArgs, InternalType* _pSource);
     InternalType*                   extract(typed_list* _pArgs);
 
     virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & /*e*/) override
@@ -113,7 +113,7 @@ public :
     }
 
     virtual InternalType*           get(const int _iIndex);
-    virtual bool                    set(const int _iIndex, InternalType* _pIT);
+    virtual List*                   set(const int _iIndex, InternalType* _pIT);
 
     /* return type as string ( double, int, cell, list, ... )*/
     virtual std::wstring            getTypeStr()
index b82c583..b28596b 100644 (file)
@@ -25,7 +25,7 @@ public :
     virtual                 ~ListDelete();
 
     // FIXME : Should not return NULL;
-    InternalType*           clone();
+    ListDelete*             clone();
 
     inline ScilabType       getType(void)
     {
index ae8def5..4750465 100644 (file)
@@ -24,7 +24,7 @@ public :
     ListInsert(InternalType* _pIT);
     virtual                 ~ListInsert();
 
-    InternalType*           clone();
+    ListInsert*             clone();
 
     inline ScilabType       getType(void)
     {
index 1318bab..0fb0aa0 100644 (file)
@@ -24,7 +24,7 @@ public :
     ListOperation(): InternalType() {};
     virtual                 ~ListOperation();
 
-    InternalType*           clone();
+    ListOperation*          clone();
 
     inline ScilabType       getType(void)
     {
index 164c1fb..856d511 100644 (file)
@@ -25,7 +25,7 @@ public :
     virtual                 ~ListUndefined();
 
     // FIXME : Should not return NULL;
-    InternalType*           clone();
+    ListUndefined*          clone();
 
     ScilabType                getType(void);
     bool                    isListUndefined()
index 743ca2f..a7525c9 100644 (file)
@@ -38,7 +38,7 @@ public :
     virtual                     ~Macro();
 
     // FIXME : Should not return NULL;
-    InternalType*               clone();
+    Macro*                      clone();
 
     inline ScilabType           getType(void)
     {
index 3a175ef..83fc939 100644 (file)
@@ -28,7 +28,7 @@ public :
     virtual                 ~MacroFile();
 
     //FIXME : Should not return NULL
-    InternalType*           clone();
+    MacroFile*              clone();
 
     inline ScilabType       getType(void)
     {
index 5a23877..3b0540d 100644 (file)
@@ -24,7 +24,7 @@ public :
     MList() : TList() {}
     //Destructor uses ~TList()
 
-    virtual InternalType*           clone()
+    virtual MList*                  clone()
     {
         return new MList(this);
     }
@@ -33,7 +33,7 @@ public :
         std::cout << "types::MList";
     };
 
-    ScilabType                        getType(void)
+    ScilabType                      getType(void)
     {
         return ScilabMList;
     }
index bff375f..03b0686 100644 (file)
@@ -70,7 +70,7 @@ public :
         return true;
     }
 
-    InternalType* clone()
+    Pointer* clone()
     {
         return new Pointer(m_iRows, m_iCols, m_pvData, m_cplx);
     }
index 73c41d4..99f7454 100644 (file)
@@ -45,12 +45,12 @@ public :
     virtual                 ~Polynom();
 
     // FIXME : Should not return NULL
-    InternalType*           clone();
+    Polynom*                clone();
 
-    bool                    setCoef(int _iRows, int _iCols, Double *_pdblCoef);
-    bool                    setCoef(int _iIdx, Double *_pdblCoef);
+    Polynom*                setCoef(int _iRows, int _iCols, Double *_pdblCoef);
+    Polynom*                setCoef(int _iIdx, Double *_pdblCoef);
 
-    virtual void            setComplex(bool _bComplex);
+    virtual Polynom*        setComplex(bool _bComplex);
 
     inline ScilabType       getType(void)
     {
@@ -82,15 +82,15 @@ public :
     Double*                 evaluate(Double* _pdblValue);
     void                    updateRank(void);
     Double*                 getCoef(void);
-    void                    setCoef(Double *_pCoef);
+    Polynom*                setCoef(Double *_pCoef);
     Double*                 extractCoef(int _iRank);
     bool                    insertCoef(int _iRank, Double* _pCoef);
     void                    setZeros();
-    InternalType*           insert(typed_list* _pArgs, InternalType* _pSource);
+    Polynom*                insert(typed_list* _pArgs, InternalType* _pSource);
 
-    bool                    set(int _iPos, SinglePoly* _pS);
-    bool                    set(int _iRows, int _iCols, SinglePoly* _pS);
-    bool                    set(SinglePoly** _pS);
+    Polynom*                set(int _iPos, SinglePoly* _pS);
+    Polynom*                set(int _iRows, int _iCols, SinglePoly* _pS);
+    Polynom*                set(SinglePoly** _pS);
 
     std::wstring            getRowString(int* _piDims, int _iDims, bool _bComplex);
     std::wstring            getColString(int* _piDims, int _iDims, bool _bComplex);
index 0fbd366..9b9f0cf 100644 (file)
@@ -79,14 +79,14 @@ struct EXTERN_AST Sparse : GenericType
     void finalize();
 
     /*data management member function defined for compatibility with the Double API*/
-    bool set(int _iRows, int _iCols, double _dblReal, bool _bFinalize = true);
-    bool set(int _iIndex, double _dblReal, bool _bFinalize = true)
+    Sparse* set(int _iRows, int _iCols, double _dblReal, bool _bFinalize = true);
+    Sparse* set(int _iIndex, double _dblReal, bool _bFinalize = true)
     {
         return set(_iIndex % m_iRows, _iIndex / m_iRows, _dblReal, _bFinalize);
     }
 
-    bool set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize = true);
-    bool set(int _iIndex, std::complex<double> v, bool _bFinalize = true)
+    Sparse* set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize = true);
+    Sparse* set(int _iIndex, std::complex<double> v, bool _bFinalize = true)
     {
         return set(_iIndex % m_iRows, _iIndex / m_iRows, v, _bFinalize);
     }
@@ -159,7 +159,7 @@ struct EXTERN_AST Sparse : GenericType
        @param _iNewCols new minimum nb of cols
        @return true upon succes, false otherwise.
      */
-    bool resize(int _iNewRows, int _iNewCols);
+    Sparse* resize(int _iNewRows, int _iNewCols);
     /* post condition: new total size must be equal to the old size.
                        Two dimensions maximum.
 
@@ -169,8 +169,8 @@ struct EXTERN_AST Sparse : GenericType
        @param _iNewDims new size for each dimension
        @return true upon succes, false otherwise.
     */
-    bool reshape(int* _piNewDims, int _iNewDims);
-    bool reshape(int _iNewRows, int _iNewCols);
+    Sparse* reshape(int* _piNewDims, int _iNewDims);
+    Sparse* reshape(int _iNewRows, int _iNewCols);
     /*
       insert _iSeqCount elements from _poSource at coords given by _piSeqCoord (max in _piMaxDim).
       coords are considered 1D if _bAsVector, 2D otherwise.
@@ -180,18 +180,17 @@ struct EXTERN_AST Sparse : GenericType
       @param  _bAsVector if _piSeqCoord contains 1D coords.
      */
     Sparse* insert(typed_list* _pArgs, InternalType* _pSource);
-    Sparse* insert(typed_list* _pArgs, Sparse* _pSource);
 
-    Sparse* remove(typed_list* _pArgs);
+    GenericType* remove(typed_list* _pArgs);
 
-    static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
+    GenericType* insertNew(typed_list* _pArgs);
 
     /* append _poSource from coords _iRows, _iCols
        @param _iRows row to append from
        @param _iCols col to append from
        @param _poSource src data to append
      */
-    bool append(int r, int c, types::Sparse SPARSE_CONST* src);
+    Sparse* append(int r, int c, types::Sparse SPARSE_CONST* src);
 
     /*
       extract a submatrix
@@ -202,7 +201,7 @@ struct EXTERN_AST Sparse : GenericType
       @param  _bAsVector if _piSeqCoord contains 1D coords.
 
      */
-    InternalType* extract(typed_list* _pArgs);
+    GenericType* extract(typed_list* _pArgs);
     Sparse* extract(int _iSeqCount, int* _piSeqCoord, int* _piMaxDim, int* _piDimSize, bool _bAsVector) SPARSE_CONST;
     virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e);
     virtual bool isInvokable() const;
@@ -472,6 +471,8 @@ private :
      */
     template<typename Src, typename SrcTraversal, typename Sz, typename DestTraversal>
     static bool copyToSparse(Src SPARSE_CONST& src, SrcTraversal srcTrav, Sz n, Sparse& sp, DestTraversal destTrav);
+
+    Sparse* insert(typed_list* _pArgs, Sparse* _pSource);
 };
 
 template<typename T>
@@ -525,20 +526,18 @@ struct EXTERN_AST SparseBool : GenericType
     {
         return const_cast<SparseBool const*>(this)->clone();
     }
-    bool resize(int _iNewRows, int _iNewCols);
-
-    bool reshape(int* _piNewDims, int _iNewDims);
-    bool reshape(int _iNewRows, int _iNewCols);
 
+    SparseBool* resize(int _iNewRows, int _iNewCols);
+    SparseBool* reshape(int* _piNewDims, int _iNewDims);
+    SparseBool* reshape(int _iNewRows, int _iNewCols);
     SparseBool* insert(typed_list* _pArgs, InternalType* _pSource);
-    SparseBool* insert(typed_list* _pArgs, SparseBool* _pSource);
-    SparseBool* remove(typed_list* _pArgs);
+    SparseBool* append(int _iRows, int _iCols, SparseBool SPARSE_CONST* _poSource);
 
-    bool append(int _iRows, int _iCols, SparseBool SPARSE_CONST* _poSource);
+    GenericType* remove(typed_list* _pArgs);
+    GenericType* insertNew(typed_list* _pArgs);
+    GenericType* extract(typed_list* _pArgs);
 
-    static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
     SparseBool* extract(int _iSeqCount, int* _piSeqCoord, int* _piMaxDim, int* _piDimSize, bool _bAsVector) SPARSE_CONST;
-    InternalType* extract(typed_list* _pArgs);
 
     virtual bool invoke(typed_list & in, optional_list &/*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e);
     virtual bool isInvokable() const;
@@ -621,8 +620,8 @@ struct EXTERN_AST SparseBool : GenericType
         return get(_iIndex % m_iRows, _iIndex / m_iRows);
     }
 
-    bool set(int r, int c, bool b, bool _bFinalize = true) SPARSE_CONST;
-    bool set(int _iIndex, bool b, bool _bFinalize = true) SPARSE_CONST
+    SparseBool* set(int r, int c, bool b, bool _bFinalize = true) SPARSE_CONST;
+    SparseBool* set(int _iIndex, bool b, bool _bFinalize = true) SPARSE_CONST
     {
         return set(_iIndex % m_iRows, _iIndex / m_iRows, b, _bFinalize);
     }
@@ -642,6 +641,7 @@ struct EXTERN_AST SparseBool : GenericType
 
 private:
     void create2(int rows, int cols, Bool SPARSE_CONST& src, Double SPARSE_CONST& idx);
+    SparseBool* insert(typed_list* _pArgs, SparseBool* _pSource);
 };
 
 template<typename T>
index 9fc88af..ece0979 100644 (file)
@@ -43,13 +43,13 @@ public :
 
     void                    whoAmI();
 
-    virtual bool            set(int _iPos, const wchar_t* _pwstData);
-    virtual bool            set(int _iRows, int _iCols, const wchar_t* _pwstData);
-    virtual bool            set(const wchar_t* const* _pwstData);
+    virtual String*         set(int _iPos, const wchar_t* _pwstData);
+    virtual String*         set(int _iRows, int _iCols, const wchar_t* _pwstData);
+    virtual String*         set(const wchar_t* const* _pwstData);
 
-    virtual bool            set(int _iPos, const char* _pcData);
-    virtual bool            set(int _iRows, int _iCols, const char* _pcData);
-    virtual bool            set(const char* const* _pstrData);
+    virtual String*         set(int _iPos, const char* _pcData);
+    virtual String*         set(int _iRows, int _iCols, const char* _pcData);
+    virtual String*         set(const char* const* _pstrData);
 
     bool                    operator==(const InternalType& it);
     bool                    operator!=(const InternalType& it);
@@ -65,7 +65,7 @@ public :
     {
         return L"c";
     }
-    InternalType*           clone();
+    String*                 clone();
 
     inline ScilabType       getType()
     {
@@ -85,11 +85,8 @@ public :
         return false;
     }
 
-    virtual bool neg(InternalType *& out)
+    virtual bool neg(InternalType *& /*out*/)
     {
-        // silent unused parameters warnings
-        (void) out;
-
         return false;
     }
 
index 3a15aeb..6595f2a 100644 (file)
@@ -64,13 +64,13 @@ public :
     ** Clone
     ** Create a new List and Copy all values.
     */
-    InternalType*               clone();
+    Struct*                     clone();
 
-    bool                        set(int _iRows, int _iCols, SingleStruct* _pIT);
-    bool                        set(int _iRows, int _iCols, const SingleStruct* _pIT);
-    bool                        set(int _iIndex, SingleStruct* _pIT);
-    bool                        set(int _iIndex, const SingleStruct* _pIT);
-    bool                        set(SingleStruct** _pIT);
+    Struct*                     set(int _iRows, int _iCols, SingleStruct* _pIT);
+    Struct*                     set(int _iRows, int _iCols, const SingleStruct* _pIT);
+    Struct*                     set(int _iIndex, SingleStruct* _pIT);
+    Struct*                     set(int _iIndex, const SingleStruct* _pIT);
+    Struct*                     set(SingleStruct** _pIT);
 
     bool                        operator==(const InternalType& it);
     bool                        operator!=(const InternalType& it);
@@ -112,8 +112,8 @@ public :
     std::vector<InternalType*>  extractFields(typed_list* _pArgs);
     inline InternalType *       extractField(const std::wstring& wstField);
 
-    bool                        resize(int* _piDims, int _iDims);
-    bool                        resize(int _iNewRows, int _iNewCols);
+    Struct*                     resize(int* _piDims, int _iDims);
+    Struct*                     resize(int _iNewRows, int _iNewCols);
 
     /*specials functions to disable clone operation during copydata*/
     InternalType*               insertWithoutClone(typed_list* _pArgs, InternalType* _pSource);
index f80774a..224cfea 100644 (file)
@@ -44,7 +44,7 @@ public :
     {
         return L"tid";
     }
-    InternalType*           clone();
+    ThreadId*               clone();
 
     __threadId              getThreadId();
     void                    setThreadId(__threadId _id);
index 7e6dcbd..8c71671 100644 (file)
@@ -44,13 +44,13 @@ public :
         return true;
     }
 
-    virtual InternalType*           clone();
+    virtual TList*                  clone();
 
     bool                            exists(const std::wstring& _sKey);
     InternalType*                   getField(const std::wstring& _sKey);
     int                             getIndexFromString(const std::wstring& _sKey);
-    bool                            set(const std::wstring& _sKey, InternalType* _pIT);
-    bool                            set(const int _iIndex, InternalType* _pIT);
+    TList*                          set(const std::wstring& _sKey, InternalType* _pIT);
+    TList*                          set(const int _iIndex, InternalType* _pIT);
 
     using List::extract; // to avoid this extract to hide extract in list
     bool                            extract(const std::wstring& name, InternalType *& out);
index 420a8ee..2eacb81 100644 (file)
@@ -122,32 +122,42 @@ public :
         return L"";
     }
 
-    virtual InternalType*       clone(void)
+    virtual GenericType*        clone(void)
     {
         return NULL;
     }
 
-    virtual bool                resize(int* /*_piDims*/, int /*_iDims*/)
+    virtual GenericType*        resize(int* /*_piDims*/, int /*_iDims*/)
     {
-        return false;
+        return NULL;
     }
 
-    virtual bool                resize(int /*_iNewRows*/, int /*_iNewCols*/)
+    virtual GenericType*        resize(int /*_iNewRows*/, int /*_iNewCols*/)
     {
-        return false;
+        return NULL;
     }
 
-    virtual bool                reshape(int* /*_piDims*/, int /*_iDims*/)
+    virtual GenericType*        reshape(int* /*_piDims*/, int /*_iDims*/)
     {
-        return false;
+        return NULL;
     }
 
-    virtual bool                reshape(int /*_iNewRows*/, int /*_iNewCols*/)
+    virtual GenericType*        reshape(int /*_iNewRows*/, int /*_iNewCols*/)
     {
-        return false;
+        return NULL;
+    }
+
+    virtual GenericType*        insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
+    {
+        return NULL;
+    }
+
+    virtual GenericType*        insertNew(typed_list* /*_pArgs*/)
+    {
+        return NULL;
     }
 
-    virtual InternalType*       insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
+    virtual GenericType*        remove(typed_list* /*_pArgs*/)
     {
         return NULL;
     }
index 9ef49ea..da99bf5 100644 (file)
@@ -15,6 +15,7 @@
 
 #include "types.hxx"
 #include "function.hxx"
+#include "double.hxx"
 
 namespace types
 {
@@ -27,6 +28,14 @@ EXTERN_AST void cleanIndexesArguments(typed_list* _pArgsOrig, typed_list* _pArgs
 EXTERN_AST void getIndexesWithDims(int _iIndex, int* _piIndexes, const int* _piDims, int _iDims);
 EXTERN_AST int getIndexWithDims(int* _piIndexes, const int* _piDims, int _iDims);
 EXTERN_AST types::Function::ReturnValue VariableToString(types::InternalType* pIT, const wchar_t* wcsVarName);
+
+//commom function
+EXTERN_AST int computeTuples(int* _piCountDim, int _iDims, int _iCurrentDim, int* _piIndex);
+EXTERN_AST Double* createEmptyDouble();
+EXTERN_AST Double* createDoubleVector(int _iSize);
+EXTERN_AST int getIntValueFromDouble(InternalType* _pIT, int _iPos);
+EXTERN_AST double* getDoubleArrayFromDouble(InternalType* _pIT);
+EXTERN_AST bool checkArgValidity(typed_list& _pArg);
 }
 
 #endif /* !__TYPES_TOOLS_HXX__ */
index c7a786b..9482823 100644 (file)
@@ -53,7 +53,7 @@ public :
 
     virtual std::wstring    getTypeStr() = 0;
     virtual std::wstring    getShortTypeStr() = 0;
-    virtual InternalType*   clone() = 0;
+    virtual UserType*       clone() = 0;
 
 public :
     /*** User can overload these methods                            ***/
@@ -82,7 +82,7 @@ public :
     // insertion by value
     // _pArs is a list of scilab types:: of where we want to extract
     // _pSource is what we wan to insert
-    virtual InternalType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
+    virtual UserType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
     {
         return NULL;
     }
@@ -90,7 +90,7 @@ public :
     // this method is called to perform an extraction by field. ie : a = myUserType.myfield
     // name is the field name
     // out contain extraction of field
-    virtual bool          extract(const std::wstring& /*name*/, InternalType *& /*out*/)
+    virtual bool extract(const std::wstring& /*name*/, InternalType *& /*out*/)
     {
         return false;
     }
index ef425d1..81bc583 100644 (file)
@@ -23,7 +23,7 @@ public :
     Void() {};
     virtual                 ~Void();
 
-    InternalType*           clone();
+    Void*                   clone();
 
     inline ScilabType       getType(void)
     {
index fafbcec..4a0294d 100644 (file)
@@ -222,13 +222,16 @@ template<class T>
 void RunVisitorT<T>::visitprivate(const LogicalOpExp &e)
 {
     CoverageInstance::invokeAndStartChrono((void*)&e);
+    types::InternalType *pITR = NULL; //assign only in non shortcut operations.
+    types::InternalType *pITL = NULL;
+    types::InternalType *pResult = NULL;
+
     try
     {
-        types::InternalType *pITR = NULL; //assign only in non shortcut operations.
 
         /*getting what to assign*/
         e.getLeft().accept(*this);
-        types::InternalType *pITL = getResult();
+        pITL = getResult();
         if (isSingleResult() == false)
         {
             std::wostringstream os;
@@ -249,8 +252,6 @@ void RunVisitorT<T>::visitprivate(const LogicalOpExp &e)
             }
         }
 
-        types::InternalType *pResult = NULL;
-
         switch (e.getOper())
         {
             case LogicalOpExp::logicalShortCutAnd:
@@ -350,7 +351,19 @@ void RunVisitorT<T>::visitprivate(const LogicalOpExp &e)
     }
     catch (ast::InternalError& error)
     {
-        clearResult();
+        setResult(NULL);
+        if (pResult)
+        {
+            pResult->killMe();
+        }
+        if (pITL && (pITL != pResult))
+        {
+            pITL->killMe();
+        }
+        if (pITR && (pITR != pResult))
+        {
+            pITR->killMe();
+        }
         error.SetErrorLocation(e.getLocation());
         CoverageInstance::stopChrono((void*)&e);
         throw error;
index 62653a4..67886ce 100644 (file)
@@ -903,17 +903,15 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                     }
 
                     // resize current struct
-                    pStruct->resize(pEH->getArgsDimsArray(), pEH->getArgsDims());
+                    pStruct = pStruct->resize(pEH->getArgsDimsArray(), pEH->getArgsDims());
+                    pEH->setCurrent(pStruct);
                 }
 
                 // create field in parent if it not exist
                 if (pStruct->exists(pwcsFieldname) == false)
                 {
                     pStruct = pStruct->addField(pwcsFieldname);
-                    if (pEH->setCurrent(pStruct))
-                    {
-                        pEH->setReinsertion();
-                    }
+                    pEH->setCurrent(pStruct);
                 }
 
                 if (pEH->getArgs())
@@ -1011,7 +1009,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                         int iNewSize = pEH->getSizeFromArgs();
                         if (pTL->getSize() < iNewSize)
                         {
-                            pTL->set(iNewSize - 1, new types::ListUndefined());
+                            pTL = pTL->set(iNewSize - 1, new types::ListUndefined());
+                            pEH->setCurrent(pTL);
                         }
 
                         // update pArgs variables with new argument computed in getSizeFromArgs
@@ -1166,7 +1165,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                             int iNewSize = pEH->getSizeFromArgs();
                             if (pL->getSize() < iNewSize)
                             {
-                                pL->set(iNewSize - 1, new types::ListUndefined());
+                                pL = pL->set(iNewSize - 1, new types::ListUndefined());
+                                pEH->setCurrent(pL);
                             }
 
                             types::Double* pDblArgs = (*pEH->getArgs())[0]->getAs<types::Double>();
@@ -1311,11 +1311,11 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
             }
             else if (pITCurrent->isCell())
             {
-                types::Cell* pCell = pITCurrent->getAs<types::Cell>();
                 if (pEH->getArgs() && (*pEH->getArgs())[0]->isString() == false)
                 {
                     if (pEH->isCellExp())
                     {
+                        types::Cell* pCell = pITCurrent->getAs<types::Cell>();
                         // a{x} => extract like a(x){[1 2 ...]}
                         if (pEH->getParent() && pEH->getLevel() == pEH->getParent()->getLevel())
                         {
@@ -1341,6 +1341,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                         }
                         else
                         {
+                            types::GenericType* pCell = pITCurrent->getAs<types::GenericType>();
                             if (pEH->needResize())
                             {
                                 if (pEH->getArgsDims() == 1)
@@ -1351,7 +1352,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                                 }
 
                                 // resize current Cell
-                                pCell->resize(pEH->getArgsDimsArray(), pEH->getArgsDims());
+                                pCell = pCell->resize(pEH->getArgsDimsArray(), pEH->getArgsDims());
+                                pEH->setCurrent(pCell);
                             }
 
                             types::InternalType* pIT = pCell->extract(pEH->getArgs());
@@ -1363,6 +1365,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                     {
                         if ((*iterFields)->isCellExp())
                         {
+                            types::GenericType* pCell = pITCurrent->getAs<types::GenericType>();
+
                             // a(x){y}
                             if (pEH->needResize())
                             {
@@ -1374,7 +1378,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                                 }
 
                                 // resize current Cell
-                                pCell->resize(pEH->getArgsDimsArray(), pEH->getArgsDims());
+                                pCell = pCell->resize(pEH->getArgsDimsArray(), pEH->getArgsDims())->getAs<types::Cell>();
+                                pEH->setCurrent(pCell);
                             }
 
                             types::InternalType* pIT = pCell->extract(pEH->getArgs());
@@ -1575,10 +1580,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                     throw ast::InternalError(os.str(), 999, _pExp->getLocation());
                 }
 
-                if (pEH->setCurrent(pIT))
-                {
-                    pEH->setReinsertion();
-                }
+                pEH->setCurrent(pIT);
             }
         }
 
@@ -1621,21 +1623,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                         types::TList* pTL = pParent->getAs<types::TList>();
                         if (pParentArgs)
                         {
-                            // In case where pTL is in several scilab variable,
-                            // we have to clone it for keep the other variables unchanged.
-                            if (pTL->getRef() > 1)
-                            {
-                                pTL = pTL->clone()->getAs<types::TList>();
-                            }
-
-                            pTL->set(pEH->getWhereReinsert(), pEH->getCurrent());
-
-                            if (pEH->getParent()->setCurrent(pTL))
-                            {
-                                pEH->getParent()->setReinsertion();
-                                pEH->resetReinsertion();
-                            }
-
+                            pTL = pTL->set(pEH->getWhereReinsert(), pEH->getCurrent());
+                            pEHParent->setCurrent(pTL);
                             evalFields.pop_back();
                             delete pEH;
                             continue;
@@ -1644,21 +1633,8 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                         {
                             if (pTL->exists(pEH->getExpAsString()))
                             {
-                                // In case where pTL is in several scilab variable,
-                                // we have to clone it for keep the other variables unchanged.
-                                if (pTL->getRef() > 1)
-                                {
-                                    pTL = pTL->clone()->getAs<types::TList>();
-                                }
-
-                                pTL->set(pEH->getExpAsString(), pEH->getCurrent());
-
-                                if (pEH->getParent()->setCurrent(pTL))
-                                {
-                                    pEH->getParent()->setReinsertion();
-                                    pEH->resetReinsertion();
-                                }
-
+                                pTL = pTL->set(pEH->getExpAsString(), pEH->getCurrent());
+                                pEHParent->setCurrent(pTL);
                                 evalFields.pop_back();
                                 delete pEH;
                                 continue;
@@ -1691,11 +1667,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                     throw ast::InternalError(os.str(), 999, _pExp->getLocation());
                 }
 
-                if (pEHParent->setCurrent(pIT))
-                {
-                    pEHParent->setReinsertion();
-                }
-
+                pEHParent->setCurrent(pIT);
                 if (pEHParent->getArgs() == NULL)
                 {
                     delete pParentArgs;
@@ -1788,125 +1760,46 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
     else if (_pInsert->isDouble() && _pInsert->getAs<types::Double>()->isEmpty() && _pVar->isStruct() == false && _pVar->isList() == false)
     {
         //insert [] so deletion except for Struct and List which can insert []
-        types::InternalType::ScilabType varType = _pVar->getType();
-        switch (varType)
+        if (_pVar->isHandle())
         {
-            case types::InternalType::ScilabDouble :
-            {
-                pOut = _pVar->getAs<types::Double>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabString :
-            {
-                pOut = _pVar->getAs<types::String>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabCell :
-            {
-                pOut = _pVar->getAs<types::Cell>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabBool :
-            {
-                pOut = _pVar->getAs<types::Bool>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabPolynom :
-            {
-                pOut = _pVar->getAs<types::Polynom>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabInt8 :
-            {
-                pOut = _pVar->getAs<types::Int8>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabUInt8 :
-            {
-                pOut = _pVar->getAs<types::UInt8>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabInt16 :
-            {
-                pOut = _pVar->getAs<types::Int16>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabUInt16 :
-            {
-                pOut = _pVar->getAs<types::UInt16>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabInt32 :
-            {
-                pOut = _pVar->getAs<types::Int32>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabUInt32 :
-            {
-                pOut = _pVar->getAs<types::UInt32>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabInt64 :
-            {
-                pOut = _pVar->getAs<types::Int64>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabUInt64 :
-            {
-                pOut = _pVar->getAs<types::UInt64>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabSparse :
-            {
-                pOut = _pVar->getAs<types::Sparse>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabSparseBool :
-            {
-                pOut = _pVar->getAs<types::SparseBool>()->remove(_pArgs);
-                break;
-            }
-            case types::InternalType::ScilabStruct :
-            {
-                pOut = _pVar->getAs<types::Struct>()->insert(_pArgs, _pInsert);
-                break;
-            }
-            case types::InternalType::ScilabHandle :
+            types::GraphicHandle* pH = _pVar->getAs<types::GraphicHandle>();
+            if ((*_pArgs)[0]->isString())
             {
-                types::GraphicHandle* pH = _pVar->getAs<types::GraphicHandle>();
-                if ((*_pArgs)[0]->isString())
-                {
-                    types::String *pS = (*_pArgs)[0]->getAs<types::String>();
+                types::String *pS = (*_pArgs)[0]->getAs<types::String>();
 
-                    types::typed_list in;
-                    types::typed_list out;
-                    types::optional_list opt;
+                types::typed_list in;
+                types::typed_list out;
+                types::optional_list opt;
 
-                    in.push_back(pH);
-                    in.push_back(pS);
-                    in.push_back(_pInsert);
+                in.push_back(pH);
+                in.push_back(pS);
+                in.push_back(_pInsert);
 
-                    types::Function* pCall = (types::Function*)symbol::Context::getInstance()->get(symbol::Symbol(L"set"));
-                    types::Callable::ReturnValue ret = pCall->call(in, opt, 1, out);
-                    if (ret == types::Callable::OK)
-                    {
-                        pOut = _pVar;
-                    }
-                }
-                else
+                types::Function* pCall = (types::Function*)symbol::Context::getInstance()->get(symbol::Symbol(L"set"));
+                types::Callable::ReturnValue ret = pCall->call(in, opt, 1, out);
+                if (ret == types::Callable::OK)
                 {
-                    pOut = pH->insert(_pArgs, _pInsert);
+                    pOut = _pVar;
                 }
-
-                break;
             }
-            default :
+            else
             {
-                //overload !
-                pOut = callOverload(e, L"i", _pArgs, _pInsert, _pVar);
-                break;
+                pOut = pH->insert(_pArgs, _pInsert);
             }
         }
+        else if (_pVar->isStruct())
+        {
+            pOut = _pVar->getAs<types::Struct>()->insert(_pArgs, _pInsert);
+        }
+        else if (_pVar->isGenericType())
+        {
+            pOut = _pVar->getAs<types::GenericType>()->remove(_pArgs);
+        }
+        else
+        {
+            //overload !
+            pOut = callOverload(e, L"i", _pArgs, _pInsert, _pVar);
+        }
     }
     else if (_pVar == NULL || (_pVar->isDouble() && _pVar->getAs<types::Double>()->getSize() == 0))
     {
@@ -1936,64 +1829,16 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
         }
         else
         {
-            switch (_pInsert->getType())
+            if (_pInsert->isGenericType())
             {
-                case types::InternalType::ScilabDouble :
-                    pOut = types::Double::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabString :
-                    pOut = types::String::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabCell :
-                    pOut = types::Cell::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabBool :
-                    pOut = types::Bool::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabPolynom :
-                    pOut = types::Polynom::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabInt8 :
-                    pOut = types::Int8::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabUInt8 :
-                    pOut = types::UInt8::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabInt16 :
-                    pOut = types::Int16::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabUInt16 :
-                    pOut = types::UInt16::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabInt32 :
-                    pOut = types::Int32::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabUInt32 :
-                    pOut = types::UInt32::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabInt64 :
-                    pOut = types::Int64::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabUInt64 :
-                    pOut = types::UInt64::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabSparse :
-                    pOut = types::Sparse::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabSparseBool :
-                    pOut = types::SparseBool::insertNew(_pArgs, _pInsert);
-                    break;
-                case types::InternalType::ScilabHandle:
-                    pOut = types::GraphicHandle::insertNew(_pArgs, _pInsert);
-                    break;
-                default :
-                {
-                    // overload
-                    types::Double* pEmpty = types::Double::Empty();
-                    pOut = callOverload(e, L"i", _pArgs, _pInsert, pEmpty);
-                    pEmpty->killMe();
-                    break;
-                }
+                pOut = _pInsert->getAs<types::GenericType>()->insertNew(_pArgs);
+            }
+            else
+            {
+                // overload
+                types::Double* pEmpty = types::Double::Empty();
+                pOut = callOverload(e, L"i", _pArgs, _pInsert, pEmpty);
+                pEmpty->killMe();
             }
         }
     }
@@ -2011,45 +1856,21 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
         }
 
         //check types compatibilties
-        if (_pVar->isDouble() && _pInsert->isDouble())
-        {
-            pRet = _pVar->getAs<types::Double>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isDouble() && _pInsert->isSparse())
+        if (_pVar->isDouble() && _pInsert->isSparse())
         {
             types::Sparse* pSp = _pInsert->getAs<types::Sparse>();
             types::Double* pD = new types::Double(pSp->getRows(), pSp->getCols(), pSp->isComplex());
             pSp->fill(*pD);
-            pRet = _pVar->getAs<types::Double>()->insert(_pArgs, pD);
+            pRet = _pVar->getAs<types::GenericType>()->insert(_pArgs, pD);
             delete pD;
         }
-        else if (_pVar->isString() && _pInsert->isString())
-        {
-            pRet = _pVar->getAs<types::String>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isCell() && _pInsert->isCell())
-        {
-            pRet = _pVar->getAs<types::Cell>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isBool() && _pInsert->isBool())
-        {
-            pRet = _pVar->getAs<types::Bool>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isSparse() && _pInsert->isSparse())
-        {
-            pRet = _pVar->getAs<types::Sparse>()->insert(_pArgs, _pInsert->getAs<types::Sparse>());
-        }
         else if (_pVar->isSparse() && _pInsert->isDouble())
         {
-            pRet = _pVar->getAs<types::Sparse>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isSparseBool() && _pInsert->isSparseBool())
-        {
-            pRet = _pVar->getAs<types::SparseBool>()->insert(_pArgs, _pInsert->getAs<types::SparseBool>());
+            pRet = _pVar->getAs<types::GenericType>()->insert(_pArgs, _pInsert);
         }
         else if (_pVar->isSparseBool() && _pInsert->isBool())
         {
-            pRet = _pVar->getAs<types::SparseBool>()->insert(_pArgs, _pInsert);
+            pRet = _pVar->getAs<types::GenericType>()->insert(_pArgs, _pInsert);
         }
         else if (_pVar->isDouble() && _pInsert->isPoly())
         {
@@ -2122,42 +1943,6 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
             pRet = pDest->insert(_pArgs, pP);
             pP->killMe();
         }
-        else if (_pVar->isPoly() && _pInsert->isPoly())
-        {
-            pRet = _pVar->getAs<types::Polynom>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isInt8() && _pInsert->isInt8())
-        {
-            pRet = _pVar->getAs<types::Int8>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isUInt8() && _pInsert->isUInt8())
-        {
-            pRet = _pVar->getAs<types::UInt8>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isInt16() && _pInsert->isInt16())
-        {
-            pRet = _pVar->getAs<types::Int16>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isUInt16() && _pInsert->isUInt16())
-        {
-            pRet = _pVar->getAs<types::UInt16>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isInt32() && _pInsert->isInt32())
-        {
-            pRet = _pVar->getAs<types::Int32>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isUInt32() && _pInsert->isUInt32())
-        {
-            pRet = _pVar->getAs<types::UInt32>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isInt64() && _pInsert->isInt64())
-        {
-            pRet = _pVar->getAs<types::Int64>()->insert(_pArgs, _pInsert);
-        }
-        else if (_pVar->isUInt64() && _pInsert->isUInt64())
-        {
-            pRet = _pVar->getAs<types::UInt64>()->insert(_pArgs, _pInsert);
-        }
         else if (_pVar->isStruct())
         {
             types::Struct* pStruct = _pVar->getAs<types::Struct>();
@@ -2293,8 +2078,7 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
 
                     if (pTL->exists(pS->get(0)))
                     {
-                        pTL->set(pS->get(0), _pInsert);
-                        pRet = pTL;
+                        pRet = pTL->set(pS->get(0), _pInsert);
                     }
                     else
                     {
@@ -2452,6 +2236,10 @@ types::InternalType* insertionCall(const ast::Exp& e, types::typed_list* _pArgs,
                 pRet = callOverload(e, L"i", _pArgs, _pInsert, _pVar);
             }
         }
+        else if (_pVar->getType() == _pInsert->getType())
+        {
+            pRet = _pVar->getAs<types::GenericType>()->insert(_pArgs, _pInsert);
+        }
         else if (_pVar->isCell())
         {
             if (_pInsert->isCell() == false)
index 39a3ad5..f4c000a 100644 (file)
@@ -17,6 +17,7 @@
 #include "singlestruct.hxx"
 #include "type_traits.hxx"
 #include "exp.hxx"
+#include "types_tools.hxx"
 
 extern "C"
 {
@@ -25,100 +26,25 @@ extern "C"
 
 namespace types
 {
-//n-uplet in french
-int computeTuples(int* _piCountDim, int _iDims, int _iCurrentDim, int* _piIndex)
-{
-    //if bRet == 1, previous dims has reach max value.
-    int iRet = 0;
-
-    if (_iCurrentDim == 0)
-    {
-        //last dims
-        if (_piIndex[_iCurrentDim] >= _piCountDim[_iCurrentDim])
-        {
-            _piIndex[_iCurrentDim] = 0;
-            return 1;
-        }
-    }
-    else
-    {
-        iRet = computeTuples(_piCountDim, _iDims, _iCurrentDim - 1, _piIndex);
-        if (iRet)
-        {
-            _piIndex[_iCurrentDim]++;
-            if (_piIndex[_iCurrentDim] >= _piCountDim[_iCurrentDim])
-            {
-                _piIndex[_iCurrentDim] = 0;
-                return 1;
-            }
-        }
-    }
-    return 0;
-}
-
-InternalType* createEmptyDouble()
-{
-    return Double::Empty();
-}
-
-int getIntValueFromDouble(InternalType* _pIT, int _iPos)
-{
-    return static_cast<int>(_pIT->getAs<Double>()->get(_iPos));
-}
-
-double* getDoubleArrayFromDouble(InternalType* _pIT)
-{
-    return _pIT->getAs<Double>()->get();
-}
 
-InternalType* createDoubleVector(int _iSize)
+template <typename T>
+GenericType* ArrayOf<T>::createEmpty()
 {
-    int piDims[] = {1, _iSize};
-    Double* pOut = new Double(2, piDims);
-    for (int i = 0; i < _iSize; i++)
-    {
-        pOut->set(i, i + 1);
-    }
-    return pOut;
+    return createEmptyDouble();
 }
 
-bool checkArgValidity(typed_list& _Arg)
+template <typename T>
+void ArrayOf<T>::getIndexes(int _iIndex, int* _piIndexes)
 {
-    for (int i = 0; i < (int)_Arg.size(); i++)
-    {
-        if (_Arg[i]->isDouble() == false)
-        {
-            return false;
-        }
-
-        Double* pDbl = _Arg[i]->getAs<Double>();
-        double* pdbl = pDbl->get();
-        for (int j = 0; j < pDbl->getSize(); j++)
-        {
-            if (pdbl[j] <= 0)
-            {
-                return false;
-            }
-        }
-    }
-
-    return true;
+    getIndexesWithDims(_iIndex, _piIndexes, m_piDims, m_iDims);
 }
 
 template <typename T>
-InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
+ArrayOf<T>* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
 {
-    if (getRef() > 1)
+    ArrayOf<T>* pIT = checkRef(this, &ArrayOf::insert, _pArgs, _pSource);
+    if (pIT != this)
     {
-        // An ArrayOf content in more than one Scilab variable
-        // must be cloned before to be modified.
-        ArrayOf* pClone = clone()->template getAs<ArrayOf>();
-        InternalType* pIT = pClone->insert(_pArgs, _pSource);
-        if (pIT == NULL)
-        {
-            pClone->killMe();
-        }
-
         return pIT;
     }
 
@@ -138,7 +64,7 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
 
         if (isComplex() == false && pIns->isComplex() == false)
         {
-            if (set(index, *pRealData) == true)
+            if (set(index, *pRealData) != NULL)
             {
                 return this;
             }
@@ -175,7 +101,7 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
             {
                 for (int & i : indexes)
                 {
-                    if (set(i, *pRealData) == false)
+                    if (set(i, *pRealData) == NULL)
                     {
                         status = false;
                         break;
@@ -186,7 +112,7 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
             {
                 for (int & i : indexes)
                 {
-                    if (set(i, *pRealData) == false)
+                    if (set(i, *pRealData) == NULL)
                     {
                         status = false;
                         break;
@@ -362,11 +288,10 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
     }
 
     //before resize, check input dimension
-
     if (bNeedToResize)
     {
-        bool bPass = resize(piNewDims, iNewDims);
-        if (bPass == false)
+        ArrayOf<T>* pTemp = resize(piNewDims, iNewDims);
+        if (pTemp == NULL)
         {
             delete[] piCountDim;
             delete[] piMaxDim;
@@ -507,16 +432,15 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
 }
 
 template <typename T>
-InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
+GenericType* ArrayOf<T>::insertNew(typed_list* _pArgs)
 {
     typed_list pArg;
     InternalType *pOut = NULL;
-    ArrayOf* pSource = _pSource->getAs<ArrayOf>();
 
     int iDims = (int)_pArgs->size();
     int* piMaxDim = new int[iDims];
     int* piCountDim = new int[iDims];
-    bool bComplex = pSource->getImg() != NULL;
+    bool bComplex = getImg() != NULL;
     bool bUndefine = false;
     bool bIsImpli = false;
 
@@ -541,8 +465,8 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
     if (bUndefine)
     {
         //manage : and $ in creation by insertion
-        int *piSourceDims = pSource->getDimsArray();
-        int iSourceDims = pSource->getDims();
+        int *piSourceDims = getDimsArray();
+        int iSourceDims = getDims();
         int iCompteurNull = 0;
         int iLastNull = 0;
         for (int i = 0; i < iDims; i++)
@@ -568,19 +492,19 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
             delete[] piCountDim;
             //free pArg content
             cleanIndexesArguments(_pArgs, &pArg);
-            return _pSource;
+            return this;
         }
 
         //vector case
-        if (pSource->isVector() && iCompteurNull == 1)
+        if (isVector() && iCompteurNull == 1)
         {
-            piMaxDim[iLastNull] = pSource->getSize();
+            piMaxDim[iLastNull] = getSize();
             pArg[iLastNull] = createDoubleVector(piMaxDim[iLastNull]);
         }
         else
         {
             //matrix and hypermatrix case
-            if (iCompteurNull < pSource->getDims())
+            if (iCompteurNull < getDims())
             {
                 delete[] piMaxDim;
                 delete[] piCountDim;
@@ -604,7 +528,7 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
                     }
                     else
                     {
-                        //fill dimensions after pSource->getDimes() with 1
+                        //fill dimensions after getDimes() with 1
                         piMaxDim[i] = 1;
                         pArg[i] = createDoubleVector(piMaxDim[i]);
                     }
@@ -641,21 +565,21 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
 
     if (iDims == 1)
     {
-        if (pSource->getCols() == 1)
+        if (getCols() == 1)
         {
             int piRealDim[2] = {piMaxDim[0], 1};
-            pOut = pSource->createEmpty(2, piRealDim, bComplex);
+            pOut = createEmpty(2, piRealDim, bComplex);
         }
         else
         {
             //rows == 1
             int piRealDim[2] = {1, piMaxDim[0]};
-            pOut = pSource->createEmpty(2, piRealDim, bComplex);
+            pOut = createEmpty(2, piRealDim, bComplex);
         }
     }
     else
     {
-        pOut = pSource->createEmpty(iDims, piMaxDim, bComplex);
+        pOut = createEmpty(iDims, piMaxDim, bComplex);
     }
 
     //fill with null item
@@ -667,9 +591,9 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
         for (int i = 0; i < pArrayOut->getSize(); i++)
         {
             pArrayOut->deleteData(pRealData[i]);
-            pRealData[i] = pSource->getNullValue();
+            pRealData[i] = getNullValue();
             pArrayOut->deleteData(pImgData[i]);
-            pImgData[i] = pSource->getNullValue();
+            pImgData[i] = getNullValue();
         }
     }
     else
@@ -677,11 +601,11 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
         for (int i = 0; i < pArrayOut->getSize(); i++)
         {
             pArrayOut->deleteData(pRealData[i]);
-            pRealData[i] = pSource->getNullValue();
+            pRealData[i] = getNullValue();
         }
     }
 
-    if (bIsImpli && (pArrayOut->getSize() != _pSource->getAs<types::GenericType>()->getSize()))
+    if (bIsImpli && (pArrayOut->getSize() != getSize()))
     {
         delete[] piMaxDim;
         delete[] piCountDim;
@@ -690,7 +614,7 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
         return NULL;
     }
     //insert values in new matrix
-    InternalType* pOut2 = pArrayOut->insert(&pArg, _pSource);
+    ArrayOf* pOut2 = pArrayOut->insert(&pArg, this);
     if (pOut != pOut2)
     {
         delete pOut;
@@ -705,8 +629,14 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
 }
 
 template <typename T>
-bool ArrayOf<T>::append(int _iRows, int _iCols, InternalType* _poSource)
+ArrayOf<T>* ArrayOf<T>::append(int _iRows, int _iCols, InternalType* _poSource)
 {
+    ArrayOf<T>* pIT = checkRef(this, &ArrayOf::append, _iRows, _iCols, _poSource);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     ArrayOf * pGT = _poSource->getAs<ArrayOf>();
     int iRows = pGT->getRows();
     int iCols = pGT->getCols();
@@ -714,7 +644,7 @@ bool ArrayOf<T>::append(int _iRows, int _iCols, InternalType* _poSource)
     //insert without resize
     if (iRows + _iRows > m_iRows || iCols + _iCols > m_iCols)
     {
-        return false;
+        return NULL;
     }
 
     //Update complexity if necessary
@@ -749,11 +679,11 @@ bool ArrayOf<T>::append(int _iRows, int _iCols, InternalType* _poSource)
         }
     }
 
-    return true;
+    return this;
 }
 
 template <typename T>
-InternalType* ArrayOf<T>::remove(typed_list* _pArgs)
+GenericType* ArrayOf<T>::remove(typed_list* _pArgs)
 {
     ArrayOf<T>* pOut = NULL;
     int iDims = (int)_pArgs->size();
@@ -1008,7 +938,7 @@ InternalType* ArrayOf<T>::remove(typed_list* _pArgs)
 }
 
 template <typename T>
-InternalType* ArrayOf<T>::extract(typed_list* _pArgs)
+GenericType* ArrayOf<T>::extract(typed_list* _pArgs)
 {
     ArrayOf<T>* pOut = NULL;
     int iDims = (int)_pArgs->size();
@@ -1370,8 +1300,63 @@ InternalType* ArrayOf<T>::extract(typed_list* _pArgs)
 }
 
 template <typename T>
-bool ArrayOf<T>::resize(int* _piDims, int _iDims)
+ArrayOf<T>* ArrayOf<T>::reshape(int* _piDims, int _iDims)
 {
+    typedef ArrayOf<T>* (ArrayOf<T>::*reshape_t)(int*, int);
+    ArrayOf<T>* pIT = checkRef(this, (reshape_t)&ArrayOf<T>::reshape, _piDims, _iDims);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    int iNewSize = get_max_size(_piDims, _iDims);
+    if (iNewSize != m_iSize)
+    {
+        return NULL;
+    }
+
+    for (int i = 0 ; i < _iDims ; i++)
+    {
+        m_piDims[i] = _piDims[i];
+    }
+
+    if (_iDims == 1)
+    {
+        m_piDims[1] = 1;
+        _iDims++;
+    }
+
+    int iDims = _iDims;
+    for (int i = iDims - 1; i >= 2; --i)
+    {
+        if (m_piDims[i] == 1)
+        {
+            _iDims--;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    m_iRows = m_piDims[0];
+    m_iCols = m_piDims[1];
+    m_iSize = iNewSize;
+    m_iDims = _iDims;
+
+    return this;
+}
+
+template <typename T>
+ArrayOf<T>* ArrayOf<T>::resize(int* _piDims, int _iDims)
+{
+    typedef ArrayOf<T>* (ArrayOf<T>::*resize_t)(int*, int);
+    ArrayOf<T>* pIT = checkRef(this, (resize_t)&ArrayOf::resize, _piDims, _iDims);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iDims == m_iDims)
     {
         bool bChange = false;
@@ -1387,7 +1372,7 @@ bool ArrayOf<T>::resize(int* _piDims, int _iDims)
         if (bChange == false)
         {
             //nothing to do
-            return true;
+            return this;
         }
     }
 
@@ -1642,7 +1627,7 @@ bool ArrayOf<T>::resize(int* _piDims, int _iDims)
     m_iRows = m_piDims[0];
     m_iCols = m_piDims[1];
     m_iSize = iNewSize;
-    return true;
+    return this;
 }
 
 template <typename T>
index 6983bb8..7bb5b90 100644 (file)
@@ -76,7 +76,7 @@ Bool::Bool(int _iDims, const int* _piDims)
 #endif
 }
 
-InternalType* Bool::clone()
+Bool* Bool::clone()
 {
     Bool *pbClone =  new Bool(getDims(), getDimsArray());
     pbClone->set(get());
index c1a90e7..65d2439 100644 (file)
@@ -130,81 +130,115 @@ bool Cell::transpose(InternalType *& out)
     return false;
 }
 
-bool Cell::set(int _iRows, int _iCols, InternalType* _pIT)
+Cell* Cell::set(int _iRows, int _iCols, InternalType* _pIT)
 {
     if (_iRows < getRows() && _iCols < getCols())
     {
         return set(_iCols * getRows() + _iRows, _pIT);
     }
-    return false;
+    return NULL;
 }
 
-bool Cell::set(int _iRows, int _iCols, const InternalType* _pIT)
+Cell* Cell::set(int _iRows, int _iCols, const InternalType* _pIT)
 {
     if (_iRows < getRows() && _iCols < getCols())
     {
         return set(_iCols * getRows() + _iRows, _pIT);
     }
-    return false;
+    return NULL;
 }
 
-bool Cell::set(int _iIndex, InternalType* _pIT)
+Cell* Cell::set(int _iIndex, InternalType* _pIT)
 {
-    if (_iIndex < getSize())
+    if (_iIndex >= m_iSize)
     {
-        // corner case when inserting twice
-        if (m_pRealData[_iIndex] == _pIT)
-        {
-            return true;
-        }
+        return NULL;
+    }
 
-        if (m_pRealData[_iIndex] != NULL)
-        {
-            m_pRealData[_iIndex]->DecreaseRef();
-            m_pRealData[_iIndex]->killMe();
-        }
+    // corner case when inserting twice
+    if (m_pRealData[_iIndex] == _pIT)
+    {
+        return this;
+    }
 
-        _pIT->IncreaseRef();
-        m_pRealData[_iIndex] = _pIT;
-        return true;
+    typedef Cell* (Cell::*set_t)(int, InternalType*);
+    Cell* pIT = checkRef(this, (set_t)&Cell::set, _iIndex, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
     }
-    return false;
+
+    if (m_pRealData[_iIndex] != NULL)
+    {
+        m_pRealData[_iIndex]->DecreaseRef();
+        m_pRealData[_iIndex]->killMe();
+    }
+
+    _pIT->IncreaseRef();
+    m_pRealData[_iIndex] = _pIT;
+    return this;
 }
 
-bool Cell::set(int _iIndex, const InternalType* _pIT)
+Cell* Cell::set(int _iIndex, const InternalType* _pIT)
 {
-    if (_iIndex < getSize())
+    if (_iIndex >= m_iSize)
     {
-        if (m_pRealData[_iIndex] != NULL)
-        {
-            m_pRealData[_iIndex]->DecreaseRef();
-            m_pRealData[_iIndex]->killMe();
-        }
+        return NULL;
+    }
 
-        const_cast<InternalType*>(_pIT)->IncreaseRef();
-        m_pRealData[_iIndex] = const_cast<InternalType*>(_pIT);
-        return true;
+    typedef Cell* (Cell::*set_t)(int, const InternalType*);
+    Cell* pIT = checkRef(this, (set_t)&Cell::set, _iIndex, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
     }
-    return false;
+
+    if (m_pRealData[_iIndex] != NULL)
+    {
+        m_pRealData[_iIndex]->DecreaseRef();
+        m_pRealData[_iIndex]->killMe();
+    }
+
+    const_cast<InternalType*>(_pIT)->IncreaseRef();
+    m_pRealData[_iIndex] = const_cast<InternalType*>(_pIT);
+
+    return this;
 }
 
-bool Cell::set(InternalType** _pIT)
+Cell* Cell::set(InternalType** _pIT)
 {
-    for (int i = 0 ; i < getSize() ; i++)
+    typedef Cell* (Cell::*set_t)(InternalType**);
+    Cell* pIT = checkRef(this, (set_t)&Cell::set, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    for (int i = 0; i < m_iSize; i++)
     {
-        if (set(i, _pIT[i]) == false)
+        if (i >= m_iSize)
         {
-            return false;
+            return NULL;
+        }
+
+        if (m_pRealData[i] != NULL)
+        {
+            m_pRealData[i]->DecreaseRef();
+            m_pRealData[i]->killMe();
         }
+
+        _pIT[i]->IncreaseRef();
+        m_pRealData[i] = _pIT[i];
     }
-    return true;
+
+    return this;
 }
 
 /**
 ** Clone
 ** Create a new Struct and Copy all values.
 */
-InternalType* Cell::clone()
+Cell* Cell::clone()
 {
     return new Cell(this);
 }
@@ -374,11 +408,6 @@ bool Cell::subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDi
     return true;
 }
 
-//bool Cell::append(int _iRows, int _iCols, Cell *_poSource)
-//{
-//    return true;
-//}
-
 bool Cell::operator==(const InternalType& it)
 {
     if (const_cast<InternalType &>(it).isCell() == false)
@@ -443,7 +472,7 @@ Cell* Cell::insertNewCell(typed_list* _pArgs, InternalType* _pSource)
 {
     Cell* pCell = new Cell(1, 1);
     pCell->set(0, _pSource);
-    Cell* pOut = Cell::insertNew(_pArgs, pCell)->getAs<Cell>();
+    Cell* pOut = pCell->insertNew(_pArgs)->getAs<Cell>();
     return pOut;
 }
 
index 1f69451..76b4477 100644 (file)
@@ -17,6 +17,7 @@
 #include "tostring_common.hxx"
 #include "configvariable.hxx"
 #include "type_traits.hxx"
+#include "types_tools.hxx"
 
 extern "C"
 {
@@ -805,7 +806,7 @@ bool Double::subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_i
     return true;
 }
 
-InternalType* Double::clone()
+Double* Double::clone()
 {
     int iOne = 1;
     Double *pReturn = new Double(m_iDims, m_piDims, isComplex());
@@ -980,8 +981,14 @@ double* Double::allocData(int _iSize)
     }
 }
 
-bool Double::append(int _iRows, int _iCols, InternalType* _poSource)
+Double* Double::append(int _iRows, int _iCols, InternalType* _poSource)
 {
+    Double* pIT = checkRef(this, &Double::append, _iRows, _iCols, _poSource);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     Double* pD = _poSource->getAs<Double>();
     int iRows = pD->getRows();
     int iCols = pD->getCols();
@@ -990,7 +997,7 @@ bool Double::append(int _iRows, int _iCols, InternalType* _poSource)
     //insert without resize
     if (iRows + _iRows > m_iRows || iCols + _iCols > m_iCols)
     {
-        return false;
+        return NULL;
     }
 
     //Update complexity if necessary
@@ -1117,7 +1124,7 @@ bool Double::append(int _iRows, int _iCols, InternalType* _poSource)
             }
         }
     }
-    return true;
+    return this;
 }
 
 void Double::convertToInteger()
index d14f5c4..b828abb 100644 (file)
@@ -140,7 +140,7 @@ bool Function::toString(std::wostringstream& ostr)
     return true;
 }
 
-InternalType* Function::clone()
+Function* Function::clone()
 {
     IncreaseRef();
     return this;
@@ -168,7 +168,7 @@ OptFunction::OptFunction(OptFunction* _pWrapFunction)
     m_pLoadDeps = _pWrapFunction->getDeps();
 }
 
-InternalType* OptFunction::clone()
+OptFunction* OptFunction::clone()
 {
     return new OptFunction(this);
 }
@@ -211,7 +211,7 @@ WrapFunction::WrapFunction(WrapFunction* _pWrapFunction)
     m_pLoadDeps = _pWrapFunction->getDeps();
 }
 
-InternalType* WrapFunction::clone()
+WrapFunction* WrapFunction::clone()
 {
     return new WrapFunction(this);
 }
@@ -373,7 +373,7 @@ WrapMexFunction::WrapMexFunction(WrapMexFunction* _pWrapFunction)
     m_pLoadDeps = _pWrapFunction->getDeps();
 }
 
-InternalType* WrapMexFunction::clone()
+WrapMexFunction* WrapMexFunction::clone()
 {
     return new WrapMexFunction(this);
 }
@@ -457,7 +457,7 @@ WrapCFunction::WrapCFunction(WrapCFunction* _pWrapFunction)
     m_pLoadDeps = _pWrapFunction->getDeps();
 }
 
-InternalType* WrapCFunction::clone()
+WrapCFunction* WrapCFunction::clone()
 {
     return new WrapCFunction(this);
 }
index e8e1156..569db62 100644 (file)
@@ -75,7 +75,7 @@ GraphicHandle::~GraphicHandle()
 #endif
 }
 
-InternalType* GraphicHandle::clone()
+GraphicHandle* GraphicHandle::clone()
 {
     GraphicHandle* pGH = new GraphicHandle(getDims(), getDimsArray());
     for (int i = 0 ; i < getSize() ; i++)
index b9f0bee..0d864d0 100644 (file)
@@ -18,6 +18,7 @@
 #include "configvariable.hxx"
 #include "scilabWrite.hxx"
 #include "type_traits.hxx"
+#include "types_tools.hxx"
 #include "numericconstants.hxx"
 #include "doubleexp.hxx"
 
@@ -106,7 +107,7 @@ ImplicitList::ImplicitList(InternalType* _poStart, InternalType* _poStep, Intern
 #endif
 }
 
-InternalType* ImplicitList::clone()
+ImplicitList* ImplicitList::clone()
 {
     return new ImplicitList(m_poStart, m_poStep, m_poEnd);
 }
index c3012a0..30e99ba 100644 (file)
@@ -78,7 +78,7 @@ bool Library::toString(std::wostringstream& ostr)
     return true;
 }
 
-InternalType* Library::clone()
+Library* Library::clone()
 {
     IncreaseRef();
     return this;
index 7fb388c..56b340c 100644 (file)
@@ -96,17 +96,16 @@ int List::getSize()
 ** append(InternalType *_typedValue)
 ** Append the given value to the end of the List
 */
-void List::append(InternalType *_typedValue)
+List* List::append(InternalType *_typedValue)
 {
-    if (_typedValue->isList())
+    List* pIT = checkRef(this, &List::append, _typedValue);
+    if (pIT != this)
     {
-        m_plData->push_back(_typedValue->clone());
+        return pIT;
     }
-    else
-    {
-        m_plData->push_back(_typedValue);
-    }
-    m_plData->back()->IncreaseRef();
+
+    _typedValue->IncreaseRef();
+    m_plData->push_back(_typedValue);
     m_iSize = static_cast<int>(m_plData->size());
 }
 
@@ -114,7 +113,7 @@ void List::append(InternalType *_typedValue)
 ** Clone
 ** Create a new List and Copy all values.
 */
-InternalType *List::clone()
+List *List::clone()
 {
     return new List(this);
 }
@@ -194,7 +193,7 @@ InternalType* List::extract(typed_list* _pArgs)
     return outList;
 }
 
-InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
+List* List::insert(typed_list* _pArgs, InternalType* _pSource)
 {
     //check input param
     if (_pArgs->size() != 1)
@@ -202,6 +201,12 @@ InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
         return NULL;
     }
 
+    List* pIT = checkRef(this, &List::insert, _pArgs, _pSource);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     typed_list pArg;
     int iDims           = (int)_pArgs->size();
 
@@ -267,7 +272,7 @@ InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
             throw ast::InternalError(os.str());
         }
 
-        InternalType* pInsert = _pSource->getAs<ListInsert>()->getInsert()->clone();
+        InternalType* pInsert = _pSource->getAs<ListInsert>()->getInsert();
         pInsert->IncreaseRef();
         if (idx > (int)m_plData->size())
         {
@@ -286,11 +291,9 @@ InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
     }
     else if (idx == 0)
     {
-        //special cazse to insert at the first position
-        InternalType* pInsert = NULL;
-        pInsert = _pSource->clone();
-        pInsert->IncreaseRef();
-        m_plData->insert(m_plData->begin(), pInsert);
+        //special case to insert at the first position
+        _pSource->IncreaseRef();
+        m_plData->insert(m_plData->begin(), _pSource);
     }
     else
     {
@@ -303,11 +306,12 @@ InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
         }
 
         InternalType* pIT = (*m_plData)[idx - 1];
-        pIT->DecreaseRef();
-        pIT->killMe();
 
-        (*m_plData)[idx - 1] = _pSource->clone();
+        (*m_plData)[idx - 1] = _pSource;
         (*m_plData)[idx - 1]->IncreaseRef();
+
+        pIT->DecreaseRef();
+        pIT->killMe();
     }
 
     m_iSize = (int)m_plData->size();
@@ -327,11 +331,17 @@ InternalType* List::get(const int _iIndex)
     return NULL;
 }
 
-bool List::set(const int _iIndex, InternalType* _pIT)
+List* List::set(const int _iIndex, InternalType* _pIT)
 {
     if (_iIndex < 0)
     {
-        return false;
+        return NULL;
+    }
+
+    List* pIT = checkRef(this, &List::set, _iIndex, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
     }
 
     while ((int)m_plData->size() < _iIndex)
@@ -363,7 +373,7 @@ bool List::set(const int _iIndex, InternalType* _pIT)
         }
     }
 
-    return true;
+    return this;
 }
 
 bool List::operator==(const InternalType& it)
index 4b368b7..f9d0416 100644 (file)
@@ -28,7 +28,7 @@ void ListDelete::whoAmI()
     std::cout << "types::ListDelete";
 }
 
-InternalType* ListDelete::clone(void)
+ListDelete* ListDelete::clone(void)
 {
     return new ListDelete();
 }
index fab3d6c..bb50c33 100644 (file)
@@ -43,7 +43,7 @@ void ListInsert::whoAmI()
     std::cout << "types::ListInsert";
 }
 
-InternalType* ListInsert::clone(void)
+ListInsert* ListInsert::clone(void)
 {
     return new ListInsert(m_pInsert);
 }
index 71e8f8b..eed3065 100644 (file)
@@ -28,7 +28,7 @@ void ListOperation::whoAmI()
     std::cout << "types::ListDelete";
 }
 
-InternalType* ListOperation::clone(void)
+ListOperation* ListOperation::clone(void)
 {
     return new ListOperation();
 }
index d695356..55200d9 100644 (file)
@@ -28,7 +28,7 @@ void ListUndefined::whoAmI()
     std::cout << "types::ListUndefined";
 }
 
-InternalType* ListUndefined::clone(void)
+ListUndefined* ListUndefined::clone(void)
 {
     return new ListUndefined();
 }
index 27458ba..9e2ebb1 100644 (file)
@@ -89,7 +89,7 @@ void Macro::cleanCall(symbol::Context * pContext, int oldPromptMode)
     ConfigVariable::macroFirstLine_end();
 }
 
-InternalType* Macro::clone()
+Macro* Macro::clone()
 {
     IncreaseRef();
     return this;
index f8fa219..9e56cf5 100644 (file)
@@ -44,7 +44,7 @@ MacroFile::~MacroFile()
     }
 }
 
-InternalType* MacroFile::clone()
+MacroFile* MacroFile::clone()
 {
     IncreaseRef();
     return this;
index 2194dc1..4a857fa 100644 (file)
@@ -79,12 +79,18 @@ void Polynom::createPoly(const std::wstring& _szVarName, int _iDims, const int*
 #endif
 }
 
-bool Polynom::set(int _iPos, SinglePoly* _pS)
+Polynom* Polynom::set(int _iPos, SinglePoly* _pS)
 {
-    bool bComplex = isComplex();
     if (m_pRealData == NULL || _iPos >= m_iSize)
     {
-        return false;
+        return NULL;
+    }
+
+    typedef Polynom* (Polynom::*set_t)(int, SinglePoly*);
+    Polynom* pIT = checkRef(this, (set_t)&Polynom::set, _iPos, _pS);
+    if (pIT != this)
+    {
+        return pIT;
     }
 
     if (m_pRealData[_iPos])
@@ -94,6 +100,7 @@ bool Polynom::set(int _iPos, SinglePoly* _pS)
 
     m_pRealData[_iPos] = copyValue(_pS);
 
+    bool bComplex = isComplex();
     if (_pS->isComplex() && bComplex == false)
     {
         setComplex(true);
@@ -103,44 +110,57 @@ bool Polynom::set(int _iPos, SinglePoly* _pS)
         m_pRealData[_iPos]->setComplex(true);
     }
 
-    return true;
+    return this;
 }
 
-bool Polynom::set(int _iRows, int _iCols, SinglePoly* _pS)
+Polynom* Polynom::set(int _iRows, int _iCols, SinglePoly* _pS)
 {
     return set(_iCols * getRows() + _iRows, _pS);
 }
 
-bool Polynom::set(SinglePoly** _pS)
+Polynom* Polynom::set(SinglePoly** _pS)
 {
+    typedef Polynom* (Polynom::*set_t)(SinglePoly**);
+    Polynom* pIT = checkRef(this, (set_t)&Polynom::set, _pS);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     for (int i = 0 ; i < m_iSize ; i++)
     {
         set(i, _pS[i]);
     }
-    return true;
+
+    return this;
 }
 
-bool Polynom::setCoef(int _iRows, int _iCols, Double *_pdblCoef)
+Polynom* Polynom::setCoef(int _iRows, int _iCols, Double *_pdblCoef)
 {
     int piDims[] = {_iRows, _iCols};
     int iPos = getIndex(piDims);
     return setCoef(iPos, _pdblCoef);
 }
 
-bool Polynom::setCoef(int _iIdx, Double *_pdblCoef)
+Polynom* Polynom::setCoef(int _iIdx, Double *_pdblCoef)
 {
-    if (_iIdx < getSize())
+    if (_iIdx > m_iSize)
     {
-        /*Get old SinglePoly*/
-        m_pRealData[_iIdx]->setRank(_pdblCoef->getSize() - 1);
-        m_pRealData[_iIdx]->setCoef(_pdblCoef);
+        return NULL;
     }
-    else
+
+    typedef Polynom* (Polynom::*setCoef_t)(int, Double*);
+    Polynom* pIT = checkRef(this, (setCoef_t)&Polynom::setCoef, _iIdx, _pdblCoef);
+    if (pIT != this)
     {
-        return false;
+        return pIT;
     }
 
-    return true;
+    /*Get old SinglePoly*/
+    m_pRealData[_iIdx]->setRank(_pdblCoef->getSize() - 1);
+    m_pRealData[_iIdx]->setCoef(_pdblCoef);
+
+    return this;
 }
 
 void Polynom::setZeros()
@@ -206,18 +226,29 @@ bool Polynom::isComplex()
     return false;
 }
 
-void Polynom::setComplex(bool _bComplex)
+Polynom* Polynom::setComplex(bool _bComplex)
 {
-    if (_bComplex != isComplex())
+    if (_bComplex == isComplex())
     {
-        for (int i = 0 ; i < getSize() ; i++)
-        {
-            get(i)->setComplex(_bComplex);
-        }
+        return this;
     }
+
+    typedef Polynom* (Polynom::*setcplx_t)(bool);
+    Polynom* pIT = checkRef(this, (setcplx_t)&Polynom::setComplex, _bComplex);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    for (int i = 0 ; i < getSize() ; i++)
+    {
+        get(i)->setComplex(_bComplex);
+    }
+
+    return this;
 }
 
-InternalType* Polynom::clone()
+Polynom* Polynom::clone()
 {
     Polynom* pMP = new Polynom(getVariableName(), getDims(), getDimsArray());
     for (int i = 0 ; i < getSize() ; i++)
@@ -381,8 +412,15 @@ Double* Polynom::getCoef(void)
     return pCoef;
 }
 
-void Polynom::setCoef(Double *_pCoef)
+Polynom* Polynom::setCoef(Double *_pCoef)
 {
+    typedef Polynom* (Polynom::*setCoef_t)(Double*);
+    Polynom* pIT = checkRef(this, (setCoef_t)&Polynom::setCoef, _pCoef);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     setComplex(_pCoef->isComplex());
     double *pR = _pCoef->getReal();
 
@@ -417,6 +455,8 @@ void Polynom::setCoef(Double *_pCoef)
             }
         }
     }
+
+    return this;
 }
 
 bool Polynom::subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims)
@@ -978,7 +1018,7 @@ void Polynom::deleteData(SinglePoly* data)
 }
 
 //overload to check variable name and call arrayof<>::insert after
-InternalType* Polynom::insert(typed_list* _pArgs, InternalType* _pSource)
+Polynom* Polynom::insert(typed_list* _pArgs, InternalType* _pSource)
 {
     Polynom* p = _pSource->getAs<Polynom>();
     if (p->getVariableName() != getVariableName())
@@ -990,7 +1030,8 @@ InternalType* Polynom::insert(typed_list* _pArgs, InternalType* _pSource)
         FREE(pwstError);
         throw ast::InternalError(wstError);
     }
-    return ArrayOf<SinglePoly*>::insert(_pArgs, _pSource);
+
+    return ArrayOf<SinglePoly*>::insert(_pArgs, _pSource)->getAs<Polynom>();
 }
 
 Polynom* Polynom::Dollar()
index 565d918..23bae97 100644 (file)
@@ -32,6 +32,7 @@
 #include "configvariable.hxx"
 #include "scilabWrite.hxx"
 #include "exp.hxx"
+#include "types_tools.hxx"
 
 #include "sparseOp.hxx"
 
@@ -538,11 +539,18 @@ void Sparse::fill(Double& dest, int r, int c) SPARSE_CONST
     }
 }
 
-bool Sparse::set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize)
+Sparse* Sparse::set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize)
 {
     if (_iRows >= getRows() || _iCols >= getCols())
     {
-        return false;
+        return NULL;
+    }
+
+    typedef Sparse* (Sparse::*set_t)(int, int, std::complex<double>, bool);
+    Sparse* pIT = checkRef(this, (set_t)&Sparse::set, _iRows, _iCols, v, _bFinalize);
+    if (pIT != this)
+    {
+        return pIT;
     }
 
     if (matrixReal)
@@ -558,14 +566,21 @@ bool Sparse::set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize
     {
         finalize();
     }
-    return true;
+    return this;
 }
 
-bool Sparse::set(int _iRows, int _iCols, double _dblReal, bool _bFinalize)
+Sparse* Sparse::set(int _iRows, int _iCols, double _dblReal, bool _bFinalize)
 {
     if (_iRows >= getRows() || _iCols >= getCols())
     {
-        return false;
+        return NULL;
+    }
+
+    typedef Sparse* (Sparse::*set_t)(int, int, double, bool);
+    Sparse* pIT = checkRef(this, (set_t)&Sparse::set, _iRows, _iCols, _dblReal, _bFinalize);
+    if (pIT != this)
+    {
+        return pIT;
     }
 
     if (matrixReal)
@@ -582,7 +597,8 @@ bool Sparse::set(int _iRows, int _iCols, double _dblReal, bool _bFinalize)
     {
         finalize();
     }
-    return true;
+
+    return this;
 }
 
 void Sparse::finalize()
@@ -712,15 +728,22 @@ bool Sparse::toString(std::wostringstream& ostr) const
     return true;
 }
 
-bool Sparse::resize(int _iNewRows, int _iNewCols)
+Sparse* Sparse::resize(int _iNewRows, int _iNewCols)
 {
+    typedef Sparse* (Sparse::*resize_t)(int, int);
+    Sparse* pIT = checkRef(this, (resize_t)&Sparse::resize, _iNewRows, _iNewCols);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iNewRows <= getRows() && _iNewCols <= getCols())
     {
         //nothing to do: hence we do NOT fail
-        return true;
+        return this;
     }
 
-    bool res = false;
+    Sparse* res = NULL;
     try
     {
         if (matrixReal)
@@ -798,11 +821,11 @@ bool Sparse::resize(int _iNewRows, int _iNewCols)
         m_piDims[0] = m_iRows;
         m_piDims[1] = m_iCols;
 
-        res = true;
+        res = this;
     }
     catch (...)
     {
-        res = false;
+        res = NULL;
     }
     return res;
 }
@@ -874,16 +897,15 @@ void Sparse::toComplex()
     }
 }
 
-InternalType* Sparse::insertNew(typed_list* _pArgs, InternalType* _pSource)
+GenericType* Sparse::insertNew(typed_list* _pArgs)
 {
     typed_list pArg;
-    InternalType *pOut  = NULL;
-    Sparse* pSource = _pSource->getAs<Sparse>();
+    Sparse *pOut  = NULL;
 
     int iDims           = (int)_pArgs->size();
     int* piMaxDim       = new int[iDims];
     int* piCountDim     = new int[iDims];
-    bool bComplex       = pSource->isComplex();
+    bool bComplex       = isComplex();
     bool bUndefine      = false;
 
     //evaluate each argument and replace by appropriate value and compute the count of combinations
@@ -905,14 +927,14 @@ InternalType* Sparse::insertNew(typed_list* _pArgs, InternalType* _pSource)
     {
         //manage : and $ in creation by insertion
         int iSource         = 0;
-        int *piSourceDims   = pSource->getDimsArray();
+        int *piSourceDims   = getDimsArray();
 
         for (int i = 0 ; i < iDims ; i++)
         {
             if (pArg[i] == NULL)
             {
                 //undefine value
-                if (pSource->isScalar())
+                if (isScalar())
                 {
                     piMaxDim[i]     = 1;
                     piCountDim[i]   = 1;
@@ -958,7 +980,7 @@ InternalType* Sparse::insertNew(typed_list* _pArgs, InternalType* _pSource)
 
     if (iDims == 1)
     {
-        if (pSource->getCols() == 1)
+        if (getCols() == 1)
         {
             pOut = new Sparse(piCountDim[0], 1, bComplex);
         }
@@ -971,14 +993,11 @@ InternalType* Sparse::insertNew(typed_list* _pArgs, InternalType* _pSource)
     else
     {
         pOut = new Sparse(piMaxDim[0], piMaxDim[1], bComplex);
-        //pOut = pSource->createEmpty(iDims, piMaxDim, bComplex);
+        //pOut = createEmpty(iDims, piMaxDim, bComplex);
     }
 
-    //fill with null item
-    Sparse* pSpOut = pOut->getAs<Sparse>();
-
     //insert values in new matrix
-    InternalType* pOut2 = pSpOut->insert(&pArg, pSource);
+    Sparse* pOut2 = pOut->insert(&pArg, this);
     if (pOut != pOut2)
     {
         delete pOut;
@@ -992,6 +1011,18 @@ InternalType* Sparse::insertNew(typed_list* _pArgs, InternalType* _pSource)
 
 Sparse* Sparse::insert(typed_list* _pArgs, InternalType* _pSource)
 {
+    typedef Sparse* (Sparse::*insert_t)(typed_list*, InternalType*);
+    Sparse* pIT = checkRef(this, (insert_t)&Sparse::insert, _pArgs, _pSource);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    if (_pSource->isSparse())
+    {
+        return insert(_pArgs, _pSource->getAs<Sparse>());
+    }
+
     bool bNeedToResize  = false;
     int iDims           = (int)_pArgs->size();
     if (iDims > 2)
@@ -1335,7 +1366,7 @@ Sparse* Sparse::insert(typed_list* _pArgs, Sparse* _pSource)
     return this;
 }
 
-Sparse* Sparse::remove(typed_list* _pArgs)
+GenericType* Sparse::remove(typed_list* _pArgs)
 {
     Sparse* pOut = NULL;
     int iDims = (int)_pArgs->size();
@@ -1567,8 +1598,14 @@ Sparse* Sparse::remove(typed_list* _pArgs)
     return pOut;
 }
 
-bool Sparse::append(int r, int c, types::Sparse SPARSE_CONST* src)
+Sparse* Sparse::append(int r, int c, types::Sparse SPARSE_CONST* src)
 {
+    Sparse* pIT = checkRef(this, &Sparse::append, r, c, src);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     //        std::wcerr << L"to a sparse of size"<<getRows() << L","<<getCols() << L" should append @"<<r << L","<<c<< "a sparse:"<< src->toString(32,80)<<std::endl;
     if (src->isComplex())
     {
@@ -1592,13 +1629,13 @@ bool Sparse::append(int r, int c, types::Sparse SPARSE_CONST* src)
 
     finalize();
 
-    return true; // realloc is meaningless for sparse matrices
+    return this; // realloc is meaningless for sparse matrices
 }
 
 /*
 * create a new Sparse of dims according to resSize and fill it from currentSparse (along coords)
 */
-InternalType* Sparse::extract(typed_list* _pArgs)
+GenericType* Sparse::extract(typed_list* _pArgs)
 {
     Sparse* pOut        = NULL;
     int iDims           = (int)_pArgs->size();
@@ -2594,9 +2631,9 @@ SparseBool* Sparse::newEqualTo(Sparse &o)
     return ret;
 }
 
-bool Sparse::reshape(int* _piDims, int _iDims)
+Sparse* Sparse::reshape(int* _piDims, int _iDims)
 {
-    bool bOk = false;
+    Sparse* pSp = NULL;
     int iCols = 1;
 
     if (_iDims == 2)
@@ -2606,20 +2643,27 @@ bool Sparse::reshape(int* _piDims, int _iDims)
 
     if (_iDims <= 2)
     {
-        bOk = reshape(_piDims[0], iCols);
+        pSp = reshape(_piDims[0], iCols);
     }
 
-    return bOk;
+    return pSp;
 }
 
-bool Sparse::reshape(int _iNewRows, int _iNewCols)
+Sparse* Sparse::reshape(int _iNewRows, int _iNewCols)
 {
+    typedef Sparse* (Sparse::*reshape_t)(int, int);
+    Sparse* pIT = checkRef(this, (reshape_t)&Sparse::reshape, _iNewRows, _iNewCols);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iNewRows * _iNewCols != getRows() * getCols())
     {
-        return false;
+        return NULL;
     }
 
-    bool res = false;
+    Sparse* res = NULL;
     try
     {
         if (matrixReal)
@@ -2701,11 +2745,11 @@ bool Sparse::reshape(int _iNewRows, int _iNewCols)
 
         finalize();
 
-        res = true;
+        res = this;
     }
     catch (...)
     {
-        res = false;
+        res = NULL;
     }
     return res;
 }
@@ -2878,15 +2922,22 @@ SparseBool* SparseBool::clone(void) const
     return new SparseBool(*this);
 }
 
-bool SparseBool::resize(int _iNewRows, int _iNewCols)
+SparseBool* SparseBool::resize(int _iNewRows, int _iNewCols)
 {
+    typedef SparseBool* (SparseBool::*resize_t)(int, int);
+    SparseBool* pIT = checkRef(this, (resize_t)&SparseBool::resize, _iNewRows, _iNewCols);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iNewRows <= getRows() && _iNewCols <= getCols())
     {
         //nothing to do: hence we do NOT fail
-        return true;
+        return this;
     }
 
-    bool res = false;
+    SparseBool* res = NULL;
     try
     {
         //item count
@@ -2920,12 +2971,11 @@ bool SparseBool::resize(int _iNewRows, int _iNewCols)
         m_piDims[0] = m_iRows;
         m_piDims[1] = m_iCols;
 
-        res = true;
-
+        res = this;
     }
     catch (...)
     {
-        res = false;
+        res = NULL;
     }
     return res;
 }
@@ -3071,6 +3121,18 @@ SparseBool* SparseBool::insert(typed_list* _pArgs, SparseBool* _pSource)
 
 SparseBool* SparseBool::insert(typed_list* _pArgs, InternalType* _pSource)
 {
+    typedef SparseBool* (SparseBool::*insert_t)(typed_list*, InternalType*);
+    SparseBool* pIT = checkRef(this, (insert_t)&SparseBool::insert, _pArgs, _pSource);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    if (_pSource->isSparseBool())
+    {
+        return insert(_pArgs, _pSource->getAs<SparseBool>());
+    }
+
     bool bNeedToResize  = false;
     int iDims           = (int)_pArgs->size();
     if (iDims > 2)
@@ -3205,7 +3267,7 @@ SparseBool* SparseBool::insert(typed_list* _pArgs, InternalType* _pSource)
     return this;
 }
 
-SparseBool* SparseBool::remove(typed_list* _pArgs)
+GenericType* SparseBool::remove(typed_list* _pArgs)
 {
     SparseBool* pOut = NULL;
     int iDims = (int)_pArgs->size();
@@ -3429,18 +3491,23 @@ SparseBool* SparseBool::remove(typed_list* _pArgs)
     return pOut;
 }
 
-bool SparseBool::append(int r, int c, SparseBool SPARSE_CONST* src)
+SparseBool* SparseBool::append(int r, int c, SparseBool SPARSE_CONST* src)
 {
+    SparseBool* pIT = checkRef(this, &SparseBool::append, r, c, src);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     doAppend(*src, r, c, *matrixBool);
     finalize();
-    return true;
+    return this;
 }
 
-InternalType* SparseBool::insertNew(typed_list* _pArgs, InternalType* _pSource)
+GenericType* SparseBool::insertNew(typed_list* _pArgs)
 {
     typed_list pArg;
-    InternalType *pOut  = NULL;
-    SparseBool* pSource = _pSource->getAs<SparseBool>();
+    SparseBool *pOut  = NULL;
 
     int iDims           = (int)_pArgs->size();
     int* piMaxDim       = new int[iDims];
@@ -3466,14 +3533,14 @@ InternalType* SparseBool::insertNew(typed_list* _pArgs, InternalType* _pSource)
     {
         //manage : and $ in creation by insertion
         int iSource         = 0;
-        int *piSourceDims   = pSource->getDimsArray();
+        int *piSourceDims   = getDimsArray();
 
         for (int i = 0 ; i < iDims ; i++)
         {
             if (pArg[i] == NULL)
             {
                 //undefine value
-                if (pSource->isScalar())
+                if (isScalar())
                 {
                     piMaxDim[i]     = 1;
                     piCountDim[i]   = 1;
@@ -3519,7 +3586,7 @@ InternalType* SparseBool::insertNew(typed_list* _pArgs, InternalType* _pSource)
 
     if (iDims == 1)
     {
-        if (pSource->getCols() == 1)
+        if (getCols() == 1)
         {
             pOut = new SparseBool(piCountDim[0], 1);
         }
@@ -3534,11 +3601,8 @@ InternalType* SparseBool::insertNew(typed_list* _pArgs, InternalType* _pSource)
         pOut = new SparseBool(piMaxDim[0], piMaxDim[1]);
     }
 
-    //fill with null item
-    SparseBool* pSpOut = pOut->getAs<SparseBool>();
-
     //insert values in new matrix
-    InternalType* pOut2 = pSpOut->insert(&pArg, pSource);
+    SparseBool* pOut2 = pOut->insert(&pArg, this);
     if (pOut != pOut2)
     {
         delete pOut;
@@ -3579,7 +3643,7 @@ SparseBool* SparseBool::extract(int nbCoords, int SPARSE_CONST* coords, int SPAR
 /*
 * create a new SparseBool of dims according to resSize and fill it from currentSparseBool (along coords)
 */
-InternalType* SparseBool::extract(typed_list* _pArgs)
+GenericType* SparseBool::extract(typed_list* _pArgs)
 {
     SparseBool* pOut    = NULL;
     int iDims           = (int)_pArgs->size();
@@ -3887,8 +3951,15 @@ bool SparseBool::get(int r, int c) SPARSE_CONST
     return matrixBool->coeff(r, c);
 }
 
-bool SparseBool::set(int _iRows, int _iCols, bool _bVal, bool _bFinalize) SPARSE_CONST
+SparseBool* SparseBool::set(int _iRows, int _iCols, bool _bVal, bool _bFinalize) SPARSE_CONST
 {
+    typedef SparseBool* (SparseBool::*set_t)(int, int, bool, bool);
+    SparseBool* pIT = checkRef(this, (set_t)&SparseBool::set, _iRows, _iCols, _bVal, _bFinalize);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     matrixBool->coeffRef(_iRows, _iCols) = _bVal;
 
     if (_bFinalize)
@@ -3896,7 +3967,7 @@ bool SparseBool::set(int _iRows, int _iCols, bool _bVal, bool _bFinalize) SPARSE
         finalize();
     }
 
-    return true;
+    return this;
 }
 
 void SparseBool::fill(Bool& dest, int r, int c) SPARSE_CONST
@@ -4003,9 +4074,9 @@ SparseBool* SparseBool::newLogicalAnd(SparseBool const&o) const
     return cwiseOp<std::logical_and>(*this, o);
 }
 
-bool SparseBool::reshape(int* _piDims, int _iDims)
+SparseBool* SparseBool::reshape(int* _piDims, int _iDims)
 {
-    bool bOk = false;
+    SparseBool* pSpBool = NULL;
     int iCols = 1;
 
     if (_iDims == 2)
@@ -4015,20 +4086,27 @@ bool SparseBool::reshape(int* _piDims, int _iDims)
 
     if (_iDims <= 2)
     {
-        bOk = reshape(_piDims[0], iCols);
+        pSpBool = reshape(_piDims[0], iCols);
     }
 
-    return bOk;
+    return pSpBool;
 }
 
-bool SparseBool::reshape(int _iNewRows, int _iNewCols)
+SparseBool* SparseBool::reshape(int _iNewRows, int _iNewCols)
 {
+    typedef SparseBool* (SparseBool::*reshape_t)(int, int);
+    SparseBool* pIT = checkRef(this, (reshape_t)&SparseBool::reshape, _iNewRows, _iNewCols);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iNewRows * _iNewCols != getRows() * getCols())
     {
-        return false;
+        return NULL;
     }
 
-    bool res = false;
+    SparseBool* res = NULL;
     try
     {
         //item count
@@ -4066,11 +4144,11 @@ bool SparseBool::reshape(int _iNewRows, int _iNewCols)
 
         finalize();
 
-        res = true;
+        res = this;
     }
     catch (...)
     {
-        res = false;
+        res = NULL;
     }
     return res;
 }
index 0454a99..e549fd9 100644 (file)
@@ -98,7 +98,7 @@ String::String(int _iRows, int _iCols, wchar_t const* const* _pstData)
 #endif
 }
 
-InternalType* String::clone()
+String* String::clone()
 {
     String *pstClone = new String(getDims(), getDimsArray());
     pstClone->set(m_pRealData);
@@ -578,60 +578,84 @@ void String::deleteData(wchar_t* data)
     }
 }
 
-bool String::set(int _iPos, const wchar_t* _pwstData)
+String* String::set(int _iPos, const wchar_t* _pwstData)
 {
     if (m_pRealData == NULL || _iPos >= m_iSize)
     {
-        return false;
+        return NULL;
+    }
+
+    typedef String* (String::*set_t)(int, const wchar_t*);
+    String* pIT = checkRef(this, (set_t)&String::set, _iPos, _pwstData);
+    if (pIT != this)
+    {
+        return pIT;
     }
 
     deleteString(_iPos);
     m_pRealData[_iPos] = copyValue(_pwstData);
-    return true;
+    return this;
 }
 
-bool String::set(int _iRows, int _iCols, const wchar_t* _pwstData)
+String* String::set(int _iRows, int _iCols, const wchar_t* _pwstData)
 {
     int piIndexes[2] = {_iRows, _iCols};
     return set(getIndex(piIndexes), _pwstData);
 }
 
-bool String::set(const wchar_t* const* _pwstData)
+String* String::set(const wchar_t* const* _pwstData)
 {
-    for (int i = 0; i < getSize(); i++)
+    typedef String* (String::*set_t)(const wchar_t * const*);
+    String* pIT = checkRef(this, (set_t)&String::set, _pwstData);
+    if (pIT != this)
     {
-        if (set(i, _pwstData[i]) == false)
+        return pIT;
+    }
+
+    for (int i = 0; i < m_iSize; i++)
+    {
+        if (m_pRealData == NULL || i >= m_iSize)
         {
-            return false;
+            return NULL;
         }
+
+        deleteString(i);
+        m_pRealData[i] = copyValue(_pwstData[i]);
     }
-    return true;
+    return this;
 }
 
-bool String::set(int _iPos, const char* _pcData)
+String* String::set(int _iPos, const char* _pcData)
 {
     wchar_t* w = to_wide_string(_pcData);
-    bool ret = set(_iPos, w);
+    String* ret = set(_iPos, w);
     FREE(w);
     return ret;
 }
 
-bool String::set(int _iRows, int _iCols, const char* _pcData)
+String* String::set(int _iRows, int _iCols, const char* _pcData)
 {
     int piIndexes[2] = {_iRows, _iCols};
     return set(getIndex(piIndexes), _pcData);
 }
 
-bool String::set(const char* const* _pstrData)
+String* String::set(const char* const* _pstrData)
 {
-    for (int i = 0; i < getSize(); i++)
+    typedef String* (String::*set_t)(const char * const*);
+    String* pIT = checkRef(this, (set_t)&String::set, _pstrData);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
+    for (int i = 0; i < m_iSize; i++)
     {
-        if (set(i, _pstrData[i]) == false)
+        if (set(i, _pstrData[i]) == NULL)
         {
-            return false;
+            return NULL;
         }
     }
-    return true;
+    return this;
 }
 
 wchar_t** String::allocData(int _iSize)
index 002aa84..ae39111 100644 (file)
@@ -17,6 +17,7 @@
 #include "localization.hxx"
 #include "scilabWrite.hxx"
 #include "exp.hxx"
+#include "types_tools.hxx"
 
 namespace types
 {
@@ -102,7 +103,7 @@ Struct::Struct(Struct *_oStructCopyMe)
 #endif
 }
 
-InternalType* Struct::clone()
+Struct* Struct::clone()
 {
     return new Struct(this);
 }
@@ -199,31 +200,38 @@ bool Struct::invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_
     return ArrayOf<SingleStruct*>::invoke(in, opt, _iRetCount, out, e);
 }
 
-bool Struct::set(int _iRows, int _iCols, SingleStruct* _pIT)
+Struct* Struct::set(int _iRows, int _iCols, SingleStruct* _pIT)
 {
     if (_iRows < getRows() && _iCols < getCols())
     {
         return set(_iCols * getRows() + _iRows, _pIT);
     }
-    return false;
+    return NULL;
 }
 
-bool Struct::set(int _iRows, int _iCols, const SingleStruct* _pIT)
+Struct* Struct::set(int _iRows, int _iCols, const SingleStruct* _pIT)
 {
     if (_iRows < getRows() && _iCols < getCols())
     {
         return set(_iCols * getRows() + _iRows, _pIT);
     }
-    return false;
+    return NULL;
 }
 
-bool Struct::set(int _iIndex, SingleStruct* _pIT)
+Struct* Struct::set(int _iIndex, SingleStruct* _pIT)
 {
+    typedef Struct* (Struct::*set_t)(int, SingleStruct*);
+    Struct* pIT = checkRef(this, (set_t)&Struct::set, _iIndex, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iIndex < getSize())
     {
         if (m_bDisableCloneInCopyValue && m_pRealData[_iIndex] == _pIT)
         {
-            return true;
+            return this;
         }
 
         InternalType* pOld = m_pRealData[_iIndex];
@@ -241,13 +249,20 @@ bool Struct::set(int _iIndex, SingleStruct* _pIT)
             pOld->killMe();
         }
 
-        return true;
+        return this;
     }
-    return false;
+    return NULL;
 }
 
-bool Struct::set(int _iIndex, const SingleStruct* _pIT)
+Struct* Struct::set(int _iIndex, const SingleStruct* _pIT)
 {
+    typedef Struct* (Struct::*set_t)(int, const SingleStruct*);
+    Struct* pIT = checkRef(this, (set_t)&Struct::set, _iIndex, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     if (_iIndex < getSize())
     {
         InternalType* pOld = m_pRealData[_iIndex];
@@ -260,21 +275,28 @@ bool Struct::set(int _iIndex, const SingleStruct* _pIT)
             pOld->killMe();
         }
 
-        return true;
+        return this;
     }
-    return false;
+    return NULL;
 }
 
-bool Struct::set(SingleStruct** _pIT)
+Struct* Struct::set(SingleStruct** _pIT)
 {
+    typedef Struct* (Struct::*set_t)(SingleStruct**);
+    Struct* pIT = checkRef(this, (set_t)&Struct::set, _pIT);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     for (int i = 0 ; i < getSize() ; i++)
     {
-        if (set(i, _pIT[i]) == false)
+        if (set(i, _pIT[i]) == NULL)
         {
-            return false;
+            return NULL;
         }
     }
-    return true;
+    return this;
 }
 
 String* Struct::getFieldNames()
@@ -404,13 +426,10 @@ bool Struct::subMatrixToString(std::wostringstream& /*ostr*/, int* /*_piDims*/,
 
 Struct* Struct::addField(const std::wstring& _sKey)
 {
-    if (getRef() > 1)
+    Struct* pIT = checkRef(this, &Struct::addField, _sKey);
+    if (pIT != this)
     {
-        // A Struct content in more than one Scilab variable
-        // must be cloned before to be modified.
-        Struct* pClone = clone()->template getAs<Struct>();
-        pClone->addField(_sKey);
-        return pClone;
+        return pIT;
     }
 
     if (getSize() == 0)
@@ -421,13 +440,6 @@ Struct* Struct::addField(const std::wstring& _sKey)
 
     for (int i = 0 ; i < getSize() ; i++)
     {
-        /*
-                    if(get(i)->isRef(1))
-                    {//assign more than once
-                        //clone it before add field
-                        set(i, get(i)->clone());
-                    }
-        */
         get(i)->addField(_sKey);
     }
 
@@ -436,13 +448,10 @@ Struct* Struct::addField(const std::wstring& _sKey)
 
 Struct* Struct::addFieldFront(const std::wstring& _sKey)
 {
-    if (getRef() > 1)
+    Struct* pIT = checkRef(this, &Struct::addFieldFront, _sKey);
+    if (pIT != this)
     {
-        // A Struct content in more than one Scilab variable
-        // must be cloned before to be modified.
-        Struct* pClone = clone()->template getAs<Struct>();
-        pClone->addField(_sKey);
-        return pClone;
+        return pIT;
     }
 
     if (getSize() == 0)
@@ -461,13 +470,10 @@ Struct* Struct::addFieldFront(const std::wstring& _sKey)
 
 Struct* Struct::removeField(const std::wstring& _sKey)
 {
-    if (getRef() > 1)
+    Struct* pIT = checkRef(this, &Struct::removeField, _sKey);
+    if (pIT != this)
     {
-        // A Struct content in more than one Scilab variable
-        // must be cloned before to be modified.
-        Struct* pClone = clone()->template getAs<Struct>();
-        pClone->addField(_sKey);
-        return pClone;
+        return pIT;
     }
 
     for (int j = 0; j < getSize(); j++)
@@ -683,18 +689,25 @@ std::vector<InternalType*> Struct::extractFields(typed_list* _pArgs)
     return ResultList;
 }
 
-bool Struct::resize(int _iNewRows, int _iNewCols)
+Struct* Struct::resize(int _iNewRows, int _iNewCols)
 {
     int piDims[2] = {_iNewRows, _iNewCols};
     return resize(piDims, 2);
 }
 
-bool Struct::resize(int* _piDims, int _iDims)
+Struct* Struct::resize(int* _piDims, int _iDims)
 {
+    typedef Struct* (Struct::*resize_t)(int*, int);
+    Struct* pIT = checkRef(this, (resize_t)&Struct::resize, _piDims, _iDims);
+    if (pIT != this)
+    {
+        return pIT;
+    }
+
     m_bDisableCloneInCopyValue = true;
-    bool bRes = ArrayOf<SingleStruct*>::resize(_piDims, _iDims);
+    Struct* pSRes = ArrayOf<SingleStruct*>::resize(_piDims, _iDims)->getAs<Struct>();
     m_bDisableCloneInCopyValue = false;
-    if (bRes)
+    if (pSRes)
     {
         // insert field(s) only in new element(s) of current struct
         String* pFields = getFieldNames();
@@ -709,7 +722,7 @@ bool Struct::resize(int* _piDims, int _iDims)
         pFields->killMe();
     }
 
-    return bRes;
+    return pSRes;
 }
 
 InternalType* Struct::insertWithoutClone(typed_list* _pArgs, InternalType* _pSource)
index db120ef..d4fc0da 100644 (file)
@@ -61,7 +61,7 @@ void ThreadId::setKey(__threadKey _key)
     this->m_threadKey = _key;
 }
 
-InternalType* ThreadId::clone()
+ThreadId* ThreadId::clone()
 {
     return this;
 }
index 808bff3..bdea399 100644 (file)
@@ -21,6 +21,8 @@
 #include "polynom.hxx"
 #include "overload.hxx"
 #include "configvariable.hxx"
+#include "types_tools.hxx"
+#include "scilabWrite.hxx"
 
 #ifndef NDEBUG
 #include "inspector.hxx"
@@ -54,7 +56,7 @@ TList::~TList()
 ** Clone
 ** Create a new List and Copy all values.
 */
-InternalType* TList::clone()
+TList* TList::clone()
 {
     return new TList(this);
 }
@@ -278,14 +280,14 @@ std::wstring TList::getShortTypeStr()
     return getTypeStr();
 }
 
-bool TList::set(const std::wstring& _sKey, InternalType* _pIT)
+TList* TList::set(const std::wstring& _sKey, InternalType* _pIT)
 {
-    return List::set(getIndexFromString(_sKey), _pIT);
+    return List::set(getIndexFromString(_sKey), _pIT)->getAs<TList>();
 }
 
-bool TList::set(const int _iIndex, InternalType* _pIT)
+TList* TList::set(const int _iIndex, InternalType* _pIT)
 {
-    return List::set(_iIndex, _pIT);
+    return List::set(_iIndex, _pIT)->getAs<TList>();
 }
 
 String* TList::getFieldNames()
index e4bd538..ba1a516 100644 (file)
@@ -16,6 +16,7 @@
 #include "alltypes.hxx"
 #include "types_tools.hxx"
 #include "overload.hxx"
+#include "scilabWrite.hxx"
 
 extern "C"
 {
@@ -61,7 +62,7 @@ double getIndex(InternalType* val)
 {
     switch (val->getType())
     {
-        //scalar
+            //scalar
         case InternalType::ScilabDouble:
         {
             return getIndex(val->getAs<Double>());
@@ -854,4 +855,85 @@ types::Function::ReturnValue VariableToString(types::InternalType* pIT, const wc
         return types::Function::OK;
     }
 }
+
+//n-uplet in french
+int computeTuples(int* _piCountDim, int _iDims, int _iCurrentDim, int* _piIndex)
+{
+    //if bRet == 1, previous dims has reach max value.
+    int iRet = 0;
+
+    if (_iCurrentDim == 0)
+    {
+        //last dims
+        if (_piIndex[_iCurrentDim] >= _piCountDim[_iCurrentDim])
+        {
+            _piIndex[_iCurrentDim] = 0;
+            return 1;
+        }
+    }
+    else
+    {
+        iRet = computeTuples(_piCountDim, _iDims, _iCurrentDim - 1, _piIndex);
+        if (iRet)
+        {
+            _piIndex[_iCurrentDim]++;
+            if (_piIndex[_iCurrentDim] >= _piCountDim[_iCurrentDim])
+            {
+                _piIndex[_iCurrentDim] = 0;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+Double* createEmptyDouble()
+{
+    return Double::Empty();
+}
+
+int getIntValueFromDouble(InternalType* _pIT, int _iPos)
+{
+    return static_cast<int>(_pIT->getAs<Double>()->get(_iPos));
+}
+
+double* getDoubleArrayFromDouble(InternalType* _pIT)
+{
+    return _pIT->getAs<Double>()->get();
+}
+
+Double* createDoubleVector(int _iSize)
+{
+    int piDims[] = {1, _iSize};
+    Double* pOut = new Double(2, piDims);
+    for (int i = 0; i < _iSize; i++)
+    {
+        pOut->set(i, i + 1);
+    }
+    return pOut;
+}
+
+bool checkArgValidity(typed_list& _Arg)
+{
+    for (int i = 0; i < (int)_Arg.size(); i++)
+    {
+        if (_Arg[i]->isDouble() == false)
+        {
+            return false;
+        }
+
+        Double* pDbl = _Arg[i]->getAs<Double>();
+        double* pdbl = pDbl->get();
+        for (int j = 0; j < pDbl->getSize(); j++)
+        {
+            if (pdbl[j] <= 0)
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 }
index 64bc086..b12f9fa 100644 (file)
@@ -28,7 +28,7 @@ void Void::whoAmI()
     std::cout << "types::Void";
 }
 
-InternalType* Void::clone(void)
+Void* Void::clone(void)
 {
     return new Void();
 }
index b3b0b5d..145e749 100644 (file)
@@ -48,7 +48,7 @@ public:
         return L"nt";
     }
 
-    types::InternalType*    clone()
+    NewType*    clone()
     {
         return new NewType();
     }
index 60227a0..a0e076a 100644 (file)
@@ -14,6 +14,7 @@
 #include "string.hxx"
 #include "scilabWrite.hxx"
 #include "configvariable.hxx"
+#include "function.hxx"
 
 extern "C"
 {
index d8abb96..5b52dc6 100644 (file)
@@ -44,7 +44,7 @@ public :
         return L"eo";
     }
 
-    InternalType* clone()
+    EOType* clone()
     {
         return new EOType(id, isNew);
     }
index 35b32c3..698dcbc 100644 (file)
@@ -11,6 +11,8 @@
 */
 
 #include "double.hxx"
+#include "function.hxx"
+
 extern "C"
 {
 #include "fftw_utilities.h"
index 00497e8..2e94cd4 100644 (file)
@@ -20,6 +20,7 @@
 #include "string.hxx"
 #include "scilab_sprintf.hxx"
 #include "overload.hxx"
+#include "scilabWrite.hxx"
 
 extern "C"
 {
index b88c1f7..b47d73f 100644 (file)
@@ -14,6 +14,7 @@
 #include "callable.hxx"
 #include "double.hxx"
 #include "bool.hxx"
+#include "function.hxx"
 
 extern "C"
 {
@@ -41,7 +42,7 @@ int schur_dgees(double* _real, double* _img)
         types::typed_list out;
         types::optional_list opt;
         int iRetCount = 1;
-        
+
         types::Double* pDbl = new types::Double(*_real, *_img);
         pDbl->IncreaseRef();
         in.push_back(pDbl);
@@ -104,7 +105,7 @@ int schur_dgges(double* _real, double* _img, double* _beta)
         types::typed_list out;
         types::optional_list opt;
         int iRetCount = 1;
-        
+
         types::Double* pDblAlpha = new types::Double(*_real, *_img);
         pDblAlpha->IncreaseRef();
         types::Double* pDblBeta  = new types::Double(*_beta);
@@ -172,7 +173,7 @@ int schur_zgees(doublecomplex* _complex)
         types::typed_list out;
         types::optional_list opt;
         int iRetCount = 1;
-        
+
         types::Double* pDbl = new types::Double(_complex->r, _complex->i);
         pDbl->IncreaseRef();
         in.push_back(pDbl);
@@ -241,7 +242,7 @@ int schur_zgges(doublecomplex* _alpha, doublecomplex* _beta)
         types::typed_list out;
         types::optional_list opt;
         int iRetCount = 1;
-        
+
         types::Double* pDblAlpha = new types::Double(_alpha->r, _alpha->i);
         pDblAlpha->IncreaseRef();
         types::Double* pDblBeta  = new types::Double(_beta->r, _beta->i);
index 75bae0e..650ea77 100644 (file)
@@ -25,8 +25,6 @@
 #include <cstring>
 
 #include "gw_scicos.hxx"
-#include "extractblklist.hxx"
-#include "createblklist.hxx"
 
 #include "internal.hxx"
 #include "function.hxx"
@@ -45,6 +43,10 @@ extern "C"
 #include "Scierror.h"
 #include "localization.h"
 }
+
+#include "extractblklist.hxx"
+#include "createblklist.hxx"
+
 /*--------------------------------------------------------------------------*/
 static const std::string name = "callblk";
 /*--------------------------------------------------------------------------*/
index aac296b..d372376 100644 (file)
@@ -23,8 +23,6 @@
 /*--------------------------------------------------------------------------*/
 #include <cstring>
 
-#include "extractblklist.hxx"
-
 #include "internal.hxx"
 #include "list.hxx"
 #include "tlist.hxx"
@@ -37,6 +35,9 @@ extern "C"
 #include "scicos_block4.h"
 #include "charEncoding.h"
 }
+
+#include "extractblklist.hxx"
+
 /*--------------------------------------------------------------------------*/
 
 template <typename T>
index ef8d65e..7e340d2 100644 (file)
@@ -298,7 +298,7 @@ public:
     virtual std::wstring getShortTypeStr() = 0;
 
 private:
-    types::InternalType* clone()
+    virtual UserType* clone() final
     {
         return new Adaptor(*static_cast<Adaptor*>(this));
     }
@@ -387,7 +387,7 @@ private:
         return NULL;
     }
 
-    types::InternalType* insert(types::typed_list* _pArgs, types::InternalType* _pSource)
+    types::UserType* insert(types::typed_list* _pArgs, types::InternalType* _pSource)
     {
         for (size_t i = 0; i < _pArgs->size(); i++)
         {
index 3cef755..2444f2a 100644 (file)
@@ -13,6 +13,7 @@
 #include "double.hxx"
 #include "signalprocessingfunctions.hxx"
 #include "configvariable.hxx"
+#include "function.hxx"
 
 extern "C"
 {
index 8ce996e..18b06b0 100644 (file)
@@ -16,7 +16,7 @@
 
 #include "types.hxx"
 #include "int.hxx"
-
+#include "function.hxx"
 #include "gw_xcos.hxx"
 
 extern "C" {