Coverity #1097868, #1097733 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 /*--------------------------------------------------------------------------*/
31 int sci_param3d1(char *fname, void *pvApiCtx)
32 {
33     SciErr sciErr;
34     int izcol = 0, isfac = 0;
35     double *zcol = NULL;
36     static double  ebox_def [6] = { 0, 1, 0, 1, 0, 1};
37     double *ebox = ebox_def;
38     static int iflag_def[3] = {1, 2, 4};
39     int iflag[3] , *ifl = NULL;
40     double  alpha_def = 35.0 , theta_def = 45.0;
41     double *alpha = &alpha_def, *theta = &theta_def;
42     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
43     int m3n = 0, n3n = 0, m3l = 0;
44     static rhs_opts opts[] =
45     {
46         { -1, "alpha", -1, 0, 0, NULL},
47         { -1, "ebox", -1, 0, 0, NULL},
48         { -1, "flag", -1, 0, 0, NULL},
49         { -1, "leg", -1, 0, 0, NULL},
50         { -1, "theta", -1, 0, 0, NULL},
51         { -1, NULL, -1, 0, 0, NULL}
52     };
53
54     char * labels = NULL;
55
56     int* piAddr1  = NULL;
57     int* piAddr2  = NULL;
58     int* piAddr3  = NULL;
59     int* piAddr31 = NULL;
60     int* piAddr32 = NULL;
61
62     double* l1  = NULL;
63     double* l2  = NULL;
64     double* l3  = NULL;
65     double* l3n = NULL;
66
67     if (nbInputArgument(pvApiCtx) <= 0)
68     {
69         sci_demo(fname, pvApiCtx);
70         return 0;
71     }
72
73     CheckInputArgument(pvApiCtx, 3, 8);
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"), fname, 1, 4);
84         return (0);
85     }
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); /* x */
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     if (m1 == 1 && n1 > 1)
105     {
106         m1 = n1;
107         n1 = 1;
108     }
109
110     //get variable address
111     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
112     if (sciErr.iErr)
113     {
114         printError(&sciErr, 0);
115         return 1;
116     }
117
118     // Retrieve a matrix of double at position 2.
119     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2); /* y */
120     if (sciErr.iErr)
121     {
122         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
123         printError(&sciErr, 0);
124         return 1;
125     }
126
127     if (m2 == 1 && n2 > 1)
128     {
129         m2 = n2;
130         n2 = 1;
131     }
132
133     if (m1 * n1 == 0)
134     {
135         AssignOutputVariable(pvApiCtx, 1) = 0;
136         ReturnArguments(pvApiCtx);
137         return 0;
138     }
139     //CheckSameDims
140     if (m1 != m2 || n1 != n2)
141     {
142         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
143         return 1;
144     }
145
146     //get variable address
147     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
148     if (sciErr.iErr)
149     {
150         printError(&sciErr, 0);
151         return 1;
152     }
153
154     switch (getInputArgumentType(pvApiCtx, 3))
155     {
156         case 1 :
157             izcol = 0;
158
159             // Retrieve a matrix of double at position 3.
160             // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l3".
161             sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3); /* z */
162             if (sciErr.iErr)
163             {
164                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
165                 printError(&sciErr, 0);
166                 return 1;
167             }
168
169             break;
170         case 15 :
171             izcol = 1;
172             /* z = list(z,colors) */
173             sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l);
174             if (sciErr.iErr)
175             {
176                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
177                 printError(&sciErr, 0);
178                 return 1;
179             }
180
181             if (m3l != 2)
182             {
183                 Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
184                          fname, 2, m3l, 2);
185                 return 0;
186             }
187
188             sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31);
189             if (sciErr.iErr)
190             {
191                 printError(&sciErr, 0);
192                 return 1;
193             }
194
195             sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */
196             if (sciErr.iErr)
197             {
198                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
199                 printError(&sciErr, 0);
200                 return 1;
201             }
202
203             sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32);
204             if (sciErr.iErr)
205             {
206                 printError(&sciErr, 0);
207                 return 1;
208             }
209
210             sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */
211             if (sciErr.iErr)
212             {
213                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
214                 printError(&sciErr, 0);
215                 return 1;
216             }
217
218             zcol  = (l3n);
219             if (m3n * n3n != n3)
220             {
221                 Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 3, n3);
222                 return 0;
223             }
224             break;
225         default :
226             OverLoad(3);
227             return 0;
228     }
229
230     if (m3 == 1 && n3 > 1)
231     {
232         m3 = n3;
233         n3 = 1;
234     }
235     //CheckSameDims
236     if (m1 != m3 || n1 != n3)
237     {
238         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
239         return 1;
240     }
241
242
243     if (get_optional_double_arg(pvApiCtx, fname, 4, "theta", &theta, 1, opts) == 0)
244     {
245         return 0;
246     }
247     if (get_optional_double_arg(pvApiCtx, fname, 5, "alpha", &alpha, 1, opts) == 0)
248     {
249         return 0;
250     }
251     if (get_labels_arg(pvApiCtx, fname, 6, opts, &labels) == 0)
252     {
253         return 0;
254     }
255     iflag_def[1] = 8;
256     ifl = &(iflag_def[1]);
257     if (get_optional_int_arg(pvApiCtx, fname, 7, "flag", &ifl, 2, opts) == 0)
258     {
259         return 0;
260     }
261     iflag[0] = iflag_def[0];
262     iflag[1] = ifl[0];
263     iflag[2] = ifl[1];
264
265     if (get_optional_double_arg(pvApiCtx, fname, 8, "ebox", &ebox, 6, opts) == 0)
266     {
267         return 0;
268     }
269
270     getOrCreateDefaultSubwin();
271
272     /* NG beg */
273     isfac = -1;
274
275     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*/
276
277     AssignOutputVariable(pvApiCtx, 1) = 0;
278     ReturnArguments(pvApiCtx);
279     return 0;
280 }
281 /*--------------------------------------------------------------------------*/