Coverity: api_scilab module memory errors fixed
[scilab.git] / scilab / modules / api_scilab / src / cpp / template / api_poly.hpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2015 - Scilab Enterprises - 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
15 #include "gatewaystruct.hxx"
16 #include "double.hxx"
17 #include "polynom.hxx"
18
19 extern "C"
20 {
21 #include "api_scilab.h"
22 }
23
24 scilabVar API_PROTO(createPoly)(scilabEnv env, const wchar_t* varname, int complex)
25 {
26     int dims[2] = {1, 1};
27     return scilab_createPolyMatrix(env, varname, 2, dims, complex);
28 }
29
30 scilabVar API_PROTO(createPolyMatrix)(scilabEnv env, const wchar_t* varname, int dim, const int* dims, int complex)
31 {
32 #ifdef __API_SCILAB_SAFE__
33     if (dims == nullptr)
34     {
35         scilab_setInternalError(env, L"createPolyMatrix", _W("dims array cannot be NULL"));
36         return nullptr;
37     }
38
39     for (int i = 0; i < dim; ++i)
40     {
41         if (dims[i] < 0)
42         {
43             scilab_setInternalError(env, L"createPolyMatrix", _W("dimensions cannot be negative"));
44             return nullptr;
45         }
46     }
47 #endif
48     types::Polynom* p = new types::Polynom(varname, dim, dims);
49     if (p == nullptr)
50     {
51         scilab_setInternalError(env, L"createPolyMatrix", _W("memory allocation error"));
52         return nullptr;
53     }
54
55     p->setComplex(complex != 0);
56     return (scilabVar)p;
57 }
58
59 scilabVar API_PROTO(createPolyMatrix2d)(scilabEnv env, const wchar_t* varname, int row, int col, int complex)
60 {
61     int dims[2] = {row, col};
62     return scilab_createPolyMatrix(env, varname, 2, dims, complex);
63 }
64
65 int API_PROTO(getPolyVarname)(scilabEnv env, scilabVar var, const wchar_t** varname)
66 {
67     types::Polynom* p = (types::Polynom*)var;
68 #ifdef __API_SCILAB_SAFE__
69     if (p->isPoly() == false)
70     {
71         scilab_setInternalError(env, L"getPolyArray", _W("var must be a polynomial variable"));
72         return STATUS_ERROR;
73     }
74 #endif
75
76     std::wstring v = p->getVariableName();
77     *varname = wcsdup(v.data());
78     return STATUS_OK;
79 }
80
81 int API_PROTO(getPolyArray)(scilabEnv env, scilabVar var, int index, double** real)
82 {
83     types::Polynom* p = (types::Polynom*)var;
84 #ifdef __API_SCILAB_SAFE__
85     if (p->isPoly() == false)
86     {
87         scilab_setInternalError(env, L"getPolyArray", _W("var must be a polynomial variable"));
88         return STATUS_ERROR;
89     }
90 #endif
91     types::SinglePoly* sp = p->get(index);
92     *real = sp->get();
93     return sp->getRank();
94 }
95
96 int API_PROTO(getComplexPolyArray)(scilabEnv env, scilabVar var, int index, double** real, double** img)
97 {
98     types::Polynom* p = (types::Polynom*)var;
99 #ifdef __API_SCILAB_SAFE__
100     if (p->isPoly() == false || p->isComplex() == false)
101     {
102         scilab_setInternalError(env, L"getComplexPolyArray", _W("var must be a polynomial variable"));
103         return STATUS_ERROR;
104     }
105 #endif
106     types::SinglePoly* sp = p->get(index);
107     *real = sp->get();
108     *img = sp->getImg();
109     return sp->getRank();
110 }
111
112 scilabStatus API_PROTO(setPolyArray)(scilabEnv env, scilabVar var, int index, int rank, const double* real)
113 {
114     types::Polynom* p = (types::Polynom*)var;
115 #ifdef __API_SCILAB_SAFE__
116     if (p->isPoly() == false)
117     {
118         scilab_setInternalError(env, L"setPolyArray", _W("var must be a polynomial variable"));
119         return STATUS_ERROR;
120     }
121 #endif
122
123     if (index < 0 || index >= p->getSize())
124     {
125 #ifdef __API_SCILAB_SAFE__
126         scilab_setInternalError(env, L"setPolyArray", _W("index out of bounds"));
127 #endif
128         return STATUS_ERROR;
129     }
130     types::SinglePoly* sp = p->get(index);
131     if (sp)
132     {
133         sp->setRank(rank);
134         sp->set(real);
135     }
136     else
137     {
138         sp = new types::SinglePoly();
139         sp->setRank(rank);
140         sp->set(real);
141         p->set(index, sp);
142     }
143
144     return STATUS_OK;
145 }
146
147 scilabStatus API_PROTO(setComplexPolyArray)(scilabEnv env, scilabVar var, int index, int rank, const double* real, const double* img)
148 {
149     types::Polynom* p = (types::Polynom*)var;
150 #ifdef __API_SCILAB_SAFE__
151     if (p->isPoly() == false || p->isComplex() == false)
152     {
153         scilab_setInternalError(env, L"setComplexPolyArray", _W("var must be a polynomial complex variable"));
154         return STATUS_ERROR;
155     }
156 #endif
157
158     if (index < 0 || index >= p->getSize())
159     {
160 #ifdef __API_SCILAB_SAFE__
161         scilab_setInternalError(env, L"setComplexPolyArray", _W("index out of bounds"));
162 #endif
163         return STATUS_ERROR;
164     }
165
166     types::SinglePoly* sp = p->get(index);
167     if (sp)
168     {
169         sp->setRank(rank);
170         sp->set(real);
171         sp->setImg(img);
172     }
173     else
174     {
175         sp = new types::SinglePoly();
176         sp->setRank(rank);
177         sp->set(real);
178         sp->setImg(img);
179         p->set(index, sp);
180     }
181
182     return STATUS_OK;
183 }