* Port to matio 1.5.0 * Code cleaning * Prepare code for Scilab 6 (YaSp branch merge)
[scilab.git] / scilab / modules / matio / src / c / GetIntegerVariable.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2008 - INRIA - Vincent COUVERT
4  * Copyright (C) 2010 - DIGITEO - Yann COLLETTE
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 "GetMatlabVariable.h"
15 #include "sci_types.h"
16 #include "api_scilab.h"
17
18 matvar_t *GetIntegerVariable(void *pvApiCtx, int iVar, const char *name, int * parent, int item_position)
19 {
20     int rank = 0;
21     size_t *pszDims = NULL;
22     int *piDims = NULL;
23     matvar_t *createdVar = NULL;
24     int * var_addr = NULL;
25     int i;
26     int var_type;
27     int integerType;
28     SciErr sciErr;
29     char * tmp_int8 = NULL;
30     short * tmp_int16 = NULL;
31     int * tmp_int32 = NULL;
32     int * item_addr = NULL;
33     unsigned char * tmp_uint8 = NULL;
34     unsigned short * tmp_uint16 = NULL;
35     unsigned int * tmp_uint32 = NULL;
36 #ifdef __SCILAB_INT64__
37     long long * tmp_int64 = NULL;
38     unsigned long long * tmp_uint64 = NULL;
39 #endif
40
41     if (parent == NULL)
42     {
43         sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &var_addr);
44         if (sciErr.iErr)
45         {
46             printError(&sciErr, 0);
47             return 0;
48         }
49         sciErr = getVarType(pvApiCtx, var_addr, &var_type);
50         if (sciErr.iErr)
51         {
52             printError(&sciErr, 0);
53             return 0;
54         }
55     }
56     else
57     {
58         sciErr = getListItemAddress(pvApiCtx, parent, item_position, &item_addr);
59         if (sciErr.iErr)
60         {
61             printError(&sciErr, 0);
62             return 0;
63         }
64         sciErr = getVarType(pvApiCtx, item_addr, &var_type);
65         if (sciErr.iErr)
66         {
67             printError(&sciErr, 0);
68             return 0;
69         }
70     }
71
72     if (var_type == sci_ints) /* 2-D array */
73     {
74         rank = 2;
75         if ((pszDims = (size_t*)MALLOC(sizeof(size_t) * rank)) == NULL)
76         {
77             Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable");
78             return NULL;
79         }
80         if ((piDims = (int*)MALLOC(sizeof(int) * rank)) == NULL)
81         {
82             Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable");
83             return NULL;
84         }
85
86         if (parent == NULL)
87         {
88             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, var_addr, &integerType);
89         }
90         else
91         {
92             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, item_addr, &integerType);
93         }
94
95         switch (integerType)
96         {
97             case SCI_INT8: /* INT8 */
98                 if (parent == NULL)
99                 {
100                     sciErr = getMatrixOfInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int8);
101                 }
102                 else
103                 {
104                     sciErr = getMatrixOfInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int8);
105                 }
106
107                 for (i = 0; i < rank; i++)
108                 {
109                     pszDims[i] = piDims[i];
110                 }
111
112                 createdVar = Mat_VarCreate(name, MAT_C_INT8, MAT_T_INT8, rank, pszDims, tmp_int8, 0);
113                 break;
114             case SCI_INT16: /* INT16 */
115                 if (parent == NULL)
116                 {
117                     sciErr = getMatrixOfInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int16);
118                 }
119                 else
120                 {
121                     sciErr = getMatrixOfInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int16);
122                 }
123
124                 for (i = 0; i < rank; i++)
125                 {
126                     pszDims[i] = piDims[i];
127                 }
128
129                 createdVar = Mat_VarCreate(name, MAT_C_INT16, MAT_T_INT16, rank, pszDims, tmp_int16, 0);
130                 break;
131             case SCI_INT32: /* INT32 */
132                 if (parent == NULL)
133                 {
134                     sciErr = getMatrixOfInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int32);
135                 }
136                 else
137                 {
138                     sciErr = getMatrixOfInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int32);
139                 }
140
141                 for (i = 0; i < rank; i++)
142                 {
143                     pszDims[i] = piDims[i];
144                 }
145
146                 createdVar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, rank, pszDims, tmp_int32, 0);
147                 break;
148             case SCI_UINT8: /* UINT8 */
149                 if (parent == NULL)
150                 {
151                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint8);
152                 }
153                 else
154                 {
155                     sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint8);
156                 }
157
158                 for (i = 0; i < rank; i++)
159                 {
160                     pszDims[i] = piDims[i];
161                 }
162
163                 createdVar = Mat_VarCreate(name, MAT_C_UINT8, MAT_T_UINT8, rank, pszDims, tmp_uint8, 0);
164                 break;
165             case SCI_UINT16: /* UINT16 */
166                 if (parent == NULL)
167                 {
168                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint16);
169                 }
170                 else
171                 {
172                     sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint16);
173                 }
174
175                 for (i = 0; i < rank; i++)
176                 {
177                     pszDims[i] = piDims[i];
178                 }
179
180                 createdVar = Mat_VarCreate(name, MAT_C_UINT16, MAT_T_UINT16, rank, pszDims, tmp_uint16, 0);
181                 break;
182             case SCI_UINT32: /* UINT32 */
183                 if (parent == NULL)
184                 {
185                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint32);
186                 }
187                 else
188                 {
189                     sciErr = getMatrixOfUnsignedInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint32);
190                 }
191
192                 for (i = 0; i < rank; i++)
193                 {
194                     pszDims[i] = piDims[i];
195                 }
196
197                 createdVar = Mat_VarCreate(name, MAT_C_UINT32, MAT_T_UINT32, rank, pszDims, tmp_uint32, 0);
198                 break;
199             default:
200                 createdVar = NULL;
201                 break;
202         }
203     }
204     else
205     {
206         Scierror(999, _("%s: Wrong type for first input argument: Integer matrix expected.\n"), "GetIntegerVariable");
207     }
208
209     FREE(pszDims);
210     FREE(piDims);
211
212     return createdVar;
213 }