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