d985d3b24d0015875cca7963f516e4909d5d3c1f
[scilab.git] / scilab / modules / fileio / sci_gateway / cpp / sci_pathconvert.cpp
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 "fileio_gw.hxx"
14 #include "function.hxx"
15 #include "string.hxx"
16 #include "double.hxx"
17 #include "bool.hxx"
18
19 extern "C"
20 {
21 #include "MALLOC.h"
22 #include "localization.h"
23 #include "Scierror.h"
24 #include "pathconvert.h"
25 }
26
27 #define UNIX_TYPE       L"u"
28 #define WINDOWS_TYPE    L"w"
29 #define _UNIX_TYPE      "u"
30 #define _WINDOWS_TYPE   "w"
31
32 using namespace types;
33
34 /*--------------------------------------------------------------------------*/
35 Function::ReturnValue sci_pathconvert(typed_list &in, int _iRetCount, typed_list &out)
36 {
37         PathConvertType PType   = AUTO_STYLE;
38     int iPathExpand         = 1;
39     int iPathTrail          = 1;
40
41     if(in.size() < 1 && in.size() > 4)
42     {
43         Scierror(999, _("%s: Wrong number of input arguments: %d to %d expected.\n"), "pathconvert" , 1, 4);
44         return Function::Error;
45     }
46
47     if(_iRetCount != 1)
48     {
49         Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "pathconvert", 1);
50         return Function::Error;
51     }
52
53     //get type
54     if(in.size() > 3)
55     {
56         if(in[3]->isString() == false || in[3]->getAs<types::String>()->getSize() != 1)
57         {
58             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "pathconvert", 4);
59             return Function::Error;
60         }
61
62         wchar_t* pwstType = in[3]->getAs<types::String>()->get(0);
63         if(wcscmp(pwstType, WINDOWS_TYPE) == 0)
64         {
65             PType = WINDOWS_STYLE;
66         }
67         else if(wcscmp(pwstType, UNIX_TYPE) == 0)
68         {
69             PType = UNIX_STYLE;
70         }
71         else
72         {
73             Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), "pathconvert", 4, _UNIX_TYPE, _WINDOWS_TYPE);
74             return Function::Error;
75         }
76     }
77
78     if(in.size() > 2)
79     {
80         if(in[2]->isBool() == false || in[2]->getAs<types::Bool>()->getSize() != 1)
81         {
82             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), "pathconvert", 3);
83             return Function::Error;
84         }
85
86         iPathExpand = in[2]->getAs<types::Bool>()->get()[0];
87     }
88
89     if(in.size() > 1)
90     {
91         if(in[1]->isBool() == false || in[1]->getAs<types::Bool>()->getSize() != 1)
92         {
93             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), "pathconvert", 2);
94             return Function::Error;
95         }
96
97         iPathTrail = in[1]->getAs<types::Bool>()->get()[0];
98     }
99
100     if(in[0]->isDouble() && in[0]->getAs<Double>()->isEmpty())
101     {
102         out.push_back(Double::Empty());
103         return Function::OK;
104     }
105
106     if(in[0]->isString() == false)
107     {
108         Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), "pathconvert", 1);
109         return Function::Error;
110     }
111
112     String* pS      = in[0]->getAs<types::String>();
113     String* pOut    = new String(pS->getRows(), pS->getCols());
114     wchar_t** pStr  = pOut->get();
115
116
117     for(int i = 0 ; i < pS->getSize() ; i++)
118     {
119         pStr[i] = pathconvertW(pS->get(i), (BOOL) iPathTrail, (BOOL) iPathExpand, PType);
120     }
121
122     out.push_back(pOut);
123     return Function::OK;
124         //SciErr sciErr;
125         //int *piAddressVarOne = NULL;
126         //wchar_t **pStVarOne = NULL;
127         //int iType1 = 0;
128         //int *lenStVarOne = NULL;
129         //int m1 = 0, n1 = 0;
130
131         //wchar_t **results = NULL;
132         //int i = 0;
133
134         //BOOL flagtrail = TRUE;
135         //BOOL flagexpand = TRUE;
136
137         //PathConvertType PType = AUTO_STYLE;
138
139         ///* Check Input & Output parameters */
140         //CheckRhs(1,4);
141         //CheckLhs(1,1);
142
143
144         //if (Rhs > 3)
145         //{
146         //      int *piAddressVarFour = NULL;
147         //      wchar_t *pStVarFour = NULL;
148         //      int iType4 = 0;
149         //      int lenStVarFour = 0;
150         //      int m4 = 0, n4 = 0;
151
152         //      sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour);
153         //      if(sciErr.iErr)
154         //      {
155         //              printError(&sciErr, 0);
156         //              return 0;
157         //      }
158
159         //      sciErr = getVarType(pvApiCtx, piAddressVarFour, &iType4);
160         //      if(sciErr.iErr)
161         //      {
162         //              printError(&sciErr, 0);
163         //              return 0;
164         //      }
165
166         //      if (iType4 != sci_strings)
167         //      {
168         //              Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 4);
169         //              return 0;
170         //      }
171
172         //      sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &m4, &n4);
173         //      if(sciErr.iErr)
174         //      {
175         //              printError(&sciErr, 0);
176         //              return 0;
177         //      }
178
179         //      if ( (m4 != n4) && (n4 != 1) )
180         //      {
181         //              Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 4);
182         //              return 0;
183         //      }
184
185         //      sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, &pStVarFour);
186         //      if(sciErr.iErr)
187         //      {
188         //              printError(&sciErr, 0);
189         //              return 0;
190         //      }
191
192         //      pStVarFour = (wchar_t*)MALLOC(sizeof(wchar_t)*(lenStVarFour + 1));
193         //      if (pStVarFour == NULL)
194         //      {
195         //              Scierror(999,_("%s: Memory allocation error.\n"),fname);
196         //              return 0;
197         //      }
198
199         //      sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, &pStVarFour);
200         //      if(sciErr.iErr)
201         //      {
202         //              printError(&sciErr, 0);
203         //              return 0;
204         //      }
205
206
207         //      if ( (wcscmp(pStVarFour, L"w") == 0) || (wcscmp(pStVarFour, L"u") == 0) )
208         //      {
209         //              if (wcscmp(pStVarFour, L"w") == 0)
210         //              {
211         //                      PType = WINDOWS_STYLE;
212         //              }
213         //              else
214         //              {
215         //                      PType = UNIX_STYLE;
216         //              }
217         //              if (pStVarFour) {FREE(pStVarFour); pStVarFour = NULL;}
218         //      }
219         //      else
220         //      {
221         //              if (pStVarFour) {FREE(pStVarFour); pStVarFour = NULL;}
222         //              Scierror(999,_("%s: Wrong value for input argument #%d: ''w'' or ''u'' string expected.\n"), fname, 4);
223         //              return 0;
224         //      }
225         //}
226
227         //if (Rhs > 2)
228         //{
229         //      int *piAddressVarThree = NULL;
230         //      int *piData = NULL;
231         //      int iType3      = 0;
232         //      int m3 = 0, n3 = 0;
233
234         //      sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
235         //      if(sciErr.iErr)
236         //      {
237         //              printError(&sciErr, 0);
238         //              return 0;
239         //      }
240
241         //      sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
242         //      if(sciErr.iErr)
243         //      {
244         //              printError(&sciErr, 0);
245         //              return 0;
246         //      }
247
248         //      if (iType3 != sci_boolean)
249         //      {
250         //              Scierror(999,_("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
251         //              return 0;
252         //      }
253
254         //      sciErr = getVarDimension(pvApiCtx, piAddressVarThree, &m3, &n3);
255         //      if(sciErr.iErr)
256         //      {
257         //              printError(&sciErr, 0);
258         //              return 0;
259         //      }
260
261
262         //      if ( (m3 != n3) && (n3 != 1) )
263         //      {
264         //              Scierror(999,_("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
265         //              return 0;
266         //      }
267
268         //      sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarThree, &m3, &n3,  &piData);
269         //      if(sciErr.iErr)
270         //      {
271         //              printError(&sciErr, 0);
272         //              return 0;
273         //      }
274
275         //      flagexpand = piData[0];
276         //}
277
278         //if (Rhs > 1)
279         //{
280         //      int *piAddressVarTwo = NULL;
281         //      int *piData = NULL;
282         //      int iType2      = 0;
283         //      int m2 = 0, n2 = 0;
284
285         //      sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
286         //      if(sciErr.iErr)
287         //      {
288         //              printError(&sciErr, 0);
289         //              return 0;
290         //      }
291
292         //      sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
293         //      if(sciErr.iErr)
294         //      {
295         //              printError(&sciErr, 0);
296         //              return 0;
297         //      }
298
299         //      if (iType2 != sci_boolean)
300         //      {
301         //              Scierror(999,_("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
302         //              return 0;
303         //      }
304
305         //      sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &m2, &n2);
306         //      if(sciErr.iErr)
307         //      {
308         //              printError(&sciErr, 0);
309         //              return 0;
310         //      }
311
312         //      if ( (m2 != n2) && (n2 != 1) )
313         //      {
314         //              Scierror(999,_("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 2);
315         //              return 0;
316         //      }
317
318         //      sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2,  &piData);
319         //      if(sciErr.iErr)
320         //      {
321         //              printError(&sciErr, 0);
322         //              return 0;
323         //      }
324
325         //      flagtrail = piData[0];
326         //}
327
328         //sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
329         //if(sciErr.iErr)
330         //{
331         //      printError(&sciErr, 0);
332         //      return 0;
333         //}
334
335         //sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
336         //if(sciErr.iErr)
337         //{
338         //      printError(&sciErr, 0);
339         //      return 0;
340         //}
341
342         //if (iType1 == sci_matrix)
343         //{
344         //      sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
345         //      if(sciErr.iErr)
346         //      {
347         //              printError(&sciErr, 0);
348         //              return 0;
349         //      }
350
351         //      if ( (m1 == n1) && (m1 == 0) )
352         //      {
353         //              sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, m1, n1, NULL);
354         //              if(sciErr.iErr)
355         //              {
356         //                      printError(&sciErr, 0);
357         //                      return 0;
358         //              }
359
360         //              LhsVar(1) = Rhs + 1;
361         //              C2F(putlhsvar)();
362         //      }
363         //      else
364         //      {
365         //              Scierror(999,_("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
366         //      }
367         //}
368         //else if (iType1 == sci_strings)
369         //{
370         //      sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
371         //      if(sciErr.iErr)
372         //      {
373         //              printError(&sciErr, 0);
374         //              return 0;
375         //      }
376
377         //      lenStVarOne = (int*)MALLOC(sizeof(int) * (m1 * n1));
378         //      if (lenStVarOne == NULL)
379         //      {
380         //              Scierror(999,_("%s: Memory allocation error.\n"),fname);
381         //              return 0;
382         //      }
383
384         //      results = (wchar_t **)MALLOC(sizeof(wchar_t*) * (m1 * n1));
385
386         //      if (results == NULL)
387         //      {
388         //              if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
389         //              freeArrayOfWideString(pStVarOne, m1 * n1);
390         //              Scierror(999,_("%s: Memory allocation error.\n"),fname);
391         //              return 0;
392         //      }
393
394         //      sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
395         //      if(sciErr.iErr)
396         //      {
397         //              printError(&sciErr, 0);
398         //              return 0;
399         //      }
400
401         //      pStVarOne = (wchar_t**)MALLOC(sizeof(wchar_t*) * (m1 * n1));
402         //      if (pStVarOne == NULL)
403         //      {
404         //              if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
405         //              Scierror(999,_("%s: Memory allocation error.\n"),fname);
406         //              return 0;
407         //      }
408
409         //      for( i = 0; i < m1 * n1; i++)
410         //      {
411         //              pStVarOne[i] = (wchar_t*)MALLOC(sizeof(wchar_t)*(lenStVarOne[i] + 1));
412         //              if (pStVarOne[i] == NULL)
413         //              {
414         //                      if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
415         //                      freeArrayOfWideString(pStVarOne, m1 * n1);
416         //                      Scierror(999,_("%s: Memory allocation error.\n"),fname);
417         //                      return 0;
418         //              }
419         //      }
420
421         //      sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
422         //      if(sciErr.iErr)
423         //      {
424         //              printError(&sciErr, 0);
425         //              return 0;
426         //      }
427
428         //      for( i = 0; i < m1 * n1; i++)
429         //      {
430         //              results[i] = pathconvertW(pStVarOne[i], flagtrail, flagexpand, PType);
431         //      }
432
433         //      sciErr = createMatrixOfWideString(pvApiCtx, Rhs + 1, m1, n1, results);
434         //      if(sciErr.iErr)
435         //      {
436         //              printError(&sciErr, 0);
437         //              return 0;
438         //      }
439
440         //      LhsVar(1) = Rhs + 1;
441         //      C2F(putlhsvar)();
442
443         //      if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
444         //      freeArrayOfWideString(results, m1 * n1);
445         //      freeArrayOfWideString(pStVarOne, m1 * n1);
446         //}
447         //else
448         //{
449         //      Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
450         //      return 0;
451         //}
452         //return 0;
453 }
454 /*--------------------------------------------------------------------------*/