Coverity: graphics module resource leaks fixed
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_grayplot.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_grayplot.c                                                   */
20 /* desc : interface for grayplot 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 "sciCall.h"
29 #include "localization.h"
30 #include "Scierror.h"
31
32 /*--------------------------------------------------------------------------*/
33 int sci_grayplot(char *fname, void *pvApiCtx)
34 {
35     SciErr sciErr;
36     int frame_def = 8;
37     int *frame = &frame_def;
38     int axes_def = 1;
39     int *axes = &axes_def;
40     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
41     static rhs_opts opts[] =
42     {
43         { -1, "axesflag", -1, 0, 0, NULL},
44         { -1, "frameflag", -1, 0, 0, NULL},
45         { -1, "logflag", -1, 0, 0, NULL},
46         { -1, "nax", -1, 0, 0, NULL},
47         { -1, "rect", -1, 0, 0, NULL},
48         { -1, "strf", -1, 0, 0, NULL},
49         { -1, NULL, -1, 0, 0, NULL}
50     };
51
52     char   * strf    = NULL ;
53     BOOL freeStrf = FALSE;
54     char strfl[4];
55     double* rect    = NULL ;
56     int    * nax     = NULL ;
57     BOOL     flagNax = FALSE;
58     char* logFlags = NULL;
59
60     int* piAddr1 = NULL;
61     int* piAddr2 = NULL;
62     int* piAddr3 = NULL;
63
64     double* l1 = NULL;
65     double* l2 = NULL;
66     double* l3 = NULL;
67
68     if (nbInputArgument(pvApiCtx) <= 0)
69     {
70         sci_demo(fname, pvApiCtx);
71         return 0;
72     }
73     CheckInputArgument(pvApiCtx, 3, 7);
74
75     if (getOptionals(pvApiCtx, fname, opts) == 0)
76     {
77         ReturnArguments(pvApiCtx);
78         return 0;
79     }
80
81     if (FirstOpt(pvApiCtx) < 4)
82     {
83         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
84                  fname, 1, 4);
85         return -1;
86     }
87     //get variable address
88     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
89     if (sciErr.iErr)
90     {
91         printError(&sciErr, 0);
92         return 1;
93     }
94
95     // Retrieve a matrix of double at position 1.
96     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
97     if (sciErr.iErr)
98     {
99         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
100         printError(&sciErr, 0);
101         return 1;
102     }
103
104     //CheckVector
105     if (m1 != 1 && n1 != 1)
106     {
107         Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 1);
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     //CheckVector
129     if (m2 != 1 && n2 != 1)
130     {
131         Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
132         return 1;
133     }
134
135     //get variable address
136     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
137     if (sciErr.iErr)
138     {
139         printError(&sciErr, 0);
140         return 1;
141     }
142
143     // Retrieve a matrix of double at position 3.
144     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
145     if (sciErr.iErr)
146     {
147         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
148         printError(&sciErr, 0);
149         return 1;
150     }
151
152     if (m3 * n3 == 0)
153     {
154         AssignOutputVariable(pvApiCtx, 1) = 0;
155         ReturnArguments(pvApiCtx);
156         return 0;
157     }
158
159     //CheckDimProp
160     if (m2 * n2 != n3)
161     {
162         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
163         return 1;
164     }
165
166     //CheckDimProp
167     if (m1 * n1 != m3)
168     {
169         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
170         return 1;
171     }
172
173
174     if (get_strf_arg(pvApiCtx, fname, 4, opts, &strf) == 0)
175     {
176         return 0;
177     }
178     freeStrf = !isDefStrf(strf);
179     if (get_rect_arg(pvApiCtx, fname, 5, opts, &rect) == 0)
180     {
181         if (freeStrf)
182         {
183             freeAllocatedSingleString(strf);
184         }
185         return 0;
186     }
187     if (get_nax_arg(pvApiCtx, 6, opts, &nax, &flagNax)==0)
188     {
189         if (freeStrf)
190         {
191             freeAllocatedSingleString(strf);
192         }
193         return 0;
194     }
195     if (get_logflags_arg(pvApiCtx, fname, 7, opts, &logFlags) == 0)
196     {
197         if (freeStrf)
198         {
199             freeAllocatedSingleString(strf);
200         }
201         return 0;
202     }
203
204     getOrCreateDefaultSubwin();
205
206     if (isDefStrf(strf))
207     {
208         strcpy(strfl, DEFSTRFN);
209
210         strf = strfl;
211         if (!isDefRect(rect))
212         {
213             strfl[1] = '7';
214         }
215
216         if (get_optional_int_arg(pvApiCtx, fname, 7, "frameflag", &frame, 1, opts) == 0)
217         {
218             return 0;
219         }
220         if (frame != &frame_def)
221         {
222             strfl[1] = (char)(*frame + 48);
223         }
224         if (get_optional_int_arg(pvApiCtx, fname, 7, "axesflag", &axes, 1, opts) == 0)
225         {
226             return 0;
227         }
228         if (axes != &axes_def)
229         {
230             strfl[2] = (char)(*axes + 48);
231         }
232     }
233
234     Objgrayplot ((l1), (l2), (l3), &m3, &n3, strf, rect, nax, flagNax, logFlags);
235
236     if (freeStrf)
237     {
238         freeAllocatedSingleString(strf);
239     }
240     AssignOutputVariable(pvApiCtx, 1) = 0;
241     ReturnArguments(pvApiCtx);
242     return 0;
243 }
244 /*--------------------------------------------------------------------------*/