improve extract 89/16889/1
Antoine ELIAS [Tue, 19 May 2015 16:14:04 +0000 (18:14 +0200)]
Change-Id: Ia98df043135bc5246da4214a2c55e905a90b9b17

12 files changed:
scilab/modules/ast/includes/exps/smallintselectexp.hxx
scilab/modules/ast/includes/parse/parser.hxx
scilab/modules/ast/includes/parse/parser_private.hxx
scilab/modules/ast/includes/types/types_tools.hxx
scilab/modules/ast/src/cpp/ast/run_CallExp.hpp
scilab/modules/ast/src/cpp/ast/runvisitor.cpp
scilab/modules/ast/src/cpp/parse/parser.cpp
scilab/modules/ast/src/cpp/types/arrayof.cpp
scilab/modules/ast/src/cpp/types/sparse.cpp
scilab/modules/ast/src/cpp/types/types_tools.cpp
scilab/modules/ast/tests/nonreg_tests/bug_9344.linux.dia.ref [moved from scilab/modules/ast/tests/nonreg_tests/bug_9344.dia.ref with 100% similarity]
scilab/modules/ast/tests/nonreg_tests/bug_9344.win.dia.ref [new file with mode: 0644]

index 264bf83..0381164 100644 (file)
@@ -62,8 +62,8 @@ public:
 
     inline Exp * getExp(const int64_t key) const
     {
-        const unsigned int size = table.size();
-        for (unsigned int i = 0; i < size; ++i)
+        const int size = static_cast<int>(table.size());
+        for (int i = 0; i < size; ++i)
         {
             if (table[i] == key)
             {
index 97be86c..d1bbfda 100644 (file)
@@ -81,8 +81,8 @@ public:
     void parseFile(const std::wstring& name, const std::wstring& progName);
 
     /** \brief parse the given file command */
-    void parse(char *command);
-    void parse(wchar_t *command);
+    void parse(const char *command);
+    void parse(const wchar_t *command);
 
     /** \brief enable Bison trace mode */
     void setParseTrace(bool parseTrace)
index f858fa0..0f7c339 100644 (file)
@@ -69,7 +69,7 @@ public :
     /*
     ** Parsing functions
     */
-    static void parse(char *command);
+    static void parse(const char *command);
     static void parseFile(const std::wstring& fileName, const std::wstring& progName);
 
     /*
index c5933a7..fb532ee 100644 (file)
@@ -19,7 +19,9 @@
 namespace types
 {
 bool getScalarIndex(GenericType* _pRef, typed_list* _pArgsIn, int* index);
-bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>& index);
+bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>& index, std::vector<int>& dims);
+bool getScalarImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<double>& index);
+
 EXTERN_AST int checkIndexesArguments(InternalType* _pRef, typed_list* _pArgsIn, typed_list* _pArgsOut, int* _piMaxDim, int* _piCountDim);
 EXTERN_AST void cleanIndexesArguments(typed_list* _pArgsOrig, typed_list* _pArgsNew);
 EXTERN_AST void getIndexesWithDims(int _iIndex, int* _piIndexes, int* _piDims, int _iDims);
index fd5b519..d1a52bb 100644 (file)
@@ -96,14 +96,18 @@ void RunVisitorT<T>::visitprivate(const CallExp &e)
                 continue;
             }
 
-            InternalType * pITArg = getResult();
-            if (pITArg->isImplicitList())
+            //extract implicit list for call()
+            if (pIT->isCallable() || pIT->isUserType())
             {
-                types::ImplicitList* pIL = pITArg->getAs<types::ImplicitList>();
-                if (pIL->isComputable())
+                InternalType * pITArg = getResult();
+                if (pITArg->isImplicitList())
                 {
-                    setResult(pIL->extractFullMatrix());
-                    pITArg->killMe();
+                    types::ImplicitList* pIL = pITArg->getAs<types::ImplicitList>();
+                    if (pIL->isComputable())
+                    {
+                        setResult(pIL->extractFullMatrix());
+                        pITArg->killMe();
+                    }
                 }
             }
 
@@ -190,6 +194,8 @@ void RunVisitorT<T>::visitprivate(const CallExp &e)
                     ret = pIT->invoke(in, opt, iRetCount, out, *this, e);
                     if(ret == false && pIT->isUserType())
                     {
+
+
                         // call overload
                         ret = Overload::call(L"%" + pIT->getShortTypeStr() + L"_e", in, iRetCount, out, this);
                     }
index 818d006..9841111 100644 (file)
@@ -415,6 +415,9 @@ void RunVisitorT<T>::visitprivate(const ForExp  &e)
                         //unlock me
                         pIL->DecreaseRef();
 
+                        //no need to destroy, it already assign to another var
+                        //pIL->killMe();
+
                         //create a new me
                         pIL = pVar->getInitalType();
                         //lock loop index
@@ -434,7 +437,6 @@ void RunVisitorT<T>::visitprivate(const ForExp  &e)
 
             pVar->extractValue(i, pIL);
 
-            bool clearAndExit = false;
             try
             {
                 e.getBody().accept(*this);
index 0754b45..03fd8a7 100644 (file)
@@ -106,7 +106,7 @@ void ParserSingleInstance::parseFile(const std::wstring& fileName, const std::ws
     fclose(yyin);
 }
 
-void Parser::parse(char *command)
+void Parser::parse(const char *command)
 {
     // Calling Parse state machine in C with global values
     // Must be locked to avoid concurrent access
@@ -141,7 +141,7 @@ void Parser::parse(char *command)
     // FIXME : UNLOCK
 }
 
-void Parser::parse(wchar_t *command)
+void Parser::parse(const wchar_t *command)
 {
     char* pstCommand = wide_string_to_UTF8(command);
     parse(pstCommand);
@@ -149,7 +149,7 @@ void Parser::parse(wchar_t *command)
 }
 
 /** \brief parse the given file command */
-void ParserSingleInstance::parse(char *command)
+void ParserSingleInstance::parse(const char *command)
 {
     size_t len = strlen(command);
 
@@ -202,7 +202,7 @@ void ParserSingleInstance::parse(char *command)
 
 #ifndef _MSC_VER
 #ifndef __APPLE__
-    yyin = fmemopen(command, len, "r");
+    yyin = fmemopen((void*)command, len, "r");
 #endif
 #endif
 
index fd17e76..c7ec479 100644 (file)
@@ -153,7 +153,8 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
     }
 
     std::vector<int> indexes;
-    if (getImplicitIndex(this, _pArgs, indexes))
+    std::vector<int> dims;
+    if (getImplicitIndex(this, _pArgs, indexes, dims))
     {
         if (indexes.size() == 0)
         {
@@ -177,7 +178,7 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
         {
             if (sizeIn == 1)
             {
-                for (int i : indexes)
+                for (int& i : indexes)
                 {
                     if (set(i, *pRealData) == false)
                     {
@@ -188,7 +189,7 @@ InternalType* ArrayOf<T>::insert(typed_list* _pArgs, InternalType* _pSource)
             }
             else
             {
-                for (int i : indexes)
+                for (int& i : indexes)
                 {
                     if (set(i, *pRealData) == false)
                     {
@@ -980,6 +981,118 @@ InternalType* ArrayOf<T>::extract(typed_list* _pArgs)
     int iDims = (int)_pArgs->size();
     typed_list pArg;
 
+    int index;
+    if (getScalarIndex(this, _pArgs, &index))
+    {
+        if (index < 0 || index >= getSize())
+        {
+            return NULL;
+        }
+
+        int dims[2] = {1, 1};
+        pOut = createEmpty(2, dims, isComplex());;
+        pOut->set(0, get(index));
+        if (isComplex())
+        {
+            pOut->setImg(0, getImg(index));
+        }
+
+        return pOut;
+    }
+
+    std::vector<double> il;
+    if (getScalarImplicitIndex(this, _pArgs, il))
+    {
+        double start = il[0];
+        double step = il[1];
+        double end = il[2];
+        //index are ":"
+        bool isForceColVector = il.size() == 4;
+
+        //std::cout << start << ":" << step << ":" << end << std::endl;
+        int size = static_cast<int>((end - start) / step + 1);
+        if (size <= 0)
+        {
+            return createEmptyDouble();
+        }
+
+        bool isRowVector = getRows() == 1;
+        isRowVector = isRowVector && !isForceColVector;
+        int dims[2] = {isRowVector ? 1 : size, isRowVector ? size : 1};
+        pOut = createEmpty(2, dims, isComplex());
+        double idx = start;
+
+        if (isComplex())
+        {
+            for (int i = 0; i < size; ++i)
+            {
+                int index = static_cast<int>(idx) - 1;
+                pOut->set(i, get(index));
+                pOut->setImg(i, getImg(index));
+                idx += step;
+            }
+        }
+        else
+        {
+            for (int i = 0; i < size; ++i)
+            {
+                pOut->set(i, get(static_cast<int>(idx) - 1));
+                idx += step;
+            }
+        }
+        return pOut;
+    }
+
+    std::vector<int> indexes;
+    std::vector<int> dims;
+    if (getImplicitIndex(this, _pArgs, indexes, dims))
+    {
+        if (indexes.size() == 0)
+        {
+            return createEmptyDouble();
+        }
+
+        if (dims.size() == 1)
+        {
+            int d[2] = {1, dims[0]};
+            pOut = createEmpty(2, d, isComplex());
+        }
+        else
+        {
+            pOut = createEmpty(static_cast<int>(dims.size()), dims.data(), isComplex());
+        }
+
+        int size = getSize();
+        if (isComplex())
+        {
+            int idx = 0;
+            for (int& i : indexes)
+            {
+                if (i < 0 || i >= size)
+                {
+                    pOut->killMe();
+                    return NULL;
+                }
+
+                pOut->set(idx, get(i));
+                pOut->setImg(idx, getImg(i));
+                ++idx;
+            }
+        }
+        else
+        {
+            int idx = 0;
+            for (int& i : indexes)
+            {
+                pOut->set(idx, get(i));
+                ++idx;
+            }
+        }
+
+        return pOut;
+    }
+
+
     int* piMaxDim = new int[iDims];
     int* piCountDim = new int[iDims];
 
@@ -1490,17 +1603,17 @@ bool ArrayOf<T>::neg(InternalType *& out)
 
 
 // used to allow definition of ArrayOf methode in this cpp file.
-template class EXTERN_AST ArrayOf<char>;
-template class EXTERN_AST ArrayOf<unsigned char>;
-template class EXTERN_AST ArrayOf<short>;
-template class EXTERN_AST ArrayOf<unsigned short>;
-template class EXTERN_AST ArrayOf<int>;
-template class EXTERN_AST ArrayOf<unsigned int>;
-template class EXTERN_AST ArrayOf<long long>;
-template class EXTERN_AST ArrayOf<unsigned long long>;
-template class EXTERN_AST ArrayOf<double>;
-template class EXTERN_AST ArrayOf<wchar_t*>;
-template class EXTERN_AST ArrayOf<SinglePoly*>;
-template class EXTERN_AST ArrayOf<SingleStruct*>;
-template class EXTERN_AST ArrayOf<InternalType*>; // Cell
+template class EXTERN_AST ArrayOf < char >;
+template class EXTERN_AST ArrayOf < unsigned char >;
+template class EXTERN_AST ArrayOf < short >;
+template class EXTERN_AST ArrayOf < unsigned short >;
+template class EXTERN_AST ArrayOf < int >;
+template class EXTERN_AST ArrayOf < unsigned int >;
+template class EXTERN_AST ArrayOf < long long >;
+template class EXTERN_AST ArrayOf < unsigned long long >;
+template class EXTERN_AST ArrayOf < double >;
+template class EXTERN_AST ArrayOf < wchar_t* >;
+template class EXTERN_AST ArrayOf < SinglePoly* >;
+template class EXTERN_AST ArrayOf < SingleStruct* >;
+template class EXTERN_AST ArrayOf < InternalType* >; // Cell
 }
index 81c1176..daa7564 100644 (file)
@@ -2272,9 +2272,6 @@ SparseBool* Sparse::newEqualTo(Sparse &o)
 
     //create a boolean sparse matrix with dims of sparses
     types::SparseBool* ret = new types::SparseBool(row, col);
-
-    std::cout << "row " << row << std::endl << "col " << col << std::endl;
-
     if (isScalar() && o.isScalar())
     {
         if (isComplex() || o.isComplex())
index ae7bd6e..fd465ee 100644 (file)
@@ -94,7 +94,7 @@ bool getScalarIndex(GenericType* _pRef, typed_list* _pArgsIn, int* index)
     int dimsIn = static_cast<int>(_pArgsIn->size());
 
     //same dims and less than internal limit
-    if (dimsIn != 1 && dimsIn != dimsRef || dimsIn > MAX_DIMS)
+    if (dimsIn != 1 && (dimsIn != dimsRef || dimsIn > MAX_DIMS))
     {
         return false;
     }
@@ -120,12 +120,6 @@ bool getScalarIndex(GenericType* _pRef, typed_list* _pArgsIn, int* index)
         }
     }
 
-    //int idx = ind[0];
-    //if (dimsIn > 1 && idx >= pdims[0])
-    //{
-    //    return false;
-    //}
-
     int idx = 0;
     int previousDims = 1;
     for (int i = 0; i < dimsIn; ++i)
@@ -159,14 +153,52 @@ static double evalute(InternalType* pIT, int sizeRef)
 
     return real;
 }
+
+bool getScalarImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<double>& index)
+{
+    int dimsIn = static_cast<int>(_pArgsIn->size());
+    if (dimsIn != 1)
+    {
+        return false;
+    }
+
+    InternalType* pIT = (*_pArgsIn)[0];
+
+    if (pIT->isImplicitList() == false)
+    {
+        return false;
+    }
+
+    index.reserve(4);
+    if (pIT->isColon())
+    {
+        index.push_back(1);
+        index.push_back(1);
+        index.push_back(_pRef->getSize());
+        //use to know we have a real ":" to shape return matrix in col vector
+        index.push_back(0);
+    }
+    else
+    {
+        ImplicitList* pIL = pIT->getAs<ImplicitList>();
+        int sizeRef = _pRef->getSize();
+        index.push_back(evalute(pIL->getStart(), sizeRef));
+        index.push_back(evalute(pIL->getStep(), sizeRef));
+        index.push_back(evalute(pIL->getEnd(), sizeRef));
+    }
+
+    return true;
+}
+
 //get index from implicit or colon index + scalar
-bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>& index)
+bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>& index, std::vector<int>& dims)
 {
     int dimsRef = _pRef->getDims();
     int dimsIn = static_cast<int>(_pArgsIn->size());
     bool viewAsVector = dimsIn == 1;
+    dims.reserve(dimsIn);
     //same dims and less than internal limit
-    if (dimsIn != 1 && dimsIn != dimsRef || dimsIn > MAX_DIMS)
+    if (dimsIn != 1 && (dimsIn != dimsRef || dimsIn > MAX_DIMS))
     {
         return false;
     }
@@ -187,6 +219,7 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
             }
 
             lstIdx.emplace_back(1, idx);
+            dims.push_back(1);
         }
         else if (in->isColon())
         {
@@ -195,6 +228,7 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
             idx[1] = viewAsVector ? _pRef->getSize() : pdims[i];
             lstIdx.push_back(idx);
             finalSize *= idx[1];
+            dims.push_back(idx[1]);
         }
         else if (in->isImplicitList())
         {
@@ -217,6 +251,7 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
                         lstIdx.push_back(idx);
                         finalSize *= idx[1];
                         isColon = true;
+                        dims.push_back(idx[1]);
                     }
                 }
             }
@@ -231,15 +266,14 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
                 //printf("%.2f : %.2f : %.2f\n", start, step, end);
 
                 int size = (end - start) / step + 1;
-                vector<int> idx(size);
-
-                if (size == 0)
+                if (size <= 0)
                 {
                     //manage implicit that return []
                     index.clear();
                     return true;
                 }
 
+                vector<int> idx(size);
                 int* pi = idx.data();
                 pi[0] = start - 1; //0-indexed
                 for (int j = 1; j < size; ++j)
@@ -249,6 +283,7 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
 
                 lstIdx.push_back(idx);
                 finalSize *= size;
+                dims.push_back(size);
             }
         }
         else
@@ -258,7 +293,12 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
     }
 
     index.resize(finalSize, 0);
-    //printf("finalSize : %d\n", finalSize);
+
+    if (finalSize == 0)
+    {
+        return true;
+    }
+
     //compute tuples
     int previousSize = 1;
     int currentDim = 0;
@@ -266,10 +306,9 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
     while (lstIdx.empty() == false)
     {
         std::vector<int>& v = lstIdx.front();
-        int currentSize = v.size();
+        int currentSize = static_cast<int>(v.size());
         const int* pv = v.data();
 
-        bool colon = false;
         if (pv[0] == -1 && currentSize == 2)
         {
             currentSize = pv[1];
@@ -288,16 +327,12 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
                     for (int j = 0; j < previousSize; ++j)
                     {
                         index[idx2 + j] += idx3;
-                        //printf("\tindex[%d] = %d\n", idx2 + i, previousSize * v[m]);
                     }
                 }
             }
         }
         else
         {
-            //printf("currentSize : %d\n", currentSize);
-            //printf("previousSize : %d\n", previousSize);
-            //printf("n : %d\n", finalSize / (currentSize * previousSize));
             int occ = finalSize / (currentSize * previousSize);
             for (int n = 0; n < occ; ++n)
             {
@@ -313,7 +348,6 @@ bool getImplicitIndex(GenericType* _pRef, typed_list* _pArgsIn, std::vector<int>
                     for (int j = 0; j < previousSize; ++j)
                     {
                         index[idx2 + j] += idx3;
-                        //printf("\tindex[%d] = %d\n", idx2 + i, previousSize * v[m]);
                     }
                 }
             }
diff --git a/scilab/modules/ast/tests/nonreg_tests/bug_9344.win.dia.ref b/scilab/modules/ast/tests/nonreg_tests/bug_9344.win.dia.ref
new file mode 100644 (file)
index 0000000..33d39dc
--- /dev/null
@@ -0,0 +1,20 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011 - DIGITEO - Bruno JOFRET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- Non-regression test for bug 9344 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=9344
+//
+// <-- Short Description -->
+// Parser did not display anything when failing on UTF-8 char
+// <-- JVM NOT MANDATORY -->
+execstr("mclose(1");
+[Scilab6] mclose(1
+[Scilab6] ^
+[Scilab6] prompt : 1.1 - 2.1 : syntax error, unexpected end of line, expecting "," or )
+at line    31 of executed file TMPDIR\bug_9344.tst