utf: module scinotes
[scilab.git] / scilab / modules / scinotes / sci_gateway / cpp / sci_scinotes.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Allan CORNET
4  * Copyright (C) 2009 - DIGITEO - Vincent COUVERT
5  * Copyright (C) 2010 - Calixte DENIZET
6  * Copyright (C) 2010 - ClĂ©ment DAVID
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
13  *
14  */
15
16 #include "SciNotes.hxx"
17 #include "GiwsException.hxx"
18
19 extern "C"
20 {
21 #include <wchar.h>
22 #include "callscinotes.h"
23 #include "gw_scinotes.h"
24 #include "api_scilab.h"
25 #include "localization.h"
26 #include "Scierror.h"
27 #include "sci_malloc.h"
28 #include "freeArrayOfString.h"
29 }
30
31 /*--------------------------------------------------------------------------*/
32 int sci_scinotes(char * fname, void* pvApiCtx)
33 {
34     SciErr sciErr;
35
36     CheckRhs(0, 3);
37     CheckLhs(0, 1);
38
39     if (Rhs == 0)
40     {
41         try
42         {
43             callSciNotesW(NULL, 0);
44         }
45         catch (GiwsException::JniCallMethodException exception)
46         {
47             Scierror(999, "%s: %s\n", fname, exception.getJavaDescription().c_str());
48         }
49         catch (GiwsException::JniException exception)
50         {
51             Scierror(999, "%s: %s\n", fname, exception.whatStr().c_str());
52         }
53     }
54     else
55     {
56         int m1 = 0, n1 = 0;
57         int *piAddressVarOne = NULL;
58         char **pStVarOne = NULL;
59         int i = 0;
60         int iType1 = 0;
61         char *functionName = NULL;
62
63         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
64         if (sciErr.iErr)
65         {
66             printError(&sciErr, 0);
67             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
68             return 0;
69         }
70
71         sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
72         if (sciErr.iErr)
73         {
74             printError(&sciErr, 0);
75             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
76             return 0;
77         }
78
79         if (iType1 != sci_strings)
80         {
81             Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
82             return 0;
83         }
84
85         if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &pStVarOne))
86         {
87             printError(&sciErr, 0);
88             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
89             return 0;
90         }
91
92         if (Rhs >= 2)           //get line numbers
93         {
94             int *piAddressVarTwo = NULL;
95             int m2 = 0, n2 = 0;
96             double *pdblVarTwo = NULL;
97             int iType2 = 0;
98
99             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
100             if (sciErr.iErr)
101             {
102                 printError(&sciErr, 0);
103                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
104                 freeAllocatedMatrixOfString(m1, n1, pStVarOne);
105                 return 0;
106             }
107
108             sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
109             if (sciErr.iErr)
110             {
111                 printError(&sciErr, 0);
112                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
113                 freeAllocatedMatrixOfString(m1, n1, pStVarOne);
114                 return 0;
115             }
116
117             if (iType2 != sci_matrix && iType2 != sci_strings)
118             {
119                 Scierror(999, _("%s: Wrong type for argument #%d: Real matrix or \'readonly\' expected.\n"), fname, 2);
120                 freeAllocatedMatrixOfString(m1, n1, pStVarOne);
121                 return 0;
122             }
123
124             if (iType2 == sci_strings)
125             {
126                 /* get dimensions */
127                 char** pStVarTwo = NULL;
128
129                 if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarTwo, &m2, &n2, &pStVarTwo))
130                 {
131                     printError(&sciErr, 0);
132                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
133                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
134                     return 0;
135                 }
136
137                 try
138                 {
139                     callSciNotesWWithOption(pStVarOne, pStVarTwo, m2 * n2, m1 * n1);
140                 }
141                 catch (GiwsException::JniCallMethodException exception)
142                 {
143                     Scierror(999, "%s: %s\n", fname, exception.getJavaDescription().c_str());
144                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
145                     freeAllocatedMatrixOfString(m2, n2, pStVarTwo);
146                     return 0;
147                 }
148                 catch (GiwsException::JniException exception)
149                 {
150                     Scierror(999, "%s: %s\n", fname, exception.whatStr().c_str());
151                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
152                     freeAllocatedMatrixOfString(m2, n2, pStVarTwo);
153                     return 0;
154                 }
155                 freeAllocatedMatrixOfString(m2, n2, pStVarTwo);
156             }
157             else
158             {
159                 if (isVarComplex(pvApiCtx, piAddressVarTwo) == 1)
160                 {
161                     Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), fname, 2);
162                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
163                     return 0;
164                 }
165
166                 sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo, &m2, &n2, &pdblVarTwo);
167                 if (sciErr.iErr)
168                 {
169                     printError(&sciErr, 0);
170                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
171                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
172                     return 0;
173                 }
174
175                 if (m2 * n2 != m1 * n1)
176                 {
177                     Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Same dimensions expected.\n"), fname, 1, 2);
178                     freeAllocatedMatrixOfString(m1, n1, pStVarOne);
179                     return 0;
180                 }
181
182                 if (Rhs == 3)
183                 {
184                     int *piAddressVarThree = NULL;
185
186                     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
187                     if (sciErr.iErr)
188                     {
189                         printError(&sciErr, 0);
190                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
191                         return 0;
192                     }
193
194                     if (!isStringType(pvApiCtx, piAddressVarThree))
195                     {
196                         Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
197                         freeAllocatedMatrixOfString(m1, n1, pStVarOne);
198                         return 0;
199                     }
200
201                     int ret = getAllocatedSingleString(pvApiCtx, piAddressVarThree, &functionName);
202
203                     if (ret)
204                     {
205                         Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
206                         freeAllocatedMatrixOfString(m1, n1, pStVarOne);
207                         return 0;
208                     }
209                 }
210
211                 try
212                 {
213                     callSciNotesWWithLineNumberAndFunction(pStVarOne, pdblVarTwo, functionName, m1 * n1);
214                 }
215                 catch (GiwsException::JniCallMethodException exception)
216                 {
217                     Scierror(999, "%s: %s\n", fname, exception.getJavaDescription().c_str());
218                 }
219                 catch (GiwsException::JniException exception)
220                 {
221                     Scierror(999, "%s: %s\n", fname, exception.whatStr().c_str());
222                 }
223             }
224         }
225         else
226         {
227             try
228             {
229                 callSciNotesW(pStVarOne, m1 * n1);
230             }
231             catch (GiwsException::JniCallMethodException exception)
232             {
233                 Scierror(999, "%s: %s\n", fname, exception.getJavaDescription().c_str());
234             }
235             catch (GiwsException::JniException exception)
236             {
237                 Scierror(999, "%s: %s\n", fname, exception.whatStr().c_str());
238             }
239         }
240
241         freeAllocatedMatrixOfString(m1, n1, pStVarOne);
242         if (functionName)
243         {
244             freeAllocatedSingleString(functionName);
245         }
246     }
247
248     LhsVar(1) = 0;
249     PutLhsVar();
250     return 0;
251 }
252
253 /*--------------------------------------------------------------------------*/