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