remove stack-c.h where it is no more required
[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 "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 "scilabmode.h"
22 /*--------------------------------------------------------------------------*/
23 static int sci_lines_no_rhs(char *fname);
24 static int sci_lines_one_rhs(char *fname);
25 static int sci_lines_two_rhs(char *fname);
26 /*--------------------------------------------------------------------------*/
27 int sci_lines(char *fname,unsigned long fname_len)
28 {
29     CheckRhs(0,2);
30     CheckLhs(1,1);
31
32     switch(Rhs)
33     {
34     case 0:
35         sci_lines_no_rhs(fname);
36         break;
37     case 1:
38         sci_lines_one_rhs(fname);
39         break;
40     case 2:
41         sci_lines_two_rhs(fname);
42         break;
43     }
44     return 0;
45 }
46 /*--------------------------------------------------------------------------*/
47 static int sci_lines_no_rhs(char *fname)
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; m1 = 2;
61     sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, n1, m1, returnedDouble);
62
63     if (sciErr.iErr)
64     {
65         printError(&sciErr, 0);
66         Scierror(999,_("%s: Memory allocation error.\n"), fname);
67         return 0;
68     }
69
70     LhsVar(1) = Rhs + 1;
71     PutLhsVar();
72
73     return 0;
74 }
75 /*--------------------------------------------------------------------------*/
76 static int sci_lines_one_rhs(char *fname)
77 {
78     /* lines(nb_lines) */
79     /* nb_lines == -1 auto */
80     /* nb_lines == 0 no stop on display */
81     /* nb_lines > 0 set value */
82     SciErr sciErr;
83     int *piAddressVarOne = NULL;
84
85     int isScalarInput = 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     isScalarInput = isScalar(pvApiCtx, piAddressVarOne);
103
104     if (!isScalarInput && !checkVarDimension(pvApiCtx, piAddressVarOne, 1, 2))
105     {
106         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
107         return 0;
108     }
109
110     if (isScalarInput)
111     {
112         int iParam1 = 0;
113         if (isIntegerType(pvApiCtx, piAddressVarOne))
114         {
115             if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
116             {
117                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
118                 return 0;
119             }
120         }
121         else // double
122         {
123             double dParam1 = 0.;
124             if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
125             {
126                 iParam1 = (int)dParam1;
127                 if (dParam1 != (double)iParam1)
128                 {
129                     Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
130                     return 0;
131                 }
132             }
133             else
134             {
135                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
136                 return 0;
137             }
138         }
139
140         if (iParam1 == -1)
141         {
142             scilinesdefault();
143             if (getScilabMode() == SCILAB_STD)
144             {
145                 ScilabLinesUpdate();
146             }
147         }
148         else
149         {
150             if (iParam1 < 0)
151             {
152                 Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
153                 return 0;
154             }
155             else
156             {
157                 setLinesSize(iParam1);
158             }
159         }
160     }
161     else
162     {
163         int iLinesValues[2];
164
165         if (isIntegerType(pvApiCtx, piAddressVarOne))
166         {
167             int *iParams1 = NULL;
168             int m = 0, n = 0;
169             sciErr = getMatrixOfInteger32(pvApiCtx,piAddressVarOne, &m, &n, &iParams1);
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             iLinesValues[0] = iParams1[0];
177             iLinesValues[1] = iParams1[1];
178         }
179         else // double
180         {
181             double *dParams1 = NULL;
182             int m = 0, n = 0;
183
184             sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m, &n, &dParams1);
185             if(sciErr.iErr)
186             {
187                 printError(&sciErr, 0);
188                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
189                 return 0;
190             }
191
192             iLinesValues[0] = (int)dParams1[0];
193             iLinesValues[1] = (int)dParams1[1];
194
195             if ((dParams1[0] != (double)iLinesValues[0]) ||
196                 (dParams1[1] != (double)iLinesValues[1]))
197             {
198                 Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 1);
199                 return 0;
200             }
201         }
202
203         if ((iLinesValues[0] < 0) || (iLinesValues[1] < 0))
204         {
205             Scierror(999,_("%s: Wrong value for input argument #%d.\n"), fname, 1);
206             return 0;
207         }
208
209         scilines(iLinesValues[1], iLinesValues[0]);
210     }
211
212     LhsVar(1) = 0;
213     PutLhsVar();
214     return 0;
215 }
216 /*--------------------------------------------------------------------------*/
217 static int sci_lines_two_rhs(char *fname)
218 {
219     /* lines (nl, nc) */
220     SciErr sciErr;
221     int *piAddressVarOne = NULL;
222     int *piAddressVarTwo = NULL;
223
224     int iParam1 = 0;
225     int iParam2 = 0;
226
227     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
228     if(sciErr.iErr)
229     {
230         printError(&sciErr, 0);
231         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
232         return 0;
233     }
234
235     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
236     if(sciErr.iErr)
237     {
238         printError(&sciErr, 0);
239         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
240         return 0;
241     }
242
243     /* compatibility with previous version manages int32 and double */
244     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
245     {
246         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
247         return 0;
248     }
249
250     if (!(isDoubleType(pvApiCtx, piAddressVarTwo) || isIntegerType(pvApiCtx, piAddressVarTwo)))
251     {
252         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
253         return 0;
254     }
255
256     if (!isScalar(pvApiCtx, piAddressVarOne))
257     {
258         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
259         return 0;
260     }
261
262     if (!isScalar(pvApiCtx, piAddressVarTwo))
263     {
264         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 2);
265         return 0;
266     }
267
268     if (isIntegerType(pvApiCtx, piAddressVarOne))
269     {
270         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
271         {
272             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
273             return 0;
274         }
275     }
276     else // double
277     {
278         double dParam1 = 0.;
279         if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
280         {
281             iParam1 = (int)dParam1;
282         }
283     }
284
285     if (isIntegerType(pvApiCtx, piAddressVarTwo))
286     {
287         if (getScalarInteger32(pvApiCtx, piAddressVarTwo, &iParam2) != 0)
288         {
289             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
290             return 0;
291         }
292     }
293     else // double
294     {
295         double dParam2 = 0.;
296         if (getScalarDouble(pvApiCtx,piAddressVarTwo, &dParam2) == 0)
297         {
298             iParam2 = (int)dParam2;
299         }
300     }
301
302
303     if (iParam1 == -1)
304     {
305         scilinesdefault();
306         if (getScilabMode() == SCILAB_STD)
307         {
308             ScilabLinesUpdate();
309         }
310     }
311     else
312     {
313         if (iParam1 < 0)
314         {
315             Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
316             return 0;
317         }
318         else
319         {
320             setLinesSize(iParam1);
321         }
322     }
323
324     if (iParam2 > 0)
325     {
326         setColumnsSize(iParam2);
327     }
328     else
329     {
330         Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 2);
331         return 0;
332     }
333
334     LhsVar(1) = 0;
335     PutLhsVar();
336     return 0;
337 }
338 /*--------------------------------------------------------------------------*/