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