Scicos src: fix sublist and substruct reading in vec2var
[scilab.git] / scilab / modules / console / sci_gateway / c / sci_lines.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Allan CORNET
4  * Copyright (C) 2011 - DIGITEO - Allan CORNET
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13 /*--------------------------------------------------------------------------*/
14 #include "api_scilab.h"
15 #include "scilines.h"
16 #include "Scierror.h"
17 #include "localization.h"
18 #include "MALLOC.h"
19 #include "gw_console.h"
20 #include "ScilabLinesUpdate.h"
21 #include "configvariable_interface.h"
22 /*--------------------------------------------------------------------------*/
23 static int sci_lines_no_rhs(char *fname, void* pvApiCtx);
24 static int sci_lines_one_rhs(char *fname, void* pvApiCtx);
25 static int sci_lines_two_rhs(char *fname, void* pvApiCtx);
26 /*--------------------------------------------------------------------------*/
27 int sci_lines(char *fname, void* pvApiCtx)
28 {
29     CheckRhs(0, 2);
30     CheckLhs(1, 1);
31
32     switch (Rhs)
33     {
34         case 0:
35             sci_lines_no_rhs(fname, pvApiCtx);
36             break;
37         case 1:
38             sci_lines_one_rhs(fname, pvApiCtx);
39             break;
40         case 2:
41             sci_lines_two_rhs(fname, pvApiCtx);
42             break;
43     }
44     return 0;
45 }
46 /*--------------------------------------------------------------------------*/
47 static int sci_lines_no_rhs(char *fname, void* pvApiCtx)
48 {
49     /* ncl = lines() */
50     /* with ncl a 1x2 vector [nc , nl] */
51     /* for compatibility BUT order should be [nl, nc] */
52     /* input/output not coherents */
53     SciErr sciErr;
54     double returnedDouble[2];
55     int n1 = 0, m1 = 0;
56
57     returnedDouble[0] = (double)getColumnsSize();
58     returnedDouble[1] = (double)getLinesSize();
59
60     n1 = 1;
61     m1 = 2;
62     sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, n1, m1, returnedDouble);
63
64     if (sciErr.iErr)
65     {
66         printError(&sciErr, 0);
67         Scierror(999, _("%s: Memory allocation error.\n"), fname);
68         return 0;
69     }
70
71     LhsVar(1) = Rhs + 1;
72     PutLhsVar();
73
74     return 0;
75 }
76 /*--------------------------------------------------------------------------*/
77 static int sci_lines_one_rhs(char *fname, void* pvApiCtx)
78 {
79     /* lines(nb_lines) */
80     /* nb_lines == -1 auto */
81     /* nb_lines == 0 no stop on display */
82     /* nb_lines > 0 set value */
83     SciErr sciErr;
84     int *piAddressVarOne = NULL;
85     int iParam1 = 0;
86
87     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
88     if (sciErr.iErr)
89     {
90         printError(&sciErr, 0);
91         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
92         return 0;
93     }
94
95     /* compatibility with previous version manages int32 and double */
96     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
97     {
98         Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
99         return 0;
100     }
101
102     if (!isScalar(pvApiCtx, piAddressVarOne))
103     {
104         Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
105         return 0;
106     }
107
108     if (isIntegerType(pvApiCtx, piAddressVarOne))
109     {
110         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
111         {
112             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
113             return 0;
114         }
115     }
116     else // double
117     {
118         double dParam1 = 0.;
119         if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
120         {
121             iParam1 = (int)dParam1;
122         }
123     }
124
125     if (iParam1 == -1)
126     {
127         scilinesdefault();
128         if (getScilabMode() == SCILAB_STD)
129         {
130             ScilabLinesUpdate();
131         }
132     }
133     else
134     {
135         if (iParam1 < 0)
136         {
137             Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
138             return 0;
139         }
140         else
141         {
142             setLinesSize(iParam1);
143         }
144     }
145
146     LhsVar(1) = 0;
147     PutLhsVar();
148     return 0;
149 }
150 /*--------------------------------------------------------------------------*/
151 static int sci_lines_two_rhs(char *fname, void* pvApiCtx)
152 {
153     /* lines (nl, nc) */
154     SciErr sciErr;
155     int *piAddressVarOne = NULL;
156     int *piAddressVarTwo = NULL;
157
158     int iParam1 = 0;
159     int iParam2 = 0;
160
161     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
162     if (sciErr.iErr)
163     {
164         printError(&sciErr, 0);
165         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
166         return 0;
167     }
168
169     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
170     if (sciErr.iErr)
171     {
172         printError(&sciErr, 0);
173         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
174         return 0;
175     }
176
177     /* compatibility with previous version manages int32 and double */
178     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
179     {
180         Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
181         return 0;
182     }
183
184     if (!(isDoubleType(pvApiCtx, piAddressVarTwo) || isIntegerType(pvApiCtx, piAddressVarTwo)))
185     {
186         Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 2);
187         return 0;
188     }
189
190     if (!isScalar(pvApiCtx, piAddressVarOne))
191     {
192         Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
193         return 0;
194     }
195
196     if (!isScalar(pvApiCtx, piAddressVarTwo))
197     {
198         Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 2);
199         return 0;
200     }
201
202     if (isIntegerType(pvApiCtx, piAddressVarOne))
203     {
204         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
205         {
206             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
207             return 0;
208         }
209     }
210     else // double
211     {
212         double dParam1 = 0.;
213         if (getScalarDouble(pvApiCtx, piAddressVarOne, &dParam1) == 0)
214         {
215             iParam1 = (int)dParam1;
216         }
217     }
218
219     if (isIntegerType(pvApiCtx, piAddressVarTwo))
220     {
221         if (getScalarInteger32(pvApiCtx, piAddressVarTwo, &iParam2) != 0)
222         {
223             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 2);
224             return 0;
225         }
226     }
227     else // double
228     {
229         double dParam2 = 0.;
230         if (getScalarDouble(pvApiCtx, piAddressVarTwo, &dParam2) == 0)
231         {
232             iParam2 = (int)dParam2;
233         }
234     }
235
236
237     if (iParam1 == -1)
238     {
239         scilinesdefault();
240         if (getScilabMode() == SCILAB_STD)
241         {
242             ScilabLinesUpdate();
243         }
244     }
245     else
246     {
247         if (iParam1 < 0)
248         {
249             Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 1);
250             return 0;
251         }
252         else
253         {
254             setLinesSize(iParam1);
255         }
256     }
257
258     if (iParam2 > 0)
259     {
260         setColumnsSize(iParam2);
261     }
262     else
263     {
264         Scierror(999, _("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"), fname, 2);
265         return 0;
266     }
267
268     LhsVar(1) = 0;
269     PutLhsVar();
270     return 0;
271 }
272 /*--------------------------------------------------------------------------*/