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