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