Coverity #1099017 fixed
[scilab.git] / scilab / modules / javasci / src / c / javasci2_helper.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Sylvestre LEDRU
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15 #include <stdlib.h>
16 #include <string.h>
17
18 #define ENABLE_HELPERS
19 #include "javasci2_helper.h"
20 #include "api_scilab.h"
21 #include "lasterror.h"
22
23 BOOL isComplexVar(char *variableName)
24 {
25     /* 0 = not complex */
26     return isNamedVarComplex(NULL, variableName) != 0;
27 }
28
29 sci_int_types getIntegerPrecision(char *variableName)
30 {
31     SciErr sciErr;
32     int iPrec;
33
34     sciErr = getNamedMatrixOfIntegerPrecision(NULL, variableName, &iPrec);
35     if (sciErr.iErr)
36     {
37         printError(&sciErr, 0);
38         return sciErr.iErr;
39     }
40     return iPrec;
41 }
42
43 double *getDouble(char *variableName, int *nbRow, int *nbCol)
44 {
45     SciErr sciErr;
46     double *matrixOfDouble = NULL;
47
48     sciErr = readNamedMatrixOfDouble(NULL, variableName, nbRow, nbCol, NULL);
49     if (sciErr.iErr)
50     {
51         printError(&sciErr, 0);
52     }
53
54     /* Alloc the memory */
55     matrixOfDouble = (double *)malloc(((*nbRow) * (*nbCol)) * sizeof(double));
56
57     /* Load the matrix */
58     sciErr = readNamedMatrixOfDouble(NULL, variableName, nbRow, nbCol, matrixOfDouble);
59     if (sciErr.iErr)
60     {
61         printError(&sciErr, 0);
62     }
63
64     return matrixOfDouble;
65
66 }
67
68 int putDouble(char *variableName, double *variable, int nbRow, int nbCol)
69 {
70     SciErr sciErr;
71
72     sciErr = createNamedMatrixOfDouble(NULL, variableName, nbRow, nbCol, variable);
73     if (sciErr.iErr)
74     {
75         printError(&sciErr, 0);
76         return -1;
77     }
78     return 0;
79 }
80
81 double *getDoubleComplexReal(char *variableName, int *nbRow, int *nbCol)
82 {
83     SciErr sciErr;
84     double *matrixOfDoubleComplexReal = NULL;
85     double *matrixOfDoubleComplexImg = NULL;
86
87     sciErr = readNamedComplexMatrixOfDouble(NULL, variableName, nbRow, nbCol, NULL, NULL);
88     if (sciErr.iErr)
89     {
90         printError(&sciErr, 0);
91     }
92
93     /* Alloc the memory */
94     matrixOfDoubleComplexReal = (double *)malloc(((*nbRow) * (*nbCol)) * sizeof(double));
95     matrixOfDoubleComplexImg = (double *)malloc(((*nbRow) * (*nbCol)) * sizeof(double));
96
97     /* Load the matrix */
98     sciErr = readNamedComplexMatrixOfDouble(NULL, variableName, nbRow, nbCol, matrixOfDoubleComplexReal, matrixOfDoubleComplexImg);
99     if (sciErr.iErr)
100     {
101         printError(&sciErr, 0);
102     }
103
104     return matrixOfDoubleComplexReal;
105 }
106
107 double *getDoubleComplexImg(char *variableName, int *nbRow, int *nbCol)
108 {
109     SciErr sciErr;
110     double *matrixOfDoubleComplexReal = NULL;
111     double *matrixOfDoubleComplexImg = NULL;
112
113     sciErr = readNamedComplexMatrixOfDouble(NULL, variableName, nbRow, nbCol, NULL, NULL);
114     if (sciErr.iErr)
115     {
116         printError(&sciErr, 0);
117     }
118
119     /* Alloc the memory */
120     matrixOfDoubleComplexReal = (double *)malloc(((*nbRow) * (*nbCol)) * sizeof(double));
121     matrixOfDoubleComplexImg = (double *)malloc(((*nbRow) * (*nbCol)) * sizeof(double));
122
123     /* Load the matrix */
124     sciErr = readNamedComplexMatrixOfDouble(NULL, variableName, nbRow, nbCol, matrixOfDoubleComplexReal, matrixOfDoubleComplexImg);
125     if (sciErr.iErr)
126     {
127         printError(&sciErr, 0);
128     }
129
130     return matrixOfDoubleComplexImg;
131
132 }
133
134 int putDoubleComplex(char* variableName, double *variable, int nbRow, int nbCol, double * imag, int nbRowI, int nbColI)
135 {
136     SciErr sciErr;
137
138     sciErr = createNamedComplexMatrixOfDouble(NULL, variableName, nbRow, nbCol, variable, imag);
139     if (sciErr.iErr)
140     {
141         printError(&sciErr, 0);
142         return -1;
143     }
144     return 0;
145 }
146
147 BOOL *getBoolean(char *variableName, int *nbRow, int *nbCol)
148 {
149     SciErr sciErr;
150     BOOL *matrixOfBoolean = NULL;
151
152     sciErr = readNamedMatrixOfBoolean(NULL, variableName, nbRow, nbCol, NULL);
153     if (sciErr.iErr)
154     {
155         printError(&sciErr, 0);
156     }
157
158     /* Alloc the memory */
159     matrixOfBoolean = (BOOL *) malloc(((*nbRow) * (*nbCol)) * sizeof(BOOL));
160
161     /* Load the matrix */
162     sciErr = readNamedMatrixOfBoolean(NULL, variableName, nbRow, nbCol, matrixOfBoolean);
163
164     if (sciErr.iErr)
165     {
166         printError(&sciErr, 0);
167     }
168
169     return matrixOfBoolean;
170
171 }
172
173 int putBoolean(char *variableName, BOOL * variable, int nbRow, int nbCol)
174 {
175     SciErr sciErr;
176
177     sciErr = createNamedMatrixOfBoolean(NULL, variableName, nbRow, nbCol, variable);
178     if (sciErr.iErr)
179     {
180         printError(&sciErr, 0);
181         return -1;
182     }
183     return 0;
184
185 }
186
187 ///////////////////// byte / int8
188 byte *getByte(char *variableName, int *nbRow, int *nbCol)
189 {
190     SciErr sciErr;
191     byte *matrixOfByte = NULL;
192
193     sciErr = readNamedMatrixOfInteger8(NULL, variableName, nbRow, nbCol, NULL);
194     if (sciErr.iErr)
195     {
196         printError(&sciErr, 0);
197     }
198
199     /* Alloc the memory */
200     matrixOfByte = (byte *) malloc(((*nbRow) * (*nbCol)) * sizeof(byte));
201
202     /* Load the matrix */
203     sciErr = readNamedMatrixOfInteger8(NULL, variableName, nbRow, nbCol, (char *)matrixOfByte);
204     if (sciErr.iErr)
205     {
206         printError(&sciErr, 0);
207     }
208
209     return matrixOfByte;
210
211 }
212
213 int putByte(char *variableName, byte * variable, int nbRow, int nbCol)
214 {
215     SciErr sciErr;
216
217     sciErr = createNamedMatrixOfInteger8(NULL, variableName, nbRow, nbCol, (const char *)variable);
218     if (sciErr.iErr)
219     {
220         printError(&sciErr, 0);
221         return -1;
222     }
223     return 0;
224 }
225
226 byte *getUnsignedByte(char *variableName, int *nbRow, int *nbCol)
227 {
228     SciErr sciErr;
229     byte *matrixOfByte = NULL;
230
231     sciErr = readNamedMatrixOfUnsignedInteger8(NULL, variableName, nbRow, nbCol, NULL);
232     if (sciErr.iErr)
233     {
234         printError(&sciErr, 0);
235     }
236
237     /* Alloc the memory */
238     matrixOfByte = (byte *) malloc(((*nbRow) * (*nbCol)) * sizeof(byte));
239
240     /* Load the matrix */
241     sciErr = readNamedMatrixOfUnsignedInteger8(NULL, variableName, nbRow, nbCol, matrixOfByte);
242     if (sciErr.iErr)
243     {
244         printError(&sciErr, 0);
245     }
246
247     return matrixOfByte;
248
249 }
250
251 int putUnsignedByte(char *variableName, byte * variable, int nbRow, int nbCol)
252 {
253     SciErr sciErr;
254
255     sciErr = createNamedMatrixOfUnsignedInteger8(NULL, variableName, nbRow, nbCol, variable);
256     if (sciErr.iErr)
257     {
258         printError(&sciErr, 0);
259         return -1;
260     }
261     return 0;
262 }
263
264 //////////////////////////// short / int16
265
266 short *getShort(char *variableName, int *nbRow, int *nbCol)
267 {
268     SciErr sciErr;
269     short *matrixOfShort = NULL;
270
271     sciErr = readNamedMatrixOfInteger16(NULL, variableName, nbRow, nbCol, NULL);
272     if (sciErr.iErr)
273     {
274         printError(&sciErr, 0);
275     }
276
277     /* Alloc the memory */
278     matrixOfShort = (short *)malloc(((*nbRow) * (*nbCol)) * sizeof(short));
279
280     /* Load the matrix */
281     sciErr = readNamedMatrixOfInteger16(NULL, variableName, nbRow, nbCol, matrixOfShort);
282     if (sciErr.iErr)
283     {
284         printError(&sciErr, 0);
285     }
286
287     return matrixOfShort;
288
289 }
290
291 int putShort(char *variableName, short *variable, int nbRow, int nbCol)
292 {
293     SciErr sciErr;
294
295     sciErr = createNamedMatrixOfInteger16(NULL, variableName, nbRow, nbCol, variable);
296     if (sciErr.iErr)
297     {
298         printError(&sciErr, 0);
299         return -1;
300     }
301     return 0;
302 }
303
304 unsigned short *getUnsignedShort(char *variableName, int *nbRow, int *nbCol)
305 {
306     SciErr sciErr;
307     unsigned short *matrixOfShort = NULL;
308
309     sciErr = readNamedMatrixOfUnsignedInteger16(NULL, variableName, nbRow, nbCol, NULL);
310     if (sciErr.iErr)
311     {
312         printError(&sciErr, 0);
313     }
314
315     /* Alloc the memory */
316     matrixOfShort = (unsigned short *)malloc(((*nbRow) * (*nbCol)) * sizeof(unsigned short));
317
318     /* Load the matrix */
319     sciErr = readNamedMatrixOfUnsignedInteger16(NULL, variableName, nbRow, nbCol, matrixOfShort);
320     if (sciErr.iErr)
321     {
322         printError(&sciErr, 0);
323     }
324
325     return matrixOfShort;
326
327 }
328
329 int putUnsignedShort(char *variableName, unsigned short *variable, int nbRow, int nbCol)
330 {
331     SciErr sciErr;
332
333     sciErr = createNamedMatrixOfUnsignedInteger16(NULL, variableName, nbRow, nbCol, variable);
334     if (sciErr.iErr)
335     {
336         printError(&sciErr, 0);
337         return -1;
338     }
339     return 0;
340 }
341
342 ////////////////////// int / int32
343
344 int *getInt(char *variableName, int *nbRow, int *nbCol)
345 {
346     SciErr sciErr;
347     int *matrixOfInt = NULL;
348
349     sciErr = readNamedMatrixOfInteger32(NULL, variableName, nbRow, nbCol, NULL);
350     if (sciErr.iErr)
351     {
352         printError(&sciErr, 0);
353     }
354
355     /* Alloc the memory */
356     matrixOfInt = (int *)malloc(((*nbRow) * (*nbCol)) * sizeof(int));
357
358     /* Load the matrix */
359     sciErr = readNamedMatrixOfInteger32(NULL, variableName, nbRow, nbCol, matrixOfInt);
360     if (sciErr.iErr)
361     {
362         printError(&sciErr, 0);
363     }
364
365     return matrixOfInt;
366
367 }
368
369 int putInt(char *variableName, int *variable, int nbRow, int nbCol)
370 {
371     SciErr sciErr;
372
373     sciErr = createNamedMatrixOfInteger32(NULL, variableName, nbRow, nbCol, variable);
374     if (sciErr.iErr)
375     {
376         printError(&sciErr, 0);
377         return -1;
378     }
379     return 0;
380 }
381
382 unsigned int *getUnsignedInt(char *variableName, int *nbRow, int *nbCol)
383 {
384     SciErr sciErr;
385     int *matrixOfInt = NULL;
386
387     sciErr = readNamedMatrixOfUnsignedInteger32(NULL, variableName, nbRow, nbCol, NULL);
388     if (sciErr.iErr)
389     {
390         printError(&sciErr, 0);
391     }
392
393     /* Alloc the memory */
394     matrixOfInt = (int *)malloc(((*nbRow) * (*nbCol)) * sizeof(int));
395
396     /* Load the matrix */
397     sciErr = readNamedMatrixOfUnsignedInteger32(NULL, variableName, nbRow, nbCol, (unsigned int *)matrixOfInt);
398     if (sciErr.iErr)
399     {
400         printError(&sciErr, 0);
401     }
402
403     return (unsigned int *)matrixOfInt;
404
405 }
406
407 int putUnsignedInt(char *variableName, unsigned int *variable, int nbRow, int nbCol)
408 {
409     SciErr sciErr;
410
411     sciErr = createNamedMatrixOfUnsignedInteger32(NULL, variableName, nbRow, nbCol, variable);
412     if (sciErr.iErr)
413     {
414         printError(&sciErr, 0);
415         return -1;
416     }
417     return 0;
418 }
419
420 ////////////////////// long / int64
421 #ifdef __SCILAB_INT64__
422
423 long long *getLong(char *variableName, int *nbRow, int *nbCol)
424 {
425     SciErr sciErr;
426     long long *matrixOfLong = NULL;
427
428     sciErr = readNamedMatrixOfInteger64(NULL, variableName, nbRow, nbCol, NULL);
429     if (sciErr.iErr)
430     {
431         printError(&sciErr, 0);
432     }
433
434     /* Alloc the memory */
435     matrixOfLong = (long long *)malloc(((*nbRow) * (*nbCol)) * sizeof(long long));
436
437     /* Load the matrix */
438     sciErr = readNamedMatrixOfInteger64(NULL, variableName, nbRow, nbCol, matrixOfLong);
439     if (sciErr.iErr)
440     {
441         printError(&sciErr, 0);
442     }
443
444     return matrixOfLong;
445
446 }
447
448 int putLong(char *variableName, long *variable, int nbRow, int nbCol)
449 {
450     SciErr sciErr;
451
452     sciErr = createNamedMatrixOfInteger64(NULL, variableName, nbRow, nbCol, variable);
453     if (sciErr.iErr)
454     {
455         printError(&sciErr, 0);
456         return -1;
457     }
458     return 0;
459 }
460
461 unsigned long *getUnsignedLong(char *variableName, int *nbRow, int *nbCol)
462 {
463     SciErr sciErr;
464     long *matrixOfLong = NULL;
465
466     sciErr = readNamedMatrixOfUnsignedInteger64(NULL, variableName, nbRow, nbCol, NULL);
467     if (sciErr.iErr)
468     {
469         printError(&sciErr, 0);
470     }
471
472     /* Alloc the memory */
473     matrixOfLong = (long *)malloc(((*nbRow) * (*nbCol)) * sizeof(long));
474
475     /* Load the matrix */
476     sciErr = readNamedMatrixOfUnsignedInteger64(NULL, variableName, nbRow, nbCol, matrixOfLong);
477     if (sciErr.iErr)
478     {
479         printError(&sciErr, 0);
480     }
481
482     return matrixOfLong;
483
484 }
485
486 int putUnsignedLong(char *variableName, unsigned long *variable, int nbRow, int nbCol)
487 {
488     SciErr sciErr;
489
490     sciErr = createNamedMatrixOfUnsignedInteger64(NULL, variableName, nbRow, nbCol, variable);
491     if (sciErr.iErr)
492     {
493         printError(&sciErr, 0);
494         return -1;
495     }
496     return 0;
497 }
498
499 #endif
500
501 char **getString(char *variableName, int *nbRow, int *nbCol)
502 {
503     SciErr sciErr;
504     int i = 0;
505
506     int *piLen = NULL;
507     char **pstData = NULL;
508
509     //fisrt call to retrieve dimensions
510     sciErr = readNamedMatrixOfString(NULL, variableName, nbRow, nbCol, NULL, NULL);
511     if (sciErr.iErr)
512     {
513         printError(&sciErr, 0);
514     }
515
516     piLen = (int *)malloc(sizeof(int) * (*nbRow) * (*nbCol));
517
518     //second call to retrieve length of each string
519     sciErr = readNamedMatrixOfString(NULL, variableName, nbRow, nbCol, piLen, NULL);
520     if (sciErr.iErr)
521     {
522         printError(&sciErr, 0);
523     }
524
525     pstData = (char **)malloc(sizeof(char *) * (*nbRow) * (*nbCol));
526
527     for (i = 0; i < (*nbRow) * (*nbCol); i++)
528     {
529         pstData[i] = (char *)malloc(sizeof(char) * (piLen[i] + 1)); //+ 1 for null termination
530     }
531     //third call to retrieve data
532     sciErr = readNamedMatrixOfString(NULL, variableName, nbRow, nbCol, piLen, pstData);
533     if (sciErr.iErr)
534     {
535         printError(&sciErr, 0);
536     }
537     free(piLen);
538
539     return pstData;
540
541 }
542
543 int putString(char *variableName, char **variable, int nbRow, int nbCol)
544 {
545     SciErr sciErr;
546
547     sciErr = createNamedMatrixOfString(NULL, variableName, nbRow, nbCol, variable);
548     if (sciErr.iErr)
549     {
550         printError(&sciErr, 0);
551         return -1;
552     }
553     return 0;
554 }
555
556 int putSparse(char * variableName, int nbRow, int nbCol, int * nbRowItem, int nbRowItemL, int * colPos, int colPosL, double * data, int dataL)
557 {
558     SciErr sciErr;
559
560     sciErr = createNamedSparseMatrix(NULL, variableName, nbRow, nbCol, colPosL, nbRowItem, colPos, data);
561     if (sciErr.iErr)
562     {
563         printError(&sciErr, 0);
564         return -1;
565     }
566     return 0;
567 }
568
569 int putComplexSparse(char * variableName, int nbRow, int nbCol, int * nbRowItem, int nbRowItemL, int * colPos, int colPosL, double * data, int dataL, double * imag, int imagL)
570 {
571     SciErr sciErr;
572
573     sciErr = createNamedComplexSparseMatrix(NULL, variableName, nbRow, nbCol, colPosL, nbRowItem, colPos, data, imag);
574     if (sciErr.iErr)
575     {
576         printError(&sciErr, 0);
577         return -1;
578     }
579     return 0;
580 }
581
582 int putBooleanSparse(char * variableName, int nbRow, int nbCol, int * nbRowItem, int nbRowItemL, int * colPos, int colPosL)
583 {
584     SciErr sciErr;
585
586     sciErr = createNamedBooleanSparseMatrix(NULL, variableName, nbRow, nbCol, colPosL, nbRowItem, colPos);
587     if (sciErr.iErr)
588     {
589         printError(&sciErr, 0);
590         return -1;
591     }
592     return 0;
593 }
594
595 int putPolynomial(char * variableName, char * polyVarName, double ** data, int nbRow, int nbCol, int * nbCoef)
596 {
597     SciErr sciErr;
598
599     sciErr = createNamedMatrixOfPoly(NULL, variableName, polyVarName, nbRow, nbCol, nbCoef, data);
600     if (sciErr.iErr)
601     {
602         printError(&sciErr, 0);
603         return -1;
604     }
605     return 0;
606 }
607
608 int putComplexPolynomial(char * variableName, char * polyVarName, double ** data, int nbRow, int nbCol, int * nbCoef, double ** imag, int nbRowI, int nbColI, int * nbCoefI)
609 {
610     SciErr sciErr;
611
612     sciErr = createNamedComplexMatrixOfPoly(NULL, variableName, polyVarName, nbRow, nbCol, nbCoef, data, imag);
613     if (sciErr.iErr)
614     {
615         printError(&sciErr, 0);
616         return -1;
617     }
618     return 0;
619 }
620
621
622 BOOL isExistingVariable(char *variableName)
623 {
624     int iExisting = isNamedVarExist(NULL, variableName);
625
626     return iExisting != 0;      /* 0 = not existing variable */
627 }