Coverity: graphics module resource leaks fixed
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_param3d1.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 /*------------------------------------------------------------------------*/
18 /* file: sci_param3d1.h                                                   */
19 /* desc : interface for param3d1 routine                                  */
20 /*------------------------------------------------------------------------*/
21 #include <string.h>
22 #include "gw_graphics.h"
23 #include "GetCommandArg.h"
24 #include "BuildObjects.h"
25 #include "sciCall.h"
26 #include "sci_malloc.h"
27 #include "api_scilab.h"
28 #include "localization.h"
29 #include "Scierror.h"
30 #include "DefaultCommandArg.h"
31 /*--------------------------------------------------------------------------*/
32 int sci_param3d1(char *fname, void *pvApiCtx)
33 {
34     SciErr sciErr;
35     int izcol = 0, isfac = 0;
36     double *zcol = NULL;
37     static double  ebox_def [6] = { 0, 1, 0, 1, 0, 1};
38     double *ebox = ebox_def;
39     static int iflag_def[3] = {1, 2, 4};
40     int iflag[3] , *ifl = NULL;
41     double  alpha_def = 35.0 , theta_def = 45.0;
42     double *alpha = &alpha_def, *theta = &theta_def;
43     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
44     int m3n = 0, n3n = 0, m3l = 0;
45     static rhs_opts opts[] =
46     {
47         { -1, "alpha", -1, 0, 0, NULL},
48         { -1, "ebox", -1, 0, 0, NULL},
49         { -1, "flag", -1, 0, 0, NULL},
50         { -1, "leg", -1, 0, 0, NULL},
51         { -1, "theta", -1, 0, 0, NULL},
52         { -1, NULL, -1, 0, 0, NULL}
53     };
54
55     char * labels = NULL;
56     BOOL freeLabels = FALSE;
57
58     int* piAddr1  = NULL;
59     int* piAddr2  = NULL;
60     int* piAddr3  = NULL;
61     int* piAddr31 = NULL;
62     int* piAddr32 = NULL;
63
64     double* l1  = NULL;
65     double* l2  = NULL;
66     double* l3  = NULL;
67     double* l3n = NULL;
68
69     if (nbInputArgument(pvApiCtx) <= 0)
70     {
71         sci_demo(fname, pvApiCtx);
72         return 0;
73     }
74
75     CheckInputArgument(pvApiCtx, 3, 8);
76
77     if (getOptionals(pvApiCtx, fname, opts) == 0)
78     {
79         ReturnArguments(pvApiCtx);
80         return 0;
81     }
82
83     if (FirstOpt(pvApiCtx) < 4)
84     {
85         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4);
86         return (0);
87     }
88
89     //get variable address
90     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
91     if (sciErr.iErr)
92     {
93         printError(&sciErr, 0);
94         return 1;
95     }
96
97     // Retrieve a matrix of double at position 1.
98     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1); /* x */
99     if (sciErr.iErr)
100     {
101         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
102         printError(&sciErr, 0);
103         return 1;
104     }
105
106     if (m1 == 1 && n1 > 1)
107     {
108         m1 = n1;
109         n1 = 1;
110     }
111
112     //get variable address
113     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
114     if (sciErr.iErr)
115     {
116         printError(&sciErr, 0);
117         return 1;
118     }
119
120     // Retrieve a matrix of double at position 2.
121     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2); /* y */
122     if (sciErr.iErr)
123     {
124         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
125         printError(&sciErr, 0);
126         return 1;
127     }
128
129     if (m2 == 1 && n2 > 1)
130     {
131         m2 = n2;
132         n2 = 1;
133     }
134
135     if (m1 * n1 == 0)
136     {
137         AssignOutputVariable(pvApiCtx, 1) = 0;
138         ReturnArguments(pvApiCtx);
139         return 0;
140     }
141     //CheckSameDims
142     if (m1 != m2 || n1 != n2)
143     {
144         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
145         return 1;
146     }
147
148     //get variable address
149     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
150     if (sciErr.iErr)
151     {
152         printError(&sciErr, 0);
153         return 1;
154     }
155
156     switch (getInputArgumentType(pvApiCtx, 3))
157     {
158         case 1 :
159             izcol = 0;
160
161             // Retrieve a matrix of double at position 3.
162             // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l3".
163             sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3); /* z */
164             if (sciErr.iErr)
165             {
166                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
167                 printError(&sciErr, 0);
168                 return 1;
169             }
170
171             break;
172         case 15 :
173             izcol = 1;
174             /* z = list(z,colors) */
175             sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l);
176             if (sciErr.iErr)
177             {
178                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
179                 printError(&sciErr, 0);
180                 return 1;
181             }
182
183             if (m3l != 2)
184             {
185                 Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
186                          fname, 2, m3l, 2);
187                 return 0;
188             }
189
190             sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31);
191             if (sciErr.iErr)
192             {
193                 printError(&sciErr, 0);
194                 return 1;
195             }
196
197             sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */
198             if (sciErr.iErr)
199             {
200                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
201                 printError(&sciErr, 0);
202                 return 1;
203             }
204
205             sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32);
206             if (sciErr.iErr)
207             {
208                 printError(&sciErr, 0);
209                 return 1;
210             }
211
212             sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */
213             if (sciErr.iErr)
214             {
215                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
216                 printError(&sciErr, 0);
217                 return 1;
218             }
219
220             zcol  = (l3n);
221             if (m3n * n3n != n3)
222             {
223                 Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 3, n3);
224                 return 0;
225             }
226             break;
227         default :
228             OverLoad(3);
229             return 0;
230     }
231
232     if (m3 == 1 && n3 > 1)
233     {
234         m3 = n3;
235         n3 = 1;
236     }
237     //CheckSameDims
238     if (m1 != m3 || n1 != n3)
239     {
240         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
241         return 1;
242     }
243
244
245     if (get_optional_double_arg(pvApiCtx, fname, 4, "theta", &theta, 1, opts) == 0)
246     {
247         return 0;
248     }
249     if (get_optional_double_arg(pvApiCtx, fname, 5, "alpha", &alpha, 1, opts) == 0)
250     {
251         return 0;
252     }
253     if (get_labels_arg(pvApiCtx, fname, 6, opts, &labels) == 0)
254     {
255         return 0;
256     }
257     freeLabels = !isDefLegend(labels);
258     iflag_def[1] = 8;
259     ifl = &(iflag_def[1]);
260     if (get_optional_int_arg(pvApiCtx, fname, 7, "flag", &ifl, 2, opts) == 0)
261     {
262         if (freeLabels)
263         {
264             freeAllocatedSingleString(labels);
265         }
266         return 0;
267     }
268     iflag[0] = iflag_def[0];
269     iflag[1] = ifl[0];
270     iflag[2] = ifl[1];
271
272     if (get_optional_double_arg(pvApiCtx, fname, 8, "ebox", &ebox, 6, opts) == 0)
273     {
274         if (freeLabels)
275         {
276             freeAllocatedSingleString(labels);
277         }
278         return 0;
279     }
280
281     getOrCreateDefaultSubwin();
282
283     /* NG beg */
284     isfac = -1;
285
286     Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m1, &n1, theta, alpha, labels, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04*/
287
288     if (freeLabels)
289     {
290         freeAllocatedSingleString(labels);
291     }
292     AssignOutputVariable(pvApiCtx, 1) = 0;
293     ReturnArguments(pvApiCtx);
294     return 0;
295 }
296 /*--------------------------------------------------------------------------*/