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 /*--------------------------------------------------------------------------*/