Graphics: avoid crash due to scope problem
[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  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 /*------------------------------------------------------------------------*/
16 /* file: sci_fec.c                                                        */
17 /* desc : interface for sci_fec routine                                   */
18 /*------------------------------------------------------------------------*/
19
20 #include "gw_graphics.h"
21 #include "api_scilab.h"
22 #include "GetCommandArg.h"
23 #include "BuildObjects.h"
24 #include "sciCall.h"
25 #include "DefaultCommandArg.h"
26 #include "localization.h"
27 #include "Scierror.h"
28
29 /*--------------------------------------------------------------------------*/
30 int sci_fec(char *fname, unsigned long fname_len)
31 {
32     SciErr sciErr;
33     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, mn1 = 0;
34
35     static rhs_opts opts[] =
36     {
37         { -1, "colminmax", -1, 0, 0, NULL},
38         { -1, "colout", -1, 0, 0, NULL},
39         { -1, "leg", -1, 0, 0, NULL},
40         { -1, "mesh", -1, 0, 0, NULL},
41         { -1, "nax", -1, 0, 0, NULL},
42         { -1, "rect", -1, 0, 0, NULL},
43         { -1, "strf", -1, 0, 0, NULL},
44         { -1, "zminmax", -1, 0, 0, NULL},
45         { -1, NULL, -1, 0, 0, NULL}
46     };
47
48     char* strf      = NULL;
49     char strfl[4];
50     char* legend    = NULL;
51     double* rect    = NULL;
52     double* zminmax = NULL;
53     int* colminmax  = NULL;
54     int* nax        = NULL;
55     int* colOut     = NULL;
56     BOOL flagNax    = FALSE;
57     BOOL withMesh   = FALSE;
58
59     int* piAddr1 = NULL;
60     int* piAddr2 = NULL;
61     int* piAddr3 = NULL;
62     int* piAddr4 = NULL;
63
64     double* l1 = NULL;
65     double* l2 = NULL;
66     double* l3 = NULL;
67     double* l4 = NULL;
68
69     if (nbInputArgument(pvApiCtx) <= 0)
70     {
71         sci_demo(fname, fname_len);
72         return 0;
73     }
74
75     CheckInputArgument(pvApiCtx, 4, 12);
76
77     if (getOptionals(pvApiCtx, fname, opts) == 0)
78     {
79         ReturnArguments(pvApiCtx);
80         return 0;
81     }
82
83     if (FirstOpt() < 5)
84     {
85         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
86         return -1;
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);
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     //get variable address
107     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
108     if (sciErr.iErr)
109     {
110         printError(&sciErr, 0);
111         return 1;
112     }
113
114     // Retrieve a matrix of double at position 2.
115     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
116     if (sciErr.iErr)
117     {
118         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
119         printError(&sciErr, 0);
120         return 1;
121     }
122
123     //CheckSameDims
124     if (m1 != m2 || n1 != n2)
125     {
126         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
127         return 1;
128     }
129
130
131     //get variable address
132     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
133     if (sciErr.iErr)
134     {
135         printError(&sciErr, 0);
136         return 1;
137     }
138
139     // Retrieve a matrix of double at position 3.
140     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
141     if (sciErr.iErr)
142     {
143         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
144         printError(&sciErr, 0);
145         return 1;
146     }
147
148     if (n3 != 5)
149     {
150         Scierror(999, _("%s: Wrong number of columns for input argument #%d: %d expected.\n"), fname, 3, 5);
151         return 0;
152     }
153
154     //get variable address
155     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
156     if (sciErr.iErr)
157     {
158         printError(&sciErr, 0);
159         return 1;
160     }
161
162     // Retrieve a matrix of double at position 4.
163     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
164     if (sciErr.iErr)
165     {
166         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
167         printError(&sciErr, 0);
168         return 1;
169     }
170
171
172     if (m1 * n1 == 0 || m3 == 0)
173     {
174         AssignOutputVariable(pvApiCtx, 1) = 0;
175         ReturnArguments(pvApiCtx);
176         return 0;
177     }
178
179     GetStrf(pvApiCtx, fname, 5, opts, &strf);
180     GetLegend(pvApiCtx, fname, 6, opts, &legend);
181     GetRect(pvApiCtx, fname, 7, opts, &rect);
182     GetNax(pvApiCtx, 8, opts, &nax, &flagNax);
183     GetZminmax(pvApiCtx, fname, 9, opts, &zminmax);
184     GetColminmax(pvApiCtx, fname, 10, opts, &colminmax);
185     GetColOut(pvApiCtx, fname, 11, opts, &colOut);
186     GetWithMesh(pvApiCtx, fname, 12, opts, &withMesh);
187
188     getOrCreateDefaultSubwin();
189
190     if (isDefStrf (strf))
191     {
192         strcpy(strfl, DEFSTRFN);
193
194         strf = strfl;
195         if (!isDefRect(rect))
196         {
197             strfl[1] = '7';
198         }
199         if (!isDefLegend(legend))
200         {
201             strfl[0] = '1';
202         }
203     }
204     mn1 = m1 * n1;
205
206     Objfec ((l1), (l2), (l3), (l4), &mn1, &m3, strf, legend, rect, nax, zminmax, colminmax, colOut, withMesh, flagNax);
207
208     AssignOutputVariable(pvApiCtx, 1) = 0;
209     ReturnArguments(pvApiCtx);
210
211     return 0;
212 }
213
214 /*--------------------------------------------------------------------------*/