Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_and.cpp
index 9a7376d..4893294 100644 (file)
@@ -1,12 +1,16 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
  *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ *
+ * This file is hereby licensed under the terms of the GNU GPL v2.0,
+ * pursuant to article 5.3.4 of the CeCILL v.2.1.
+ * This file was originally licensed under the terms of the CeCILL v2.1,
+ * and continues to be available under such terms.
+ * For more information, see the COPYING file which you should have received
+ * along with this program.
  *
  */
 extern "C"
@@ -397,136 +401,145 @@ void fillAndFunction()
 InternalType* GenericShortcutAnd(InternalType* _pL)
 {
     InternalType* pResult = NULL;
-    if (_pL->isBool())
-    {
-        BoolAndBool(_pL->getAs<Bool>(), (Bool**)&pResult);
-    }
-
-    if (_pL->isInt())
-    {
-        IntAndInt(_pL, (Bool**)&pResult);
-    }
-
-    if (_pL->isSparseBool())
+    switch (_pL->getType())
     {
-        SparseBoolAndSparseBool(_pL, (Bool**)&pResult);
+        case InternalType::ScilabBool :
+            isValueFalse(_pL->getAs<Bool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabDouble :
+            isValueFalse(_pL->getAs<Double>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt8 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt8 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt16 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt16 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt32 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt32 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt64 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt64 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparse :
+            isValueFalse(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparseBool :
+            isValueFalse(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        default:
+            // will return NULL
+            break;
     }
 
     return pResult;
 }
 
-// &
-InternalType* GenericLogicalAnd(InternalType* _pL, InternalType* _pR)
-{
-    InternalType *pResult = NULL;
-
-    and_function bit_and = pAndfunction[_pL->getId()][_pR->getId()];
-    if (bit_and)
-    {
-        pResult = bit_and(_pL, _pR);
-        if (pResult)
-        {
-            return pResult;
-        }
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    return NULL;
-}
-
-int BoolAndBool(Bool* _pL, Bool** _pOut)
+template<typename T>
+void isValueFalse(T* _pL, types::Bool** _pOut)
 {
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
         if (_pL->get(i) == 0)
         {
-            //false && something -> false
-            *_pOut = new Bool(0);
-            return 0;
+            if ( !_pL->isComplex() || (_pL->getImg(i) == 0) )
+            {
+                *_pOut = new Bool(0); //false && something -> false
+                return;
+            }
         }
     }
 
     //call non shortcut operation
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
-template <class K>
-static int IntAndInt(K* _pL, Bool** _pOut)
+template<>
+void isValueFalse(Double* _pL, Bool** _pOut)
 {
+    if (_pL->isEmpty())
+    {
+        //call non shorcut operation
+        *_pOut = NULL;
+        return;
+    }
+
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
         if (_pL->get(i) == 0)
         {
-            //false && something -> false
-            *_pOut = new Bool(0);
-            return 0;
+            if ( !_pL->isComplex() || (_pL->getImg(i) == 0) )
+            {
+                *_pOut = new Bool(0); //false && something -> false
+                return;
+            }
         }
     }
 
     //call non shortcut operation
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
-int IntAndInt(InternalType* _pL, Bool** _pOut)
+template<>
+void isValueFalse(Sparse* _pL, Bool** _pOut)
 {
-    switch (_pL->getType())
+    if (_pL->nonZeros() != (size_t)_pL->getSize())
     {
-        case InternalType::ScilabInt8 :
-        {
-            return IntAndInt(_pL->getAs<Int8>(), _pOut);
-        }
-        case InternalType::ScilabUInt8 :
-        {
-            return IntAndInt(_pL->getAs<UInt8>(), _pOut);
-        }
-        case InternalType::ScilabInt16 :
-        {
-            return IntAndInt(_pL->getAs<Int16>(), _pOut);
-        }
-        case InternalType::ScilabUInt16 :
-        {
-            return IntAndInt(_pL->getAs<UInt16>(), _pOut);
-        }
-        case InternalType::ScilabInt32 :
-        {
-            return IntAndInt(_pL->getAs<Int32>(), _pOut);
-        }
-        case InternalType::ScilabUInt32 :
-        {
-            return IntAndInt(_pL->getAs<UInt32>(), _pOut);
-        }
-        case InternalType::ScilabInt64 :
-        {
-            return IntAndInt(_pL->getAs<Int64>(), _pOut);
-        }
-        case InternalType::ScilabUInt64 :
-        {
-            return IntAndInt(_pL->getAs<UInt64>(), _pOut);
-        }
-        default:
-        {
-            return 3;
-        }
+        *_pOut = new Bool(0);
+        return;
     }
+
+    *_pOut = NULL;
+    return;
 }
 
-int SparseBoolAndSparseBool(InternalType* _pL, Bool** _pOut)
+template<>
+void isValueFalse(SparseBool* _pL, Bool** _pOut)
 {
-    SparseBool* pL = _pL->getAs<SparseBool>();
-    if (pL->nbTrue() != (size_t)pL->getSize())
+    if (_pL->nbTrue() != (size_t)_pL->getSize())
     {
         *_pOut = new Bool(0);
-        return 0;
+        return;
     }
 
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
+// &
+InternalType* GenericLogicalAnd(InternalType* _pL, InternalType* _pR)
+{
+    InternalType *pResult = NULL;
+
+    and_function bit_and = pAndfunction[_pL->getId()][_pR->getId()];
+    if (bit_and)
+    {
+        pResult = bit_and(_pL, _pR);
+        if (pResult)
+        {
+            return pResult;
+        }
+    }
+
+    /*
+    ** Default case : Return NULL will Call Overloading.
+    */
+    return NULL;
+}
 
 template<class T, class U, class O>
 InternalType* and_M_M(T *_pL, U *_pR)