bb62226a1e7a4ed77c6d36ba277b1f1e2739ea8e
[scilab.git] / scilab / modules / spreadsheet / sci_gateway / cpp / gw_csv_helpers.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - 2012 - INRIA - Allan CORNET
4  * Copyright (C) 2011 - INRIA - Michael Baudin
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  * This code is also published under the GPL v3 license.
13  *
14  */
15 #include <string.h>
16 #include "api_scilab.h"
17 #include "sci_types.h"
18 #include "Scierror.h"
19 #include "MALLOC.h"
20 #include "localization.h"
21 #include "gw_csv_helpers.h"
22 #ifdef _MSC_VER
23 #include "strdup_windows.h"
24 #endif
25 #include "freeArrayOfString.h"
26 // =============================================================================
27 char *csv_getArgumentAsStringWithEmptyManagement(void* _pvCtx, int _iVar, const char *fname,
28         const char *defaultValue,
29         int *iErr)
30 {
31     SciErr sciErr;
32     char *returnedValue = NULL;
33     int *piAddressVar = NULL;
34     int iType = 0;
35     int m = 0, n = 0;
36
37     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
38     if (sciErr.iErr)
39     {
40         printError(&sciErr, 0);
41         *iErr = sciErr.iErr;
42         return NULL;
43     }
44
45     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
46     if (sciErr.iErr)
47     {
48         printError(&sciErr, 0);
49         *iErr = sciErr.iErr;
50         return NULL;
51     }
52
53     if (iType != sci_strings)
54     {
55         if (isEmptyMatrix(pvApiCtx, piAddressVar))
56         {
57             /* [] equals default value */
58             if (defaultValue)
59             {
60                 *iErr = 0;
61                 returnedValue = strdup(defaultValue);
62             }
63             else
64             {
65                 *iErr = 0;
66                 returnedValue = NULL;
67             }
68         }
69         else
70         {
71             *iErr = API_ERROR_INVALID_TYPE;
72             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, _iVar);
73             return NULL;
74         }
75     }
76     else
77     {
78         *iErr = checkVarDimension(pvApiCtx, piAddressVar, 1, 1);
79
80         if (*iErr == 0 )
81         {
82             *iErr = API_ERROR_CHECK_VAR_DIMENSION;
83             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, _iVar);
84             return NULL;
85         }
86
87         *iErr = getAllocatedSingleString(pvApiCtx, piAddressVar, &returnedValue);
88         if (*iErr)
89         {
90             Scierror(999, _("%s: Memory allocation error.\n"), fname);
91             return NULL;
92         }
93     }
94     return returnedValue;
95 }
96 // =============================================================================
97
98 char *csv_getArgumentAsString(void* _pvCtx, int _iVar,
99                               const char *fname, int *iErr)
100 {
101     SciErr sciErr;
102
103     int *piAddressVar = NULL;
104     int m = 0, n = 0;
105     int iType = 0;
106
107     char *returnedValue = NULL;
108
109     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
110     if (sciErr.iErr)
111     {
112         *iErr = sciErr.iErr;
113         printError(&sciErr, 0);
114         return NULL;
115     }
116
117     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
118     if (sciErr.iErr)
119     {
120         *iErr = sciErr.iErr;
121         printError(&sciErr, 0);
122         return NULL;
123     }
124
125     if (iType != sci_strings)
126     {
127         *iErr = API_ERROR_INVALID_TYPE;
128         Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
129         return NULL;
130     }
131
132     *iErr = checkVarDimension(pvApiCtx, piAddressVar, 1, 1);
133
134     if (*iErr == 0 )
135     {
136         *iErr = API_ERROR_CHECK_VAR_DIMENSION;
137         Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, _iVar);
138         return NULL;
139     }
140
141     *iErr = getAllocatedSingleString(pvApiCtx, piAddressVar, &returnedValue);
142     if (*iErr)
143     {
144         Scierror(999, _("%s: Memory allocation error.\n"), fname);
145         return NULL;
146     }
147     return returnedValue;
148 }
149 // =============================================================================
150 double csv_getArgumentAsScalarDouble(void* _pvCtx, int _iVar,
151                                      const char *fname, int *iErr)
152 {
153     SciErr sciErr;
154     double dValue = 0.;
155     int *piAddressVar = NULL;
156     int m = 0, n = 0;
157     int iType = 0;
158
159     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
160     if (sciErr.iErr)
161     {
162         printError(&sciErr, 0);
163         *iErr = sciErr.iErr;
164         return 0;
165     }
166
167     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
168     if (sciErr.iErr)
169     {
170         printError(&sciErr, 0);
171         *iErr = sciErr.iErr;
172         return 0;
173     }
174
175     if (iType != sci_matrix)
176     {
177         Scierror(999, _("%s: Wrong type for input argument #%d: A double expected.\n"), fname, _iVar);
178         *iErr =  API_ERROR_INVALID_TYPE;
179         return 0;
180     }
181
182     *iErr = checkVarDimension(pvApiCtx, piAddressVar, 1, 1);
183
184     if (*iErr == 0 )
185     {
186         *iErr = API_ERROR_CHECK_VAR_DIMENSION;
187         Scierror(999, _("%s: Wrong size for input argument #%d: A double expected.\n"), fname, _iVar);
188         return 0;
189     }
190
191     *iErr = getScalarDouble(pvApiCtx, piAddressVar, &dValue);
192     return dValue;
193 }
194 // =============================================================================
195 int csv_getArgumentAsScalarBoolean(void* _pvCtx, int _iVar,
196                                    const char *fname, int *iErr)
197 {
198     SciErr sciErr;
199     int bValue = 0;
200     int *piAddressVar = NULL;
201     int m = 0, n = 0;
202     int iType = 0;
203
204     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
205     if (sciErr.iErr)
206     {
207         printError(&sciErr, 0);
208         *iErr = sciErr.iErr;
209         return 0;
210     }
211
212     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
213     if (sciErr.iErr)
214     {
215         printError(&sciErr, 0);
216         *iErr = sciErr.iErr;
217         return 0;
218     }
219
220     if (iType != sci_boolean)
221     {
222         Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, _iVar);
223         *iErr =  API_ERROR_INVALID_TYPE;
224         return 0;
225     }
226
227     *iErr = checkVarDimension(pvApiCtx, piAddressVar, 1, 1);
228
229     if (*iErr == 0 )
230     {
231         *iErr = API_ERROR_CHECK_VAR_DIMENSION;
232         Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, _iVar);
233         return 0;
234     }
235
236     *iErr = getScalarBoolean(pvApiCtx, piAddressVar, &bValue);
237     return bValue;
238 }
239 // =============================================================================
240 char **csv_getArgumentAsMatrixOfString(void* _pvCtx, int _iVar,
241                                        const char *fname,
242                                        int *m, int *n, int *iErr)
243 {
244     SciErr sciErr;
245     char **pStringValues = NULL;
246     int *piAddressVar = NULL;
247     int m_ = 0, n_ = 0;
248     int iType = 0;
249     int *lengthStringValues = NULL;
250     int i = 0;
251
252     *m = 0;
253     *n = 0;
254
255     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
256     if (sciErr.iErr)
257     {
258         *iErr = sciErr.iErr;
259         printError(&sciErr, 0);
260         return NULL;
261     }
262
263     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
264     if (sciErr.iErr)
265     {
266         *iErr = sciErr.iErr;
267         printError(&sciErr, 0);
268         return NULL;
269     }
270
271     if (iType != sci_strings)
272     {
273         *iErr =  API_ERROR_INVALID_TYPE;
274         Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, _iVar);
275         return NULL;
276     }
277
278     *iErr = getAllocatedMatrixOfString(pvApiCtx, piAddressVar, &m_, &n_, &pStringValues);
279     if (*iErr != 0)
280     {
281         return NULL;
282     }
283
284     *iErr = 0;
285     *m = m_;
286     *n = n_;
287
288     return pStringValues;
289 }
290 // =============================================================================
291 int csv_isRowVector(void* _pvCtx, int _iVar)
292 {
293     SciErr sciErr;
294     int *piAddressVar = NULL;
295     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
296     if (sciErr.iErr) return 0;
297     return isRowVector(pvApiCtx, piAddressVar);
298 }
299 // =============================================================================
300 int csv_isColumnVector(void* _pvCtx, int _iVar)
301 {
302     SciErr sciErr;
303     int *piAddressVar = NULL;
304     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
305     if (sciErr.iErr) return 0;
306     return isColumnVector(pvApiCtx, piAddressVar);
307 }
308 // =============================================================================
309 int csv_isScalar(void* _pvCtx, int _iVar)
310 {
311     SciErr sciErr;
312     int *piAddressVar = NULL;
313     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
314     if (sciErr.iErr) return 0;
315     return isScalar(pvApiCtx, piAddressVar);
316 }
317 // =============================================================================
318 int csv_isDoubleScalar(void* _pvCtx, int _iVar)
319 {
320     SciErr sciErr;
321     int *piAddressVar = NULL;
322
323     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
324     if (sciErr.iErr) return 0;
325
326     if (csv_isScalar(_pvCtx, _iVar))
327     {
328         int iType = 0;
329         sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
330         if (sciErr.iErr) return 0;
331
332         if (isVarComplex(pvApiCtx, piAddressVar) == 0)
333         {
334             return (iType == sci_matrix);
335         }
336     }
337     return 0;
338 }
339 // =============================================================================
340 int csv_isEmpty(void* _pvCtx, int _iVar)
341 {
342     SciErr sciErr;
343     int *piAddressVar = NULL;
344
345     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
346     if (sciErr.iErr)
347     {
348         printError(&sciErr, 0);
349         if (sciErr.iErr) return 0;
350     }
351
352     return isEmptyMatrix(pvApiCtx, piAddressVar);
353 }
354 // =============================================================================
355 int *csv_getArgumentAsMatrixofIntFromDouble(void* _pvCtx, int _iVar,
356         const char *fname,
357         int *m, int *n, int *iErr)
358 {
359     int *iReturnedArray = NULL;
360     double *dArray = NULL;
361     SciErr sciErr;
362     int *piAddressVar = NULL;
363     int iType = 0;
364     int m_ = 0;
365     int n_ = 0;
366     int i = 0;
367     int j = 0;
368
369     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddressVar);
370     if (sciErr.iErr)
371     {
372         *iErr = sciErr.iErr;
373         printError(&sciErr, 0);
374         return NULL;
375     }
376
377     sciErr = getVarType(pvApiCtx, piAddressVar, &iType);
378     if (sciErr.iErr)
379     {
380         *iErr = sciErr.iErr;
381         printError(&sciErr, 0);
382         return NULL;
383     }
384
385     if (iType != sci_matrix)
386     {
387         *iErr =  API_ERROR_INVALID_TYPE;
388         Scierror(999, _("%s: Wrong type for input argument #%d: A matrix of double expected.\n"), fname, _iVar);
389         return NULL;
390     }
391
392     sciErr = getMatrixOfDouble(pvApiCtx, piAddressVar, &m_, &n_, &dArray);
393     if (sciErr.iErr)
394     {
395         *iErr = sciErr.iErr;
396         printError(&sciErr, 0);
397         return NULL;
398     }
399
400     for (j = 0; j < m_ * n_; j++)
401     {
402         int iVal = (int)dArray[j];
403         if ((double)iVal != dArray[j])
404         {
405             *iErr = API_ERROR_GET_DOUBLE;
406             Scierror(999, _("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), fname, _iVar);
407             return NULL;
408         }
409     }
410
411     iReturnedArray = (int*)MALLOC(sizeof(int) * (m_ * n_));
412     if (iReturnedArray == NULL)
413     {
414         *iErr = API_ERROR_ALLOC_DOUBLE;
415         Scierror(999, _("%s: Memory allocation error.\n"), fname);
416         return NULL;
417     }
418
419     for (j = 0; j < m_ * n_; j++)
420     {
421         iReturnedArray[j] = (int)dArray[j];
422     }
423
424     *iErr = 0;
425     *m = m_;
426     *n = n_;
427
428     return iReturnedArray;
429 }
430 // =============================================================================