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