Graphics: avoid crash due to scope problem
[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  * 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_champ.c                                                      */
17 /* desc : interface for champ (and champ1) routine                        */
18 /*------------------------------------------------------------------------*/
19
20 #include "gw_graphics.h"
21 #include "api_scilab.h"
22 #include "GetCommandArg.h"
23 #include "BuildObjects.h"
24 #include "DefaultCommandArg.h"
25 #include "Champ.h"
26 #include "localization.h"
27 #include "Scierror.h"
28 /*--------------------------------------------------------------------------*/
29 int sci_champ (char *fname, unsigned long fname_len)
30 {
31     return sci_champ_G(fname, C2F(champ), fname_len);
32 }
33 /*--------------------------------------------------------------------------*/
34 int sci_champ1 (char *fname, unsigned long fname_len)
35 {
36     return sci_champ_G(fname, C2F(champ1), fname_len);
37 }
38 /*--------------------------------------------------------------------------*/
39 int sci_champ_G(char *fname,
40                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
41                 unsigned long fname_len)
42 {
43     SciErr sciErr;
44     double arfact_def = 1.0;
45     double* arfact = &arfact_def;
46     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
47     static rhs_opts opts[] =
48     {
49         { -1, "arfact", -1, 0, 0, NULL},
50         { -1, "rect", -1, 0, 0, NULL},
51         { -1, "strf", -1, 0, 0, NULL},
52         { -1, NULL, -1, 0, 0, NULL}
53     };
54
55     char   * strf = NULL;
56     char strfl[4];
57     double* rect = NULL;
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     CheckInputArgument(pvApiCtx, -1, 7);
70     CheckOutputArgument(pvApiCtx, 0, 1);
71
72     if (nbInputArgument(pvApiCtx) <= 0)
73     {
74         sci_demo(fname, fname_len);
75         return 0;
76     }
77     else if (nbInputArgument(pvApiCtx) < 4)
78     {
79         Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
80         return 0;
81     }
82
83     if (getOptionals(pvApiCtx, fname, opts) == 0)
84     {
85         return 0;
86     }
87
88     if (FirstOpt() < 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     //get variable address
129     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
130     if (sciErr.iErr)
131     {
132         printError(&sciErr, 0);
133         return 1;
134     }
135
136     // Retrieve a matrix of double at position 3.
137     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
138     if (sciErr.iErr)
139     {
140         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
141         printError(&sciErr, 0);
142         return 1;
143     }
144
145     //get variable address
146     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
147     if (sciErr.iErr)
148     {
149         printError(&sciErr, 0);
150         return 1;
151     }
152
153     // Retrieve a matrix of double at position 4.
154     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
155     if (sciErr.iErr)
156     {
157         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
158         printError(&sciErr, 0);
159         return 1;
160     }
161
162     //CheckSameDims
163     if (m3 != m4 || n3 != n4)
164     {
165         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
166         return 1;
167     }
168
169     //CheckDimProp
170     if (m2 * n2 != n3)
171     {
172         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
173         return 1;
174     }
175
176     //CheckDimProp
177     if (m1 * n1 != m3)
178     {
179         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
180         return 1;
181     }
182
183     if (m3 * n3 == 0)
184     {
185         AssignOutputVariable(pvApiCtx, 1) = 0;
186         ReturnArguments(pvApiCtx);
187         return 0;
188     }
189
190     GetOptionalDoubleArg(pvApiCtx, fname, 5, "arfact", &arfact, 1, opts);
191     GetRect(pvApiCtx, fname, 6, opts, &rect);
192     GetStrf(pvApiCtx, fname, 7, opts, &strf);
193
194     getOrCreateDefaultSubwin();
195
196     if (isDefStrf(strf))
197     {
198         strcpy(strfl, DEFSTRFN);
199         strf = strfl;
200         if (!isDefRect(rect))
201         {
202             strf[1] = '5';
203         }
204     }
205
206     (*func)((l1), (l2), (l3), (l4), &m3, &n3, strf, rect, arfact, 4L);
207     AssignOutputVariable(pvApiCtx, 1) = 0;
208     ReturnArguments(pvApiCtx);
209     return 0;
210 }
211 /*--------------------------------------------------------------------------*/