Merge remote-tracking branch 'refs/remotes/origin/master' into YaSp
[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-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 "sci_mode.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; 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, void* pvApiCtx)
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     int iParam1 = 0;
85
86     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
87     if(sciErr.iErr)
88     {
89         printError(&sciErr, 0);
90         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
91         return 0;
92     }
93
94     /* compatibility with previous version manages int32 and double */
95     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
96     {
97         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
98         return 0;
99     }
100
101     if (!isScalar(pvApiCtx, piAddressVarOne))
102     {
103         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
104         return 0;
105     }
106
107     if (isIntegerType(pvApiCtx, piAddressVarOne))
108     {
109         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
110         {
111             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
112             return 0;
113         }
114     }
115     else // double
116     {
117         double dParam1 = 0.;
118         if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
119         {
120             iParam1 = (int)dParam1;
121         }
122     }
123
124     if (iParam1 == -1)
125     {
126         scilinesdefault();
127         if (getScilabMode() == SCILAB_STD)
128         {
129             ScilabLinesUpdate();
130         }
131     }
132     else
133     {
134         if (iParam1 < 0)
135         {
136             Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
137             return 0;
138         }
139         else
140         {
141             setLinesSize(iParam1);
142         }
143     }
144
145     LhsVar(1) = 0;
146     PutLhsVar();
147     return 0;
148 }
149 /*--------------------------------------------------------------------------*/
150 static int sci_lines_two_rhs(char *fname, void* pvApiCtx)
151 {
152     /* lines (nl, nc) */
153     SciErr sciErr;
154     int *piAddressVarOne = NULL;
155     int *piAddressVarTwo = NULL;
156
157     int iParam1 = 0;
158     int iParam2 = 0;
159
160     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
161     if(sciErr.iErr)
162     {
163         printError(&sciErr, 0);
164         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
165         return 0;
166     }
167
168     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
169     if(sciErr.iErr)
170     {
171         printError(&sciErr, 0);
172         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
173         return 0;
174     }
175
176     /* compatibility with previous version manages int32 and double */
177     if (!(isDoubleType(pvApiCtx, piAddressVarOne) || isIntegerType(pvApiCtx, piAddressVarOne)))
178     {
179         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
180         return 0;
181     }
182
183     if (!(isDoubleType(pvApiCtx, piAddressVarTwo) || isIntegerType(pvApiCtx, piAddressVarTwo)))
184     {
185         Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
186         return 0;
187     }
188
189     if (!isScalar(pvApiCtx, piAddressVarOne))
190     {
191         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);
192         return 0;
193     }
194
195     if (!isScalar(pvApiCtx, piAddressVarTwo))
196     {
197         Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 2);
198         return 0;
199     }
200
201     if (isIntegerType(pvApiCtx, piAddressVarOne))
202     {
203         if (getScalarInteger32(pvApiCtx, piAddressVarOne, &iParam1) != 0)
204         {
205             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 1);
206             return 0;
207         }
208     }
209     else // double
210     {
211         double dParam1 = 0.;
212         if (getScalarDouble(pvApiCtx,piAddressVarOne, &dParam1) == 0)
213         {
214             iParam1 = (int)dParam1;
215         }
216     }
217
218     if (isIntegerType(pvApiCtx, piAddressVarTwo))
219     {
220         if (getScalarInteger32(pvApiCtx, piAddressVarTwo, &iParam2) != 0)
221         {
222             Scierror(999,_("%s: Wrong type for input argument #%d: A scalar expected.\n"),fname, 2);
223             return 0;
224         }
225     }
226     else // double
227     {
228         double dParam2 = 0.;
229         if (getScalarDouble(pvApiCtx,piAddressVarTwo, &dParam2) == 0)
230         {
231             iParam2 = (int)dParam2;
232         }
233     }
234
235
236     if (iParam1 == -1)
237     {
238         scilinesdefault();
239         if (getScilabMode() == SCILAB_STD)
240         {
241             ScilabLinesUpdate();
242         }
243     }
244     else
245     {
246         if (iParam1 < 0)
247         {
248             Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 1);
249             return 0;
250         }
251         else
252         {
253             setLinesSize(iParam1);
254         }
255     }
256
257     if (iParam2 > 0)
258     {
259         setColumnsSize(iParam2);
260     }
261     else
262     {
263         Scierror(999,_("%s: Wrong value for input argument #%d: A scalar (>= 0) expected.\n"),fname, 2);
264         return 0;
265     }
266
267     LhsVar(1) = 0;
268     PutLhsVar();
269     return 0;
270 }
271 /*--------------------------------------------------------------------------*/