Massive indent of all codes:
[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 /*--------------------------------------------------------------------------*/