Scicos src: fix sublist and substruct reading in vec2var
[scilab.git] / scilab / modules / console / sci_gateway / c / sci_lines.c
index e7f86ef..73a131c 100644 (file)
@@ -1,17 +1,16 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2007 - INRIA - Allan CORNET 
- * Copyright (C) 2011 - DIGITEO - Allan CORNET 
- * 
+ * Copyright (C) 2007 - INRIA - 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
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */
 /*--------------------------------------------------------------------------*/
-#include "stack-c.h"
 #include "api_scilab.h"
 #include "scilines.h"
 #include "Scierror.h"
 #include "MALLOC.h"
 #include "gw_console.h"
 #include "ScilabLinesUpdate.h"
-#include "sci_mode.h"
+#include "configvariable_interface.h"
 /*--------------------------------------------------------------------------*/
-static int sci_lines_no_rhs(char *fname, int *_piKey);
-static int sci_lines_one_rhs(char *fname, int *_piKey);
-static int sci_lines_two_rhs(char *fname, int *_piKey);
+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, int *_piKey)
+int sci_lines(char *fname, void* pvApiCtx)
 {
-    CheckRhs(0,2);
-    CheckLhs(1,1);
+    CheckRhs(0, 2);
+    CheckLhs(1, 1);
 
-    switch(Rhs)
+    switch (Rhs)
     {
-    case 0:
-        sci_lines_no_rhs(fname, _piKey);
-        break;
-    case 1:
-        sci_lines_one_rhs(fname, _piKey);
-        break;
-    case 2:
-        sci_lines_two_rhs(fname, _piKey);
-        break;
+        case 0:
+            sci_lines_no_rhs(fname, pvApiCtx);
+            break;
+        case 1:
+            sci_lines_one_rhs(fname, pvApiCtx);
+            break;
+        case 2:
+            sci_lines_two_rhs(fname, pvApiCtx);
+            break;
     }
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_no_rhs(char *fname, int *_piKey)
+static int sci_lines_no_rhs(char *fname, void* pvApiCtx)
 {
     /* ncl = lines() */
     /* with ncl a 1x2 vector [nc , nl] */
@@ -53,17 +52,19 @@ static int sci_lines_no_rhs(char *fname, int *_piKey)
     /* input/output not coherents */
     SciErr sciErr;
     double returnedDouble[2];
-    int n1 = 0,m1 = 0;
+    int n1 = 0, m1 = 0;
 
     returnedDouble[0] = (double)getColumnsSize();
     returnedDouble[1] = (double)getLinesSize();
 
-    n1 = 1; m1 = 2;
-    sciErr = createMatrixOfDouble(_piKey, Rhs + 1, n1, m1, returnedDouble);
+    n1 = 1;
+    m1 = 2;
+    sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, n1, m1, returnedDouble);
 
     if (sciErr.iErr)
     {
         printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
         return 0;
     }
 
@@ -73,7 +74,7 @@ static int sci_lines_no_rhs(char *fname, int *_piKey)
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_one_rhs(char *fname, int *_piKey)
+static int sci_lines_one_rhs(char *fname, void* pvApiCtx)
 {
     /* lines(nb_lines) */
     /* nb_lines == -1 auto */
@@ -83,38 +84,39 @@ static int sci_lines_one_rhs(char *fname, int *_piKey)
     int *piAddressVarOne = NULL;
     int iParam1 = 0;
 
-    sciErr = getVarAddressFromPosition(_piKey, 1, &piAddressVarOne);
-    if(sciErr.iErr)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
+        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
         return 0;
     }
 
     /* compatibility with previous version manages int32 and double */
-    if (!(isDoubleType(_piKey, piAddressVarOne) || isIntegerType(_piKey, piAddressVarOne)))
+    if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
         return 0;
     }
 
-    if (!isScalar(_piKey, piAddressVarOne))
+    if (!isScalar(pvApiCtx, piAddressVarOne))
     {
-        Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
         return 0;
     }
 
-    if (isIntegerType(_piKey, piAddressVarOne))
+    if (isIntegerType(pvApiCtx, piAddressVarOne))
     {
-        if (getScalarInteger32(_piKey, piAddressVarOne, &iParam1) != 0)
+        if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
         {
-            Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
             return 0;
         }
     }
     else // double
     {
         double dParam1 = 0.;
-        if (getScalarDouble(_piKey,piAddressVarOne, &dParam1) == 0)
+        if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
         {
             iParam1 = (int)dParam1;
         }
@@ -132,7 +134,7 @@ static int sci_lines_one_rhs(char *fname, int *_piKey)
     {
         if (iParam1 < 0)
         {
-            Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
             return 0;
         }
         else
@@ -146,7 +148,7 @@ static int sci_lines_one_rhs(char *fname, int *_piKey)
     return 0;
 }
 /*--------------------------------------------------------------------------*/
-static int sci_lines_two_rhs(char *fname, int *_piKey)
+static int sci_lines_two_rhs(char *fname, void* pvApiCtx)
 {
     /* lines (nl, nc) */
     SciErr sciErr;
@@ -156,74 +158,76 @@ static int sci_lines_two_rhs(char *fname, int *_piKey)
     int iParam1 = 0;
     int iParam2 = 0;
 
-    sciErr = getVarAddressFromPosition(_piKey, 2, &piAddressVarTwo);
-    if(sciErr.iErr)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
+        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
         return 0;
     }
 
-    sciErr = getVarAddressFromPosition(_piKey, 1, &piAddressVarOne);
-    if(sciErr.iErr)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
+        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
         return 0;
     }
 
     /* compatibility with previous version manages int32 and double */
-    if (!(isDoubleType(_piKey, piAddressVarOne) || isIntegerType(_piKey, piAddressVarOne)))
+    if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
         return 0;
     }
 
-    if (!(isDoubleType(_piKey, piAddressVarTwo) || isIntegerType(_piKey, piAddressVarTwo)))
+    if (!(isDoubleType(pvApiCtx, piAddressVarTwo) || isIntegerType(pvApiCtx, piAddressVarTwo)))
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 2);
         return 0;
     }
 
-    if (!isScalar(_piKey, piAddressVarOne))
+    if (!isScalar(pvApiCtx, piAddressVarOne))
     {
-        Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
         return 0;
     }
 
-    if (!isScalar(_piKey, piAddressVarTwo))
+    if (!isScalar(pvApiCtx, piAddressVarTwo))
     {
-        Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 2);
         return 0;
     }
 
-    if (isIntegerType(_piKey, piAddressVarOne))
+    if (isIntegerType(pvApiCtx, piAddressVarOne))
     {
-        if (getScalarInteger32(_piKey, piAddressVarOne, &iParam1) != 0)
+        if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
         {
-            Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
             return 0;
         }
     }
     else // double
     {
         double dParam1 = 0.;
-        if (getScalarDouble(_piKey,piAddressVarOne, &dParam1) == 0)
+        if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
         {
             iParam1 = (int)dParam1;
         }
     }
 
-    if (isIntegerType(_piKey, piAddressVarTwo))
+    if (isIntegerType(pvApiCtx, piAddressVarTwo))
     {
-        if (getScalarInteger32(_piKey, piAddressVarTwo, &iParam2) != 0)
+        if (getScalarInteger32(pvApiCtx, piAddressVarTwo, &iParam2) != 0)
         {
-            Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 2);
             return 0;
         }
     }
     else // double
     {
         double dParam2 = 0.;
-        if (getScalarDouble(_piKey,piAddressVarTwo, &dParam2) == 0)
+        if (getScalarDouble(pvApiCtx, piAddressVarTwo, &dParam2) == 0)
         {
             iParam2 = (int)dParam2;
         }
@@ -242,7 +246,7 @@ static int sci_lines_two_rhs(char *fname, int *_piKey)
     {
         if (iParam1 < 0)
         {
-            Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
             return 0;
         }
         else
@@ -257,7 +261,7 @@ static int sci_lines_two_rhs(char *fname, int *_piKey)
     }
     else
     {
-        Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 2);
+        Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 2);
         return 0;
     }