add some Scierror after printError to create an error in Scilab
[scilab.git] / scilab / modules / fileio / sci_gateway / c / sci_pathconvert.c
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Allan CORNET
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12 /*--------------------------------------------------------------------------*/
13 #include "gw_fileio.h"
14 #include "stack-c.h"
15 #include "MALLOC.h"
16 #include "localization.h"
17 #include "api_scilab.h"
18 #include "Scierror.h"
19 #include "pathconvert.h"
20 #include "freeArrayOfString.h"
21 /*--------------------------------------------------------------------------*/
22 int sci_pathconvert(char *fname, unsigned long fname_len)
23 {
24     SciErr sciErr;
25     int *piAddressVarOne = NULL;
26     wchar_t **pStVarOne = NULL;
27     int iType1 = 0;
28     int *lenStVarOne = NULL;
29     int m1 = 0, n1 = 0;
30
31     wchar_t **results = NULL;
32     int i = 0;
33
34     BOOL flagtrail = TRUE;
35     BOOL flagexpand = TRUE;
36
37     PathConvertType PType = AUTO_STYLE;
38
39     /* Check Input & Output parameters */
40     CheckRhs(1, 4);
41     CheckLhs(1, 1);
42
43     if (Rhs > 3)
44     {
45         int *piAddressVarFour = NULL;
46         wchar_t *pStVarFour = NULL;
47         int iType4 = 0;
48         int lenStVarFour = 0;
49         int m4 = 0, n4 = 0;
50
51         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour);
52         if (sciErr.iErr)
53         {
54             printError(&sciErr, 0);
55             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
56             return 0;
57         }
58
59         sciErr = getVarType(pvApiCtx, piAddressVarFour, &iType4);
60         if (sciErr.iErr)
61         {
62             printError(&sciErr, 0);
63             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
64             return 0;
65         }
66
67         if (iType4 != sci_strings)
68         {
69             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 4);
70             return 0;
71         }
72
73         sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &m4, &n4);
74         if (sciErr.iErr)
75         {
76             printError(&sciErr, 0);
77             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
78             return 0;
79         }
80
81         if ((m4 != n4) && (n4 != 1))
82         {
83             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 4);
84             return 0;
85         }
86
87         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, NULL);
88         if (sciErr.iErr)
89         {
90             printError(&sciErr, 0);
91             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
92             return 0;
93         }
94
95         pStVarFour = (wchar_t *) MALLOC(sizeof(wchar_t) * (lenStVarFour + 1));
96         if (pStVarFour == NULL)
97         {
98             Scierror(999, _("%s: Memory allocation error.\n"), fname);
99             return 0;
100         }
101
102         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, &pStVarFour);
103         if (sciErr.iErr)
104         {
105             printError(&sciErr, 0);
106             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
107             return 0;
108         }
109
110         if ((wcscmp(pStVarFour, L"w") == 0) || (wcscmp(pStVarFour, L"u") == 0))
111         {
112             if (wcscmp(pStVarFour, L"w") == 0)
113             {
114                 PType = WINDOWS_STYLE;
115             }
116             else
117             {
118                 PType = UNIX_STYLE;
119             }
120             if (pStVarFour)
121             {
122                 FREE(pStVarFour);
123                 pStVarFour = NULL;
124             }
125         }
126         else
127         {
128             if (pStVarFour)
129             {
130                 FREE(pStVarFour);
131                 pStVarFour = NULL;
132             }
133             Scierror(999, _("%s: Wrong value for input argument #%d: 'w' or 'u' string expected.\n"), fname, 4);
134             return 0;
135         }
136     }
137
138     if (Rhs > 2)
139     {
140         int *piAddressVarThree = NULL;
141         int *piData = NULL;
142         int iType3 = 0;
143         int m3 = 0, n3 = 0;
144
145         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
146         if (sciErr.iErr)
147         {
148             printError(&sciErr, 0);
149             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
150             return 0;
151         }
152
153         sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
154         if (sciErr.iErr)
155         {
156             printError(&sciErr, 0);
157             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
158             return 0;
159         }
160
161         if (iType3 != sci_boolean)
162         {
163             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
164             return 0;
165         }
166
167         sciErr = getVarDimension(pvApiCtx, piAddressVarThree, &m3, &n3);
168         if (sciErr.iErr)
169         {
170             printError(&sciErr, 0);
171             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
172             return 0;
173         }
174
175         if ((m3 != n3) && (n3 != 1))
176         {
177             Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
178             return 0;
179         }
180
181         sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarThree, &m3, &n3, &piData);
182         if (sciErr.iErr)
183         {
184             printError(&sciErr, 0);
185             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
186             return 0;
187         }
188
189         flagexpand = piData[0];
190     }
191
192     if (Rhs > 1)
193     {
194         int *piAddressVarTwo = NULL;
195         int *piData = NULL;
196         int iType2 = 0;
197         int m2 = 0, n2 = 0;
198
199         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
200         if (sciErr.iErr)
201         {
202             printError(&sciErr, 0);
203             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
204             return 0;
205         }
206
207         sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
208         if (sciErr.iErr)
209         {
210             printError(&sciErr, 0);
211             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
212             return 0;
213         }
214
215         if (iType2 != sci_boolean)
216         {
217             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
218             return 0;
219         }
220
221         sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &m2, &n2);
222         if (sciErr.iErr)
223         {
224             printError(&sciErr, 0);
225             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
226             return 0;
227         }
228
229         if ((m2 != n2) && (n2 != 1))
230         {
231             Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 2);
232             return 0;
233         }
234
235         sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &piData);
236         if (sciErr.iErr)
237         {
238             printError(&sciErr, 0);
239             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
240             return 0;
241         }
242
243         flagtrail = piData[0];
244     }
245
246     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
247     if (sciErr.iErr)
248     {
249         printError(&sciErr, 0);
250         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
251         return 0;
252     }
253
254     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
255     if (sciErr.iErr)
256     {
257         printError(&sciErr, 0);
258         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
259         return 0;
260     }
261
262     if (iType1 == sci_matrix)
263     {
264         sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
265         if (sciErr.iErr)
266         {
267             printError(&sciErr, 0);
268             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
269             return 0;
270         }
271
272         if ((m1 == n1) && (m1 == 0))
273         {
274             sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, m1, n1, NULL);
275             if (sciErr.iErr)
276             {
277                 printError(&sciErr, 0);
278                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
279                 return 0;
280             }
281
282             LhsVar(1) = Rhs + 1;
283             PutLhsVar();
284         }
285         else
286         {
287             Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
288         }
289     }
290     else if (iType1 == sci_strings)
291     {
292         sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
293         if (sciErr.iErr)
294         {
295             printError(&sciErr, 0);
296             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
297             return 0;
298         }
299
300         lenStVarOne = (int *)MALLOC(sizeof(int) * (m1 * n1));
301         if (lenStVarOne == NULL)
302         {
303             Scierror(999, _("%s: Memory allocation error.\n"), fname);
304             return 0;
305         }
306
307         results = (wchar_t **) MALLOC(sizeof(wchar_t *) * (m1 * n1));
308
309         if (results == NULL)
310         {
311             FREE(lenStVarOne);
312             lenStVarOne = NULL;
313             freeArrayOfWideString(pStVarOne, m1 * n1);
314             Scierror(999, _("%s: Memory allocation error.\n"), fname);
315             return 0;
316         }
317
318         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, NULL);
319         if (sciErr.iErr)
320         {
321             printError(&sciErr, 0);
322             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
323             return 0;
324         }
325
326         pStVarOne = (wchar_t **) MALLOC(sizeof(wchar_t *) * (m1 * n1));
327         if (pStVarOne == NULL)
328         {
329             if (lenStVarOne)
330             {
331                 FREE(lenStVarOne);
332                 lenStVarOne = NULL;
333             }
334             Scierror(999, _("%s: Memory allocation error.\n"), fname);
335             return 0;
336         }
337
338         for (i = 0; i < m1 * n1; i++)
339         {
340             pStVarOne[i] = (wchar_t *) MALLOC(sizeof(wchar_t) * (lenStVarOne[i] + 1));
341             if (pStVarOne[i] == NULL)
342             {
343                 if (lenStVarOne)
344                 {
345                     FREE(lenStVarOne);
346                     lenStVarOne = NULL;
347                 }
348                 freeArrayOfWideString(pStVarOne, m1 * n1);
349                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
350                 return 0;
351             }
352         }
353
354         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
355         if (sciErr.iErr)
356         {
357             printError(&sciErr, 0);
358             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
359             return 0;
360         }
361
362         for (i = 0; i < m1 * n1; i++)
363         {
364             results[i] = pathconvertW(pStVarOne[i], flagtrail, flagexpand, PType);
365         }
366
367         sciErr = createMatrixOfWideString(pvApiCtx, Rhs + 1, m1, n1, results);
368         if (sciErr.iErr)
369         {
370             printError(&sciErr, 0);
371             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
372             return 0;
373         }
374
375         LhsVar(1) = Rhs + 1;
376         if (lenStVarOne)
377         {
378             FREE(lenStVarOne);
379             lenStVarOne = NULL;
380         }
381         freeArrayOfWideString(results, m1 * n1);
382         freeArrayOfWideString(pStVarOne, m1 * n1);
383         PutLhsVar();
384     }
385     else
386     {
387         Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
388         return 0;
389     }
390     return 0;
391 }
392
393 /*--------------------------------------------------------------------------*/