License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / api_scilab / tests / unit_tests / common_read_api.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009-2010 - DIGITEO
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
16 #include "api_scilab.h"
17 #include "Scierror.h"
18 #include "localization.h"
19 #include "sciprint.h"
20 #include "sci_malloc.h"
21
22 static int iTab = 0;
23 void insert_indent(void)
24 {
25     int i = 0;
26     for (i = 0 ; i < iTab ; i++)
27     {
28         sciprint("\t");
29     }
30 }
31
32 int get_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
33 int get_list_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
34 int get_double_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
35 int get_poly_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
36 int get_boolean_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
37 int get_sparse_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
38 int get_bsparse_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
39 int get_integer_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
40 int get_string_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
41 int get_pointer_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
42
43 int common_read(char *fname, void* pvApiCtx)
44 {
45     SciErr sciErr;
46     int iItem       = 0;
47     int iRet        = 0;
48     int *piAddr     = NULL;
49
50     CheckInputArgument(pvApiCtx, 1, 1);
51
52     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
53     if (sciErr.iErr)
54     {
55         printError(&sciErr, 0);
56         return 0;
57     }
58
59     get_info(pvApiCtx, 1, NULL, piAddr, 0);
60     AssignOutputVariable(pvApiCtx, 1) = 0;
61     return 0;
62 }
63
64 int get_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
65 {
66     SciErr sciErr;
67     int iRet    = 0;
68     int iType   = 0;
69
70     sciErr = getVarType(_pvCtx, _piAddr, &iType);
71     switch (iType)
72     {
73         case sci_matrix :
74             iRet = get_double_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
75             break;
76         case sci_poly :
77             iRet = get_poly_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
78             break;
79         case sci_boolean :
80             iRet = get_boolean_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
81             break;
82         case sci_sparse :
83             iRet = get_sparse_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
84             break;
85         case sci_boolean_sparse :
86             iRet = get_bsparse_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
87             break;
88         case sci_ints :
89             iRet = get_integer_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
90             break;
91         case sci_strings :
92             iRet = get_string_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
93             break;
94         case sci_list :
95             insert_indent();
96             sciprint("List ");
97             iRet = get_list_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
98             break;
99         case sci_tlist :
100             insert_indent();
101             sciprint("TList ");
102             iRet = get_list_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
103             break;
104         case sci_mlist :
105             insert_indent();
106             sciprint("MList ");
107             iRet = get_list_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
108             break;
109         case sci_pointer :
110             iRet = get_pointer_info(_pvCtx, _iRhs, _piParent, _piAddr, _iItemPos);
111             break;
112         default :
113             insert_indent();
114             sciprint("Unknown type\n");
115             return 1;
116     }
117     return iRet;
118 }
119
120 int get_list_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
121 {
122     SciErr sciErr;
123     int i;
124     int iRet        = 0;
125     int iItem       = 0;
126     int* piChild    = NULL;
127
128     sciErr = getListItemNumber(_pvCtx, _piAddr, &iItem);
129     if (sciErr.iErr)
130     {
131         printError(&sciErr, 0);
132         return 0;
133     }
134
135     sciprint("(%d)\n", iItem);
136     for (i = 0 ; i < iItem ; i++)
137     {
138         sciErr = getListItemAddress(_pvCtx, _piAddr, i + 1, &piChild);
139         if (sciErr.iErr)
140         {
141             printError(&sciErr, 0);
142             return 0;
143         }
144
145         iTab++;
146         iRet = get_info(_pvCtx, _iRhs, _piAddr, piChild, i + 1);
147         iTab--;
148     }
149     return 0;;
150 }
151
152 int get_double_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
153 {
154     SciErr sciErr;
155     int iRows           = 0;
156     int iCols           = 0;
157     double* pdblReal    = NULL;
158     double* pdblImg     = NULL;
159
160     if (_iItemPos == 0)
161     {
162         //not in list
163         if (isVarComplex(_pvCtx, _piAddr))
164         {
165             sciErr = getComplexMatrixOfDouble(_pvCtx, _piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
166         }
167         else
168         {
169             sciErr = getMatrixOfDouble(_pvCtx, _piAddr, &iRows, &iCols, &pdblReal);
170         }
171     }
172     else
173     {
174         if (isVarComplex(_pvCtx, _piAddr))
175         {
176             sciErr = getComplexMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal, &pdblImg);
177         }
178         else
179         {
180             sciErr = getMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal);
181         }
182     }
183
184     if (sciErr.iErr)
185     {
186         printError(&sciErr, 0);
187         return 0;
188     }
189
190     insert_indent();
191     sciprint("Double (%d x %d)\n", iRows, iCols);
192     return 0;;
193 }
194
195 int get_poly_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
196 {
197     SciErr sciErr;
198     int i;
199     int iLen            = 0;
200     int iRows           = 0;
201     int iCols           = 0;
202     char pstVar[16];
203     int* piCoeff        = NULL;
204     double** pdblReal   = NULL;
205     double** pdblImg    = NULL;
206
207     sciErr = getPolyVariableName(_pvCtx, _piAddr, pstVar, &iLen);
208     if (sciErr.iErr)
209     {
210         printError(&sciErr, 0);
211         return 0;
212     }
213
214     if (_iItemPos == 0)
215     {
216         //not in list
217         sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, NULL, NULL);
218         if (sciErr.iErr)
219         {
220             printError(&sciErr, 0);
221             return 0;
222         }
223
224         piCoeff     = (int*)MALLOC(sizeof(int) * iRows * iCols);
225         sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, NULL);
226         if (sciErr.iErr)
227         {
228             printError(&sciErr, 0);
229             return 0;
230         }
231
232         pdblReal    = (double**)MALLOC(sizeof(double*) * iRows * iCols);
233         pdblImg     = (double**)MALLOC(sizeof(double*) * iRows * iCols);
234
235         for (i = 0 ; i < iRows * iCols ; i++)
236         {
237             pdblReal[i] = (double*)MALLOC(sizeof(double) * piCoeff[i]);
238             pdblImg[i]  = (double*)MALLOC(sizeof(double) * piCoeff[i]);
239         }
240
241         if (isVarComplex(_pvCtx, _piAddr))
242         {
243             sciErr = getComplexMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
244             if (sciErr.iErr)
245             {
246                 printError(&sciErr, 0);
247                 return 0;
248             }
249         }
250         else
251         {
252             sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal);
253             if (sciErr.iErr)
254             {
255                 printError(&sciErr, 0);
256                 return 0;
257             }
258         }
259     }
260     else
261     {
262         sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
263         if (sciErr.iErr)
264         {
265             printError(&sciErr, 0);
266             return 0;
267         }
268
269         piCoeff = (int*)MALLOC(sizeof(int) * iRows * iCols);
270
271         sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, NULL);
272         if (sciErr.iErr)
273         {
274             printError(&sciErr, 0);
275             return 0;
276         }
277
278         pdblReal    = (double**)MALLOC(sizeof(double*) * iRows * iCols);
279         pdblImg     = (double**)MALLOC(sizeof(double*) * iRows * iCols);
280
281         for (i = 0 ; i < iRows * iCols ; i++)
282         {
283             pdblReal[i] = (double*)MALLOC(sizeof(double) * piCoeff[i]);
284             pdblImg[i]  = (double*)MALLOC(sizeof(double) * piCoeff[i]);
285         }
286
287         if (isVarComplex(_pvCtx, _piAddr))
288         {
289             sciErr = getComplexMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
290         }
291         else
292         {
293             sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal);
294         }
295     }
296
297     if (sciErr.iErr)
298     {
299         printError(&sciErr, 0);
300         return 0;
301     }
302
303     insert_indent();
304     sciprint("Poly  (%d x %d), varname : \'%s\'\n", iRows, iCols, pstVar);
305
306     for (i = 0 ; i < iRows * iCols ; i++)
307     {
308         FREE(pdblReal[i]);
309         FREE(pdblImg[i]);
310     }
311
312     FREE(pdblReal);
313     FREE(pdblImg);
314     FREE(piCoeff);
315     return 0;;
316 }
317 int get_boolean_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
318 {
319     SciErr sciErr;
320     int iRows       = 0;
321     int iCols       = 0;
322     int* piBool     = NULL;
323
324     if (_iItemPos == 0)
325     {
326         sciErr = getMatrixOfBoolean(_pvCtx, _piAddr, &iRows, &iCols, &piBool);
327     }
328     else
329     {
330         sciErr = getMatrixOfBooleanInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &piBool);
331     }
332
333     if (sciErr.iErr)
334     {
335         printError(&sciErr, 0);
336         return 0;
337     }
338
339     insert_indent();
340     sciprint("Boolean (%d x %d)\n", iRows, iCols);
341     return 0;
342 }
343 int get_sparse_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
344 {
345     SciErr sciErr;
346     int iRows           = 0;
347     int iCols           = 0;
348     int iItem           = 0;
349     int* piNbRow        = NULL;
350     int* piColPos       = NULL;
351     double* pdblReal    = NULL;
352     double* pdblImg     = NULL;
353
354     if (_iItemPos == 0)
355     {
356         //Not in list
357         if (isVarComplex(_pvCtx, _piAddr))
358         {
359             sciErr = getComplexSparseMatrix(_pvCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
360         }
361         else
362         {
363             sciErr = getSparseMatrix(_pvCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
364         }
365     }
366     else
367     {
368         if (isVarComplex(_pvCtx, _piAddr))
369         {
370             sciErr = getComplexSparseMatrixInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
371         }
372         else
373         {
374             sciErr = getSparseMatrixInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
375         }
376     }
377
378     FREE(piNbRow);
379     FREE(piColPos);
380     FREE(pdblReal);
381     FREE(pdblImg);
382
383     insert_indent();
384     sciprint("Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
385     return 0;;
386 }
387
388 int get_bsparse_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
389 {
390     SciErr sciErr;
391     int iRows       = 0;
392     int iCols       = 0;
393     int iItem       = 0;
394     int* piNbRow    = NULL;
395     int* piColPos   = NULL;
396
397     if (_iItemPos == 0)
398     {
399         //Not in list
400         sciErr = getBooleanSparseMatrix(_pvCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
401     }
402     else
403     {
404         sciErr = getBooleanSparseMatrixInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
405     }
406
407     if (sciErr.iErr)
408     {
409         printError(&sciErr, 0);
410         return 0;
411     }
412
413     FREE(piNbRow);
414     FREE(piColPos);
415
416     insert_indent();
417     sciprint("Boolean Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
418     return 0;;
419 }
420 int get_integer_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
421 {
422     SciErr sciErr;
423     int iPrec               = 0;
424     int iRows               = 0;
425     int iCols               = 0;
426     char* pcData            = NULL;
427     short* psData           = NULL;
428     int* piData             = NULL;
429     unsigned char* pucData  = NULL;
430     unsigned short* pusData = NULL;
431     unsigned int* puiData   = NULL;
432
433     if (_iItemPos == 0)
434     {
435         //Not in list
436         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrec);
437         if (sciErr.iErr)
438         {
439             printError(&sciErr, 0);
440             return 0;
441         }
442
443         switch (iPrec)
444         {
445             case SCI_INT8 :
446                 sciErr = getMatrixOfInteger8(_pvCtx, _piAddr, &iRows, &iCols, &pcData);
447                 break;
448             case SCI_INT16 :
449                 sciErr = getMatrixOfInteger16(_pvCtx, _piAddr, &iRows, &iCols, &psData);
450                 break;
451             case SCI_INT32 :
452                 sciErr = getMatrixOfInteger32(_pvCtx, _piAddr, &iRows, &iCols, &piData);
453                 break;
454             case SCI_UINT8 :
455                 sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddr, &iRows, &iCols, &pucData);
456                 break;
457             case SCI_UINT16 :
458                 sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddr, &iRows, &iCols, &pusData);
459                 break;
460             case SCI_UINT32 :
461                 sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddr, &iRows, &iCols, &puiData);
462                 break;
463             default :
464                 return 1;
465         }
466     }
467     else
468     {
469         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrec);
470         if (sciErr.iErr)
471         {
472             printError(&sciErr, 0);
473             return 0;
474         }
475
476         switch (iPrec)
477         {
478             case SCI_INT8 :
479                 sciErr = getMatrixOfInteger8InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pcData);
480                 break;
481             case SCI_INT16 :
482                 sciErr = getMatrixOfInteger16InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &psData);
483                 break;
484             case SCI_INT32 :
485                 sciErr = getMatrixOfInteger32InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &piData);
486                 break;
487             case SCI_UINT8 :
488                 sciErr = getMatrixOfUnsignedInteger8InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pucData);
489                 break;
490             case SCI_UINT16 :
491                 sciErr = getMatrixOfUnsignedInteger16InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pusData);
492                 break;
493             case SCI_UINT32 :
494                 sciErr = getMatrixOfUnsignedInteger32InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &puiData);
495                 break;
496             default :
497                 return 1;
498         }
499     }
500
501     if (sciErr.iErr)
502     {
503         printError(&sciErr, 0);
504         return 0;
505     }
506
507     insert_indent();
508
509     if (iPrec > 10)
510     {
511         sciprint("Unsigned ");
512     }
513
514     sciprint("Integer %d bits (%d x %d)\n", (iPrec % 10) * 8, iRows, iCols);
515     return 0;;
516 }
517 int get_string_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
518 {
519     SciErr sciErr;
520     int i;
521     int iRows       = 0;
522     int iCols       = 0;
523     int* piLen      = NULL;
524     char **pstData  = NULL;
525
526     if (_iItemPos == 0)
527     {
528         //Not in list
529         sciErr = getMatrixOfString(_pvCtx, _piAddr, &iRows, &iCols, NULL, NULL);
530         if (sciErr.iErr)
531         {
532             printError(&sciErr, 0);
533             return 0;
534         }
535
536         piLen = (int*)MALLOC(sizeof(int) * iRows * iCols);
537         sciErr = getMatrixOfString(_pvCtx, _piAddr, &iRows, &iCols, piLen, NULL);
538         if (sciErr.iErr)
539         {
540             printError(&sciErr, 0);
541             return 0;
542         }
543
544         pstData = (char**)MALLOC(sizeof(char*) * iRows * iCols);
545
546         for (i = 0 ; i < iRows * iCols ; i++)
547         {
548             pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
549         }
550
551         sciErr = getMatrixOfString(_pvCtx, _piAddr, &iRows, &iCols, piLen, pstData);
552         if (sciErr.iErr)
553         {
554             printError(&sciErr, 0);
555             return 0;
556         }
557     }
558     else
559     {
560         sciErr = getMatrixOfStringInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
561         if (sciErr.iErr)
562         {
563             printError(&sciErr, 0);
564             return 0;
565         }
566
567         piLen = (int*)MALLOC(sizeof(int) * iRows * iCols);
568
569         sciErr = getMatrixOfStringInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, NULL);
570         if (sciErr.iErr)
571         {
572             printError(&sciErr, 0);
573             return 0;
574         }
575
576         pstData = (char**)MALLOC(sizeof(char*) * iRows * iCols);
577
578         for (i = 0 ; i < iRows * iCols ; i++)
579         {
580             pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
581         }
582
583         sciErr = getMatrixOfStringInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, pstData);
584         if (sciErr.iErr)
585         {
586             printError(&sciErr, 0);
587             return 0;
588         }
589     }
590     if (sciErr.iErr)
591     {
592         printError(&sciErr, 0);
593         return 0;
594     }
595
596     for (i = 0 ; i < iRows * iCols ; i++)
597     {
598         FREE(pstData[i]);
599     }
600
601     FREE(pstData);
602     FREE(piLen);
603
604     insert_indent();
605     sciprint("Strings (%d x %d)\n", iRows, iCols);
606     return 0;;
607 }
608 int get_pointer_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
609 {
610     SciErr sciErr;
611     void* pvPtr     = NULL;
612
613     if (_iItemPos == 0)
614     {
615         sciErr = getPointer(_pvCtx, _piAddr, &pvPtr);
616     }
617     else
618     {
619         sciErr = getPointerInList(_pvCtx, _piParent, _iItemPos, &pvPtr);
620     }
621
622     if (sciErr.iErr)
623     {
624         printError(&sciErr, 0);
625         return 0;
626     }
627
628     insert_indent();
629     sciprint("Pointer : 0x%08X\n", pvPtr);
630     return 0;
631 }