Coverity: graphics module resource leaks fixed
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_fec.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  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
6  *
7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  */
17
18 /*------------------------------------------------------------------------*/
19 /* file: sci_fec.c                                                        */
20 /* desc : interface for sci_fec routine                                   */
21 /*------------------------------------------------------------------------*/
22 #include <string.h>
23 #include "gw_graphics.h"
24 #include "api_scilab.h"
25 #include "GetCommandArg.h"
26 #include "BuildObjects.h"
27 #include "sciCall.h"
28 #include "DefaultCommandArg.h"
29 #include "localization.h"
30 #include "Scierror.h"
31
32 /*--------------------------------------------------------------------------*/
33 int sci_fec(char *fname, void *pvApiCtx)
34 {
35     SciErr sciErr;
36     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, mn1 = 0;
37
38     static rhs_opts opts[] =
39     {
40         { -1, "colminmax", -1, 0, 0, NULL},
41         { -1, "colout", -1, 0, 0, NULL},
42         { -1, "leg", -1, 0, 0, NULL},
43         { -1, "mesh", -1, 0, 0, NULL},
44         { -1, "nax", -1, 0, 0, NULL},
45         { -1, "rect", -1, 0, 0, NULL},
46         { -1, "strf", -1, 0, 0, NULL},
47         { -1, "zminmax", -1, 0, 0, NULL},
48         { -1, NULL, -1, 0, 0, NULL}
49     };
50
51     char* strf      = NULL;
52     char strfl[4];
53     char* legend    = NULL;
54     double* rect    = NULL;
55     double* zminmax = NULL;
56     int* colminmax  = NULL;
57     int* nax        = NULL;
58     int* colOut     = NULL;
59     BOOL flagNax    = FALSE;
60     BOOL withMesh   = FALSE;
61     BOOL freeLegend = FALSE;
62     BOOL freeStrf = FALSE;
63
64     int* piAddr1 = NULL;
65     int* piAddr2 = NULL;
66     int* piAddr3 = NULL;
67     int* piAddr4 = NULL;
68
69     double* l1 = NULL;
70     double* l2 = NULL;
71     double* l3 = NULL;
72     double* l4 = NULL;
73
74     if (nbInputArgument(pvApiCtx) <= 0)
75     {
76         sci_demo(fname, pvApiCtx);
77         return 0;
78     }
79
80     CheckInputArgument(pvApiCtx, 4, 12);
81
82     if (getOptionals(pvApiCtx, fname, opts) == 0)
83     {
84         ReturnArguments(pvApiCtx);
85         return 0;
86     }
87
88     if (FirstOpt(pvApiCtx) < 5)
89     {
90         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
91         return -1;
92     }
93
94     //get variable address
95     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
96     if (sciErr.iErr)
97     {
98         printError(&sciErr, 0);
99         return 1;
100     }
101
102     // Retrieve a matrix of double at position 1.
103     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
104     if (sciErr.iErr)
105     {
106         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
107         printError(&sciErr, 0);
108         return 1;
109     }
110
111     //get variable address
112     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
113     if (sciErr.iErr)
114     {
115         printError(&sciErr, 0);
116         return 1;
117     }
118
119     // Retrieve a matrix of double at position 2.
120     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
121     if (sciErr.iErr)
122     {
123         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
124         printError(&sciErr, 0);
125         return 1;
126     }
127
128     //CheckSameDims
129     if (m1 != m2 || n1 != n2)
130     {
131         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
132         return 1;
133     }
134
135
136     //get variable address
137     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
138     if (sciErr.iErr)
139     {
140         printError(&sciErr, 0);
141         return 1;
142     }
143
144     // Retrieve a matrix of double at position 3.
145     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
146     if (sciErr.iErr)
147     {
148         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
149         printError(&sciErr, 0);
150         return 1;
151     }
152
153     if (n3 < 5)
154     {
155         Scierror(999, _("%s: Wrong number of columns for input argument #%d: at least %d expected.\n"), fname, 3, 5);
156         return 0;
157     }
158     // remove number and flag
159     n3 -= 2;
160
161     //get variable address
162     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
163     if (sciErr.iErr)
164     {
165         printError(&sciErr, 0);
166         return 1;
167     }
168
169     // Retrieve a matrix of double at position 4.
170     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
171     if (sciErr.iErr)
172     {
173         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
174         printError(&sciErr, 0);
175         return 1;
176     }
177
178
179     if (m1 * n1 == 0 || m3 == 0)
180     {
181         AssignOutputVariable(pvApiCtx, 1) = 0;
182         ReturnArguments(pvApiCtx);
183         return 0;
184     }
185
186     if (get_strf_arg(pvApiCtx, fname, 5, opts, &strf) == 0)
187     {
188         return 0;
189     }
190     freeStrf = !isDefStrf(strf);
191     if (get_legend_arg(pvApiCtx, fname, 6, opts, &legend) == 0)
192     {
193         if (freeStrf)
194         {
195             freeAllocatedSingleString(strf);
196         }
197         return 0;
198     }
199     freeLegend = !isDefLegend(legend);
200     if (get_rect_arg(pvApiCtx, fname, 7, opts, &rect) == 0)
201     {
202         if (freeStrf)
203         {
204             freeAllocatedSingleString(strf);
205         }
206         if (freeLegend)
207         {
208             freeAllocatedSingleString(legend);
209         }
210         return 0;
211     }
212     if (get_nax_arg(pvApiCtx, 8, opts, &nax, &flagNax)==0)
213     {
214         if (freeStrf)
215         {
216             freeAllocatedSingleString(strf);
217         }
218         if (freeLegend)
219         {
220             freeAllocatedSingleString(legend);
221         }
222         return 0;
223     }
224     if (get_zminmax_arg(pvApiCtx, fname, 9, opts, &zminmax) == 0)
225     {
226         if (freeStrf)
227         {
228             freeAllocatedSingleString(strf);
229         }
230         if (freeLegend)
231         {
232             freeAllocatedSingleString(legend);
233         }
234         return 0;
235     }
236     if (get_colminmax_arg(pvApiCtx, fname, 10, opts, &colminmax)==0)
237     {
238         if (freeStrf)
239         {
240             freeAllocatedSingleString(strf);
241         }
242         if (freeLegend)
243         {
244             freeAllocatedSingleString(legend);
245         }
246         return 0;
247     }
248     if (get_colout_arg(pvApiCtx, fname, 11, opts, &colOut)==0)
249     {
250         if (freeStrf)
251         {
252             freeAllocatedSingleString(strf);
253         }
254         if (freeLegend)
255         {
256             freeAllocatedSingleString(legend);
257         }
258         return 0;
259     }
260     if (get_with_mesh_arg(pvApiCtx, fname, 12, opts, &withMesh)==0)
261     {
262         if (freeStrf)
263         {
264             freeAllocatedSingleString(strf);
265         }
266         if (freeLegend)
267         {
268             freeAllocatedSingleString(legend);
269         }
270         return 0;
271     }
272
273     getOrCreateDefaultSubwin();
274
275     if (isDefStrf (strf))
276     {
277         strcpy(strfl, DEFSTRFN);
278
279         strf = strfl;
280         if (!isDefRect(rect))
281         {
282             strfl[1] = '7';
283         }
284         if (!isDefLegend(legend))
285         {
286             strfl[0] = '1';
287         }
288     }
289     mn1 = m1 * n1;
290
291     Objfec ((l1), (l2), (l3), (l4), &mn1, &m3, &n3, strf, legend, rect, nax, zminmax, colminmax, colOut, withMesh, flagNax);
292
293     if (freeStrf)
294     {
295         freeAllocatedSingleString(strf);
296     }
297     if (freeLegend)
298     {
299         freeAllocatedSingleString(legend);
300     }
301     AssignOutputVariable(pvApiCtx, 1) = 0;
302     ReturnArguments(pvApiCtx);
303
304     return 0;
305 }
306
307 /*--------------------------------------------------------------------------*/