Coverity: Matio module memory leaks fixed
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_boolean.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
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 * Please note that piece of code will be rewrited for the Scilab 6 family
15 * However, the API (profile of the functions in the header files) will be
16 * still available and supported in Scilab 6.
17 */
18
19 #include <string.h>
20 #include <stdlib.h>
21
22 #include "bool.hxx"
23 #include "context.hxx"
24 #include "gatewaystruct.hxx"
25
26 extern "C"
27 {
28 #include "machine.h"
29 #include "core_math.h"
30 #include "call_scilab.h"
31 #include "api_scilab.h"
32 #include "api_internal_common.h"
33 #include "localization.h"
34 }
35
36 /********************************/
37 /*   boolean matrix functions   */
38 /********************************/
39 SciErr getMatrixOfBoolean(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piBool)
40 {
41     SciErr sciErr = sciErrInit();
42     int iType = 0;
43
44     if (_piAddress == NULL)
45     {
46         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfBoolean");
47         return sciErr;
48     }
49
50     sciErr = getVarType(_pvCtx, _piAddress, &iType);
51     if (sciErr.iErr || iType != sci_boolean)
52     {
53         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfBoolean", _("boolean matrix"));
54         return sciErr;
55     }
56
57     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
58     if (sciErr.iErr)
59     {
60         addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN, _("%s: Unable to get argument #%d"), "getMatrixOfBoolean", getRhsFromAddress(_pvCtx, _piAddress));
61         return sciErr;
62     }
63
64     if (_piBool)
65     {
66         *_piBool = ((types::InternalType*)_piAddress)->getAs<types::Bool>()->get();
67     }
68     return sciErr;
69 }
70
71 SciErr allocMatrixOfBoolean(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piBool)
72 {
73     SciErr sciErr = sciErrInit();
74
75     if (_pvCtx == NULL)
76     {
77         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "allocMatrixOfBoolean");
78         return sciErr;
79     }
80
81     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
82     types::typed_list in = *pStr->m_pIn;
83     types::InternalType** out = pStr->m_pOut;
84
85     types::Bool *pBool = new types::Bool(_iRows, _iCols);
86     if (pBool == NULL)
87     {
88         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), "allocMatrixOfBoolean");
89         return sciErr;
90     }
91
92     int rhs = _iVar - *getNbInputArgument(_pvCtx);
93     out[rhs - 1] = pBool;
94     *_piBool = pBool->get();
95     if (*_piBool == NULL)
96     {
97         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), "allocMatrixOfBoolean");
98         delete[] pBool;
99         return sciErr;
100     }
101
102     return sciErr;
103 }
104
105 SciErr createMatrixOfBoolean(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piBool)
106 {
107     SciErr sciErr = sciErrInit();
108     int* piBool         = NULL;
109
110     if (_iRows == 0 && _iCols == 0)
111     {
112         double dblReal = 0;
113         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
114         if (sciErr.iErr)
115         {
116             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
117         }
118         return sciErr;
119     }
120
121     sciErr = allocMatrixOfBoolean(_pvCtx, _iVar, _iRows, _iCols, &piBool);
122     if (sciErr.iErr)
123     {
124         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfBoolean");
125         return sciErr;
126     }
127
128     memcpy(piBool, _piBool, sizeof(int) * _iRows * _iCols);
129     return sciErr;
130 }
131
132 SciErr createNamedMatrixOfBoolean(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const int* _piBool)
133 {
134     SciErr sciErr = sciErrInit();
135
136     // check variable name
137     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
138     {
139         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createNamedMatrixOfBoolean", _pstName);
140         return sciErr;
141     }
142
143     if (_iRows == 0 && _iCols == 0)
144     {
145         double dblReal = 0;
146         sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblReal);
147         if (sciErr.iErr)
148         {
149             addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
150         }
151         return sciErr;
152     }
153
154     if (!checkNamedVarFormat(_pvCtx, _pstName))
155     {
156         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedMatrixOfBoolean", _pstName);
157         return sciErr;
158     }
159
160     types::Bool* pBool = new types::Bool(_iRows, _iCols);
161     if (pBool == NULL)
162     {
163         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_BOOLEAN, _("%s: Unable to create %s named \"%s\""), "createNamedMatrixOfBoolean", _("matrix of boolean"), _pstName);
164         return sciErr;
165     }
166
167     wchar_t* pwstName = to_wide_string(_pstName);
168     pBool->set(_piBool);
169
170     symbol::Context* ctx = symbol::Context::getInstance();
171     symbol::Symbol sym = symbol::Symbol(pwstName);
172     FREE(pwstName);
173     if (ctx->isprotected(sym) == false)
174     {
175         ctx->put(sym, pBool);
176     }
177     else
178     {
179         delete pBool;
180         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
181     }
182
183     return sciErr;
184 }
185
186 SciErr readNamedMatrixOfBoolean(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piBool)
187 {
188     SciErr sciErr = sciErrInit();
189     int* piAddr                         = NULL;
190     int* piBool                         = NULL;
191
192     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
193     if (sciErr.iErr)
194     {
195         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
196         return sciErr;
197     }
198
199     sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, &piBool);
200     if (sciErr.iErr)
201     {
202         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
203         return sciErr;
204     }
205
206     if (_piBool)
207     {
208         memcpy(_piBool, piBool, sizeof(int) **_piRows **_piCols);
209     }
210
211     return sciErr;
212 }
213
214 /*shortcut functions*/
215
216 /*--------------------------------------------------------------------------*/
217 int isBooleanType(void* _pvCtx, int* _piAddress)
218 {
219     return checkVarType(_pvCtx, _piAddress, sci_boolean);
220 }
221 /*--------------------------------------------------------------------------*/
222 int isNamedBooleanType(void* _pvCtx, const char* _pstName)
223 {
224     return checkNamedVarType(_pvCtx, _pstName, sci_boolean);
225 }
226 /*--------------------------------------------------------------------------*/
227 int getScalarBoolean(void* _pvCtx, int* _piAddress, int* _piBool)
228 {
229     SciErr sciErr = sciErrInit();
230     int iRows   = 0;
231     int iCols   = 0;
232
233     int* piBool = NULL;
234
235     sciErr = getMatrixOfBoolean(_pvCtx, _piAddress, &iRows, &iCols, &piBool);
236     if (sciErr.iErr)
237     {
238         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_BOOLEAN, _("%s: Unable to get argument #%d"), "getScalarBoolean", getRhsFromAddress(_pvCtx, _piAddress));
239         printError(&sciErr, 0);
240         return sciErr.iErr;
241     }
242
243     if (isScalar(_pvCtx, _piAddress) == 0)
244     {
245         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_BOOLEAN, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "getScalarBoolean", getRhsFromAddress(_pvCtx, _piAddress));
246         printError(&sciErr, 0);
247         return sciErr.iErr;
248     }
249
250     if (_piBool != NULL)
251     {
252         *_piBool        = piBool[0];
253     }
254
255     return 0;
256 }
257 /*--------------------------------------------------------------------------*/
258 int getNamedScalarBoolean(void* _pvCtx, const char* _pstName, int* _piBool)
259 {
260     SciErr sciErr = sciErrInit();
261     int iRows   = 0;
262     int iCols   = 0;
263
264     int iBool = 0;
265
266     sciErr = readNamedMatrixOfBoolean(_pvCtx, _pstName, &iRows, &iCols, &iBool);
267     if (sciErr.iErr)
268     {
269         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_BOOLEAN, _("%s: Unable to get argument \"%s\""), "getNamedScalarBoolean", _pstName);
270         printError(&sciErr, 0);
271         return sciErr.iErr;
272     }
273
274     if (isNamedScalar(_pvCtx, _pstName) == 0)
275     {
276         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_BOOLEAN, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), "getNamedScalarBoolean", _pstName);
277         printError(&sciErr, 0);
278         return sciErr.iErr;
279     }
280
281     if (_piBool != NULL)
282     {
283         *_piBool        = iBool;
284     }
285
286     return 0;
287 }
288 /*--------------------------------------------------------------------------*/
289 int createScalarBoolean(void* _pvCtx, int _iVar, int _iBool)
290 {
291     SciErr sciErr = sciErrInit();
292     int* piBool = NULL;
293
294     sciErr = allocMatrixOfBoolean(_pvCtx, _iVar, 1, 1, &piBool);
295     if (sciErr.iErr)
296     {
297         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_BOOLEAN, _("%s: Unable to create variable in Scilab memory"), "createScalarBoolean");
298         printError(&sciErr, 0);
299         return sciErr.iErr;
300     }
301
302     piBool[0] = _iBool;
303     return 0;
304 }
305 /*--------------------------------------------------------------------------*/
306 int createNamedScalarBoolean(void* _pvCtx, const char* _pstName, int _iBool)
307 {
308     SciErr sciErr = sciErrInit();
309     sciErr = createNamedMatrixOfBoolean(_pvCtx, _pstName, 1, 1, &_iBool);
310     if (sciErr.iErr)
311     {
312         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_BOOLEAN, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarBoolean");
313         printError(&sciErr, 0);
314         return sciErr.iErr;
315     }
316
317     return 0;
318 }
319 /*--------------------------------------------------------------------------*/