License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / api_scilab / tests / unit_tests / integer_reading_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 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn);
23
24 int read_integer(char *fname, void* pvApiCtx)
25 {
26     SciErr sciErr;
27     //output variable info
28     int iRows8                                  = 0;
29     int iCols8                                  = 0;
30     int iRows16                                 = 0;
31     int iCols16                                 = 0;
32     int iRows32                                 = 0;
33     int iCols32                                 = 0;
34     int iRowsu8                                 = 0;
35     int iColsu8                                 = 0;
36     int iRowsu16                                = 0;
37     int iColsu16                                = 0;
38     int iRowsu32                                = 0;
39     int iColsu32                                = 0;
40     int iPrec                                   = 0;
41     int* piAddr8                                = NULL;
42     int* piAddr16                               = NULL;
43     int* piAddr32                               = NULL;
44     int* piAddru8                               = NULL;
45     int* piAddru16                              = NULL;
46     int* piAddru32                              = NULL;
47     char* pcData                                = NULL;
48     short* psData                               = NULL;
49     int* piData                                 = NULL;
50     unsigned char* pucData              = NULL;
51     unsigned short* pusData             = NULL;
52     unsigned int* puiData               = NULL;
53     char* pcDataOut                             = NULL;
54     short* psDataOut                    = NULL;
55     int* piDataOut                              = NULL;
56     unsigned char* pucDataOut   = NULL;
57     unsigned short* pusDataOut  = NULL;
58     unsigned int* puiDataOut    = NULL;
59
60     //check input/output arguments count
61     CheckInputArgument(pvApiCtx, 6, 6);
62     CheckOutputArgument(pvApiCtx, 6, 6);
63
64     //get variable address
65     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
66     if (sciErr.iErr)
67     {
68         printError(&sciErr, 0);
69         return 0;
70     }
71
72     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
73     if (sciErr.iErr)
74     {
75         printError(&sciErr, 0);
76         return 0;
77     }
78
79     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
80     if (sciErr.iErr)
81     {
82         printError(&sciErr, 0);
83         return 0;
84     }
85
86     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
87     if (sciErr.iErr)
88     {
89         printError(&sciErr, 0);
90         return 0;
91     }
92
93     sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
94     if (sciErr.iErr)
95     {
96         printError(&sciErr, 0);
97         return 0;
98     }
99
100     sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
101     if (sciErr.iErr)
102     {
103         printError(&sciErr, 0);
104         return 0;
105     }
106
107     //check variable precision
108     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
109     if (sciErr.iErr || iPrec != SCI_INT8)
110     {
111         printError(&sciErr, 0);
112         return 0;
113     }
114
115     //check variable precision
116     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
117     if (sciErr.iErr || iPrec != SCI_UINT8)
118     {
119         printError(&sciErr, 0);
120         return 0;
121     }
122
123     //check variable precision
124     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
125     if (sciErr.iErr || iPrec != SCI_INT16)
126     {
127         printError(&sciErr, 0);
128         return 0;
129     }
130
131     //check variable precision
132     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
133     if (sciErr.iErr || iPrec != SCI_UINT16)
134     {
135         printError(&sciErr, 0);
136         return 0;
137     }
138     //check variable precision
139     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
140     if (sciErr.iErr || iPrec != SCI_INT32)
141     {
142         printError(&sciErr, 0);
143         return 0;
144     }
145
146     //check variable precision
147     sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
148     if (sciErr.iErr || iPrec != SCI_UINT32)
149     {
150         printError(&sciErr, 0);
151         return 0;
152     }
153
154     //retrieve dimensions and data
155     sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
156     if (sciErr.iErr)
157     {
158         printError(&sciErr, 0);
159         return 0;
160     }
161
162     //retrieve dimensions and data
163     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
164     if (sciErr.iErr)
165     {
166         printError(&sciErr, 0);
167         return 0;
168     }
169
170     //retrieve dimensions and data
171     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
172     if (sciErr.iErr)
173     {
174         printError(&sciErr, 0);
175         return 0;
176     }
177
178     //retrieve dimensions and data
179     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
180     if (sciErr.iErr)
181     {
182         printError(&sciErr, 0);
183         return 0;
184     }
185
186     //retrieve dimensions and data
187     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
188     if (sciErr.iErr)
189     {
190         printError(&sciErr, 0);
191         return 0;
192     }
193
194     //retrieve dimensions and data
195     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
196     if (sciErr.iErr)
197     {
198         printError(&sciErr, 0);
199         return 0;
200     }
201
202     //alloc and fill new variable
203     pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
204     pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
205     psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
206     pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
207     piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
208     puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
209
210     //create new variable
211     sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
212     if (sciErr.iErr)
213     {
214         printError(&sciErr, 0);
215         return 0;
216     }
217
218     //create new variable
219     sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
220     if (sciErr.iErr)
221     {
222         printError(&sciErr, 0);
223         return 0;
224     }
225
226     //create new variable
227     sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
228     if (sciErr.iErr)
229     {
230         printError(&sciErr, 0);
231         return 0;
232     }
233
234     //create new variable
235     sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
236     if (sciErr.iErr)
237     {
238         printError(&sciErr, 0);
239         return 0;
240     }
241
242     //create new variable
243     sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
244     if (sciErr.iErr)
245     {
246         printError(&sciErr, 0);
247         return 0;
248     }
249
250     //create new variable
251     sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
252     if (sciErr.iErr)
253     {
254         printError(&sciErr, 0);
255         return 0;
256     }
257
258     FREE(pcDataOut);
259     FREE(pucDataOut);
260     FREE(psDataOut);
261     FREE(pusDataOut);
262     FREE(piDataOut);
263     FREE(puiDataOut);
264
265
266     //assign allocated variables to Lhs position
267     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
268     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
269     AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
270     AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
271     AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
272     AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
273     return 0;
274 }
275
276 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn)
277 {
278     int i = 0;
279     void* pvDataOut = (void*)MALLOC(_iSize * _iRows * _iCols);
280     for (i = 0 ; i < _iRows * _iCols ; i++)
281     {
282         int iVal = 0;
283         memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
284         iVal *= _iCoeff;
285         memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
286     }
287     return pvDataOut;
288 }