Coverity: graphics module resource leaks fixed
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_champ.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_champ.c                                                      */
20 /* desc : interface for champ (and champ1) 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 "DefaultCommandArg.h"
28 #include "Champ.h"
29 #include "localization.h"
30 #include "Scierror.h"
31 /*--------------------------------------------------------------------------*/
32 int sci_champ (char *fname, void *pvApiCtx)
33 {
34     return sci_champ_G(fname, C2F(champ), pvApiCtx);
35 }
36 /*--------------------------------------------------------------------------*/
37 int sci_champ1 (char *fname, void *pvApiCtx)
38 {
39     return sci_champ_G(fname, C2F(champ1), pvApiCtx);
40 }
41 /*--------------------------------------------------------------------------*/
42 int sci_champ_G(char *fname,
43                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
44                 void *pvApiCtx)
45 {
46     SciErr sciErr;
47     double arfact_def = 1.0;
48     double* arfact = &arfact_def;
49     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
50     static rhs_opts opts[] =
51     {
52         { -1, "arfact", -1, 0, 0, NULL},
53         { -1, "rect", -1, 0, 0, NULL},
54         { -1, "strf", -1, 0, 0, NULL},
55         { -1, NULL, -1, 0, 0, NULL}
56     };
57
58     char   * strf = NULL;
59     BOOL freeStrf = FALSE;
60     char strfl[4];
61     double* rect = NULL;
62
63     int* piAddr1 = NULL;
64     int* piAddr2 = NULL;
65     int* piAddr3 = NULL;
66     int* piAddr4 = NULL;
67
68     double* l1 = NULL;
69     double* l2 = NULL;
70     double* l3 = NULL;
71     double* l4 = NULL;
72
73     CheckInputArgument(pvApiCtx, -1, 7);
74     CheckOutputArgument(pvApiCtx, 0, 1);
75
76     if (nbInputArgument(pvApiCtx) <= 0)
77     {
78         sci_demo(fname, pvApiCtx);
79         return 0;
80     }
81     else if (nbInputArgument(pvApiCtx) < 4)
82     {
83         Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
84         return 0;
85     }
86
87     if (getOptionals(pvApiCtx, fname, opts) == 0)
88     {
89         return 0;
90     }
91
92     if (FirstOpt(pvApiCtx) < 5)
93     {
94         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
95         return -1;
96     }
97
98     //get variable address
99     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
100     if (sciErr.iErr)
101     {
102         printError(&sciErr, 0);
103         return 1;
104     }
105
106     // Retrieve a matrix of double at position 1.
107     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
108     if (sciErr.iErr)
109     {
110         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
111         printError(&sciErr, 0);
112         return 1;
113     }
114
115     //get variable address
116     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
117     if (sciErr.iErr)
118     {
119         printError(&sciErr, 0);
120         return 1;
121     }
122
123     // Retrieve a matrix of double at position 2.
124     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
125     if (sciErr.iErr)
126     {
127         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
128         printError(&sciErr, 0);
129         return 1;
130     }
131
132     //get variable address
133     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
134     if (sciErr.iErr)
135     {
136         printError(&sciErr, 0);
137         return 1;
138     }
139
140     // Retrieve a matrix of double at position 3.
141     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
142     if (sciErr.iErr)
143     {
144         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
145         printError(&sciErr, 0);
146         return 1;
147     }
148
149     //get variable address
150     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
151     if (sciErr.iErr)
152     {
153         printError(&sciErr, 0);
154         return 1;
155     }
156
157     // Retrieve a matrix of double at position 4.
158     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
159     if (sciErr.iErr)
160     {
161         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
162         printError(&sciErr, 0);
163         return 1;
164     }
165
166     //CheckSameDims
167     if (m3 != m4 || n3 != n4)
168     {
169         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
170         return 1;
171     }
172
173     //CheckDimProp
174     if (m2 * n2 != n3)
175     {
176         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
177         return 1;
178     }
179
180     //CheckDimProp
181     if (m1 * n1 != m3)
182     {
183         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
184         return 1;
185     }
186
187     if (m3 * n3 == 0)
188     {
189         AssignOutputVariable(pvApiCtx, 1) = 0;
190         ReturnArguments(pvApiCtx);
191         return 0;
192     }
193
194     if (get_optional_double_arg(pvApiCtx, fname, 5, "arfact", &arfact, 1, opts) == 0)
195     {
196         return 0;
197     }
198     if (get_rect_arg(pvApiCtx, fname, 6, opts, &rect) == 0)
199     {
200         return 0;
201     }
202     if (get_strf_arg(pvApiCtx, fname, 7, opts, &strf) == 0)
203     {
204         return 0;
205     }
206     freeStrf = !isDefStrf(strf);
207
208     getOrCreateDefaultSubwin();
209
210     if (isDefStrf(strf))
211     {
212         strcpy(strfl, DEFSTRFN);
213         strf = strfl;
214         if (!isDefRect(rect))
215         {
216             strf[1] = '5';
217         }
218     }
219
220     (*func)((l1), (l2), (l3), (l4), &m3, &n3, strf, rect, arfact, 4L);
221     if (freeStrf)
222     {
223         freeAllocatedSingleString(strf);
224     }
225     AssignOutputVariable(pvApiCtx, 1) = 0;
226     ReturnArguments(pvApiCtx);
227     return 0;
228 }
229 /*--------------------------------------------------------------------------*/