Scicos src: fix sublist and substruct reading in vec2var
[scilab.git] / scilab / modules / console / sci_gateway / c / sci_lines.c
index f4f8f21..73a131c 100644 (file)
@@ -1,13 +1,13 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2007 - INRIA - Allan CORNET
- * Copyright (C) 2011-2012 - DIGITEO - Allan CORNET
+ * Copyright (C) 2011 - DIGITEO - Allan CORNET
  *
  * 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
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */
 /*--------------------------------------------------------------------------*/
 #include "MALLOC.h"
 #include "gw_console.h"
 #include "ScilabLinesUpdate.h"
-#include "scilabmode.h"
+#include "configvariable_interface.h"
 /*--------------------------------------------------------------------------*/
-static int sci_lines_no_rhs(char *fname);
-static int sci_lines_one_rhs(char *fname);
-static int sci_lines_two_rhs(char *fname);
+static int sci_lines_no_rhs(char *fname, void* pvApiCtx);
+static int sci_lines_one_rhs(char *fname, void* pvApiCtx);
+static int sci_lines_two_rhs(char *fname, void* pvApiCtx);
 /*--------------------------------------------------------------------------*/
-int sci_lines(char *fname, unsigned long fname_len)
+int sci_lines(char *fname, void* pvApiCtx)
 {
     CheckRhs(0, 2);
     CheckLhs(1, 1);
@@ -32,19 +32,19 @@ int sci_lines(char *fname, unsigned long fname_len)
     switch (Rhs)
     {
         case 0:
-            sci_lines_no_rhs(fname);
+            sci_lines_no_rhs(fname, pvApiCtx);
             break;
         case 1:
-            sci_lines_one_rhs(fname);
+            sci_lines_one_rhs(fname, pvApiCtx);
             break;
         case 2:
-            sci_lines_two_rhs(fname);
+            sci_lines_two_rhs(fname, pvApiCtx);
             break;
     }
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_no_rhs(char *fname)
+static int sci_lines_no_rhs(char *fname, void* pvApiCtx)
 {
     /* ncl = lines() */
     /* with ncl a 1x2 vector [nc , nl] */
@@ -74,7 +74,7 @@ static int sci_lines_no_rhs(char *fname)
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_one_rhs(char *fname)
+static int sci_lines_one_rhs(char *fname, void* pvApiCtx)
 {
     /* lines(nb_lines) */
     /* nb_lines == -1 auto */
@@ -82,8 +82,7 @@ static int sci_lines_one_rhs(char *fname)
     /* nb_lines > 0 set value */
     SciErr sciErr;
     int *piAddressVarOne = NULL;
-
-    int isScalarInput = 0;
+    int iParam1 = 0;
 
     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
     if (sciErr.iErr)
@@ -100,114 +99,48 @@ static int sci_lines_one_rhs(char *fname)
         return 0;
     }
 
-    isScalarInput = isScalar(pvApiCtx, piAddressVarOne);
-
-    if (!isScalarInput && !checkVarDimension(pvApiCtx, piAddressVarOne, 1, 2))
+    if (!isScalar(pvApiCtx, piAddressVarOne))
     {
         Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
         return 0;
     }
 
-    if (isScalarInput)
+    if (isIntegerType(pvApiCtx, piAddressVarOne))
     {
-        int iParam1 = 0;
-        if (isIntegerType(pvApiCtx, piAddressVarOne))
+        if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
         {
-            if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
-            {
-                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
-                return 0;
-            }
+            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
+            return 0;
         }
-        else // double
+    }
+    else // double
+    {
+        double dParam1 = 0.;
+        if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
         {
-            double dParam1 = 0.;
-            if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
-            {
-                iParam1 = (int)dParam1;
-                if (dParam1 != (double)iParam1)
-                {
-                    Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
-                    return 0;
-                }
-            }
-            else
-            {
-                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
-                return 0;
-            }
+            iParam1 = (int)dParam1;
         }
+    }
 
-        if (iParam1 == -1)
-        {
-            scilinesdefault();
-            if (getScilabMode() == SCILAB_STD)
-            {
-                ScilabLinesUpdate();
-            }
-        }
-        else
+    if (iParam1 == -1)
+    {
+        scilinesdefault();
+        if (getScilabMode() == SCILAB_STD)
         {
-            if (iParam1 < 0)
-            {
-                Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
-                return 0;
-            }
-            else
-            {
-                setLinesSize(iParam1);
-            }
+            ScilabLinesUpdate();
         }
     }
     else
     {
-        int iLinesValues[2];
-
-        if (isIntegerType(pvApiCtx, piAddressVarOne))
-        {
-            int *iParams1 = NULL;
-            int m = 0, n = 0;
-            sciErr = getMatrixOfInteger32(pvApiCtx, piAddressVarOne, &m, &n, &iParams1);
-            if (sciErr.iErr)
-            {
-                printError(&sciErr, 0);
-                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
-                return 0;
-            }
-            iLinesValues[0] = iParams1[0];
-            iLinesValues[1] = iParams1[1];
-        }
-        else // double
+        if (iParam1 < 0)
         {
-            double *dParams1 = NULL;
-            int m = 0, n = 0;
-
-            sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m, &n, &dParams1);
-            if (sciErr.iErr)
-            {
-                printError(&sciErr, 0);
-                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
-                return 0;
-            }
-
-            iLinesValues[0] = (int)dParams1[0];
-            iLinesValues[1] = (int)dParams1[1];
-
-            if ((dParams1[0] != (double)iLinesValues[0]) ||
-                    (dParams1[1] != (double)iLinesValues[1]))
-            {
-                Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
-                return 0;
-            }
+            Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
+            return 0;
         }
-
-        if ((iLinesValues[0] < 0) || (iLinesValues[1] < 0))
+        else
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d.\n"), fname, 1);
-            return 0;
+            setLinesSize(iParam1);
         }
-
-        scilines(iLinesValues[1], iLinesValues[0]);
     }
 
     LhsVar(1) = 0;
@@ -215,7 +148,7 @@ static int sci_lines_one_rhs(char *fname)
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_two_rhs(char *fname)
+static int sci_lines_two_rhs(char *fname, void* pvApiCtx)
 {
     /* lines (nl, nc) */
     SciErr sciErr;