Bug #10379 fixed - lines did not manage a 1x2 vector [nc, nl] as input argument.
[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-2012 - 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-en.txt
11  *
12  */
13 /*--------------------------------------------------------------------------*/
14 #include "stack-c.h"
15 #include "api_scilab.h"
16 #include "scilines.h"
17 #include "Scierror.h"
18 #include "localization.h"
19 #include "MALLOC.h"
20 #include "gw_console.h"
21 #include "ScilabLinesUpdate.h"
22 #include "scilabmode.h"
23 /*--------------------------------------------------------------------------*/
24 static int sci_lines_no_rhs(char *fname);
25 static int sci_lines_one_rhs(char *fname);
26 static int sci_lines_two_rhs(char *fname);
27 /*--------------------------------------------------------------------------*/
28 int sci_lines(char *fname,unsigned long fname_len)
29 {
30     CheckRhs(0,2);
31     CheckLhs(1,1);
32
33     switch(Rhs)
34     {
35     case 0:
36         sci_lines_no_rhs(fname);
37         break;
38     case 1:
39         sci_lines_one_rhs(fname);
40         break;
41     case 2:
42         sci_lines_two_rhs(fname);
43         break;
44     }
45     return 0;
46 }
47 /*--------------------------------------------------------------------------*/
48 static int sci_lines_no_rhs(char *fname)
49 {
50     /* ncl = lines() */
51     /* with ncl a 1x2 vector [nc , nl] */
52     /* for compatibility BUT order should be [nl, nc] */
53     /* input/output not coherents */
54     SciErr sciErr;
55     double returnedDouble[2];
56     int n1 = 0,m1 = 0;
57
58     returnedDouble[0] = (double)getColumnsSize();
59     returnedDouble[1] = (double)getLinesSize();
60
61     n1 = 1; 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)
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
86     int isScalarInput = 0;
87
88     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
89     if(sciErr.iErr)
90     {
91         printError(&sciErr, 0);
92         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
93         return 0;
94     }
95
96     /* compatibility with previous version manages int32 and double */
97     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
98     {
99         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
100         return 0;
101     }
102
103     isScalarInput = isScalar(pvApiCtx, piAddressVarOne);
104
105     if (!isScalarInput && !checkVarDimension(pvApiCtx, piAddressVarOne, 1, 2))
106     {
107         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
108         return 0;
109     }
110
111     if (isScalarInput)
112     {
113         int iParam1 = 0;
114         if (isIntegerType(pvApiCtx, piAddressVarOne))
115         {
116             if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
117             {
118                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
119                 return 0;
120             }
121         }
122         else // double
123         {
124             double dParam1 = 0.;
125             if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
126             {
127                 iParam1 = (int)dParam1;
128                 if (dParam1 != (double)iParam1)
129                 {
130                     Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
131                     return 0;
132                 }
133             }
134             else
135             {
136                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
137                 return 0;
138             }
139         }
140
141         if (iParam1 == -1)
142         {
143             scilinesdefault();
144             if (getScilabMode() == SCILAB_STD)
145             {
146                 ScilabLinesUpdate();
147             }
148         }
149         else
150         {
151             if (iParam1 < 0)
152             {
153                 Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
154                 return 0;
155             }
156             else
157             {
158                 setLinesSize(iParam1);
159             }
160         }
161     }
162     else
163     {
164         int iLinesValues[2];
165
166         if (isIntegerType(pvApiCtx, piAddressVarOne))
167         {
168             int *iParams1 = NULL;
169             int m = 0, n = 0;
170             sciErr = getMatrixOfInteger32(pvApiCtx,piAddressVarOne, &m, &n, &iParams1);
171             if(sciErr.iErr)
172             {
173                 printError(&sciErr, 0);
174                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
175                 return 0;
176             }
177             iLinesValues[0] = iParams1[0];
178             iLinesValues[1] = iParams1[1];
179         }
180         else // double
181         {
182             double *dParams1 = NULL;
183             int m = 0, n = 0;
184
185             sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m, &n, &dParams1);
186             if(sciErr.iErr)
187             {
188                 printError(&sciErr, 0);
189                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
190                 return 0;
191             }
192
193             iLinesValues[0] = (int)dParams1[0];
194             iLinesValues[1] = (int)dParams1[1];
195
196             if ((dParams1[0] != (double)iLinesValues[0]) ||
197                 (dParams1[1] != (double)iLinesValues[1]))
198             {
199                 Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
200                 return 0;
201             }
202         }
203
204         if ((iLinesValues[0] < 0) || (iLinesValues[1] < 0))
205         {
206             Scierror(999,_("%s: Wrong value for input argument #%d.\n"), fname, 1);
207             return 0;
208         }
209
210         scilines(iLinesValues[1], iLinesValues[0]);
211     }
212
213     LhsVar(1) = 0;
214     PutLhsVar();
215     return 0;
216 }
217 /*--------------------------------------------------------------------------*/
218 static int sci_lines_two_rhs(char *fname)
219 {
220     /* lines (nl, nc) */
221     SciErr sciErr;
222     int *piAddressVarOne = NULL;
223     int *piAddressVarTwo = NULL;
224
225     int iParam1 = 0;
226     int iParam2 = 0;
227
228     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
229     if(sciErr.iErr)
230     {
231         printError(&sciErr, 0);
232         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
233         return 0;
234     }
235
236     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
237     if(sciErr.iErr)
238     {
239         printError(&sciErr, 0);
240         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
241         return 0;
242     }
243
244     /* compatibility with previous version manages int32 and double */
245     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
246     {
247         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
248         return 0;
249     }
250
251     if (!(isDoubleType(pvApiCtx, piAddressVarTwo) || isIntegerType(pvApiCtx, piAddressVarTwo)))
252     {
253         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
254         return 0;
255     }
256
257     if (!isScalar(pvApiCtx, piAddressVarOne))
258     {
259         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
260         return 0;
261     }
262
263     if (!isScalar(pvApiCtx, piAddressVarTwo))
264     {
265         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 2);
266         return 0;
267     }
268
269     if (isIntegerType(pvApiCtx, piAddressVarOne))
270     {
271         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
272         {
273             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
274             return 0;
275         }
276     }
277     else // double
278     {
279         double dParam1 = 0.;
280         if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
281         {
282             iParam1 = (int)dParam1;
283         }
284     }
285
286     if (isIntegerType(pvApiCtx, piAddressVarTwo))
287     {
288         if (getScalarInteger32(pvApiCtx, piAddressVarTwo, &iParam2) != 0)
289         {
290             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
291             return 0;
292         }
293     }
294     else // double
295     {
296         double dParam2 = 0.;
297         if (getScalarDouble(pvApiCtx,piAddressVarTwo, &dParam2) == 0)
298         {
299             iParam2 = (int)dParam2;
300         }
301     }
302
303
304     if (iParam1 == -1)
305     {
306         scilinesdefault();
307         if (getScilabMode() == SCILAB_STD)
308         {
309             ScilabLinesUpdate();
310         }
311     }
312     else
313     {
314         if (iParam1 < 0)
315         {
316             Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
317             return 0;
318         }
319         else
320         {
321             setLinesSize(iParam1);
322         }
323     }
324
325     if (iParam2 > 0)
326     {
327         setColumnsSize(iParam2);
328     }
329     else
330     {
331         Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 2);
332         return 0;
333     }
334
335     LhsVar(1) = 0;
336     PutLhsVar();
337     return 0;
338 }
339 /*--------------------------------------------------------------------------*/