scilab/modules/fileio/sci_gateway/c/sci_pathconvert.c

   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 "gw_fileio.h"
  14 #include "stack-c.h"
  15 #include "MALLOC.h"
  16 #include "localization.h"
  17 #include "api_scilab.h"
  18 #include "Scierror.h"
  19 #include "pathconvert.h"
  20 #include "freeArrayOfString.h"
  21 /*--------------------------------------------------------------------------*/
  22 int sci_pathconvert(char *fname, unsigned long fname_len)
  23 {
  24     SciErr sciErr;
  25     int *piAddressVarOne = NULL;
  26     wchar_t **pStVarOne = NULL;
  27     int iType1 = 0;
  28     int *lenStVarOne = NULL;
  29     int m1 = 0, n1 = 0;
  30
  31     wchar_t **results = NULL;
  32     int i = 0;
  33
  34     BOOL flagtrail = TRUE;
  35     BOOL flagexpand = TRUE;
  36
  37     PathConvertType PType = AUTO_STYLE;
  38
  39     /* Check Input & Output parameters */
  40     CheckRhs(1, 4);
  41     CheckLhs(1, 1);
  42
  43     if (Rhs > 3)
  44     {
  45         int *piAddressVarFour = NULL;
  46         wchar_t *pStVarFour = NULL;
  47         int iType4 = 0;
  48         int lenStVarFour = 0;
  49         int m4 = 0, n4 = 0;
  50
  51         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour);
  52         if (sciErr.iErr)
  53         {
  54             printError(&sciErr, 0);
  55             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
  56             return 0;
  57         }
  58
  59         sciErr = getVarType(pvApiCtx, piAddressVarFour, &iType4);
  60         if (sciErr.iErr)
  61         {
  62             printError(&sciErr, 0);
  63             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
  64             return 0;
  65         }
  66
  67         if (iType4 != sci_strings)
  68         {
  69             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 4);
  70             return 0;
  71         }
  72
  73         sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &m4, &n4);
  74         if (sciErr.iErr)
  75         {
  76             printError(&sciErr, 0);
  77             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
  78             return 0;
  79         }
  80
  81         if ((m4 != n4) && (n4 != 1))
  82         {
  83             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 4);
  84             return 0;
  85         }
  86
  87         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, NULL);
  88         if (sciErr.iErr)
  89         {
  90             printError(&sciErr, 0);
  91             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
  92             return 0;
  93         }
  94
  95         pStVarFour = (wchar_t *) MALLOC(sizeof(wchar_t) * (lenStVarFour + 1));
  96         if (pStVarFour == NULL)
  97         {
  98             Scierror(999, _("%s: Memory allocation error.\n"), fname);
  99             return 0;
 100         }
 101
 102         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarFour, &m4, &n4, &lenStVarFour, &pStVarFour);
 103         if (sciErr.iErr)
 104         {
 105             printError(&sciErr, 0);
 106             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
 107             return 0;
 108         }
 109
 110         if ((wcscmp(pStVarFour, L"w") == 0) || (wcscmp(pStVarFour, L"u") == 0))
 111         {
 112             if (wcscmp(pStVarFour, L"w") == 0)
 113             {
 114                 PType = WINDOWS_STYLE;
 115             }
 116             else
 117             {
 118                 PType = UNIX_STYLE;
 119             }
 120             if (pStVarFour)
 121             {
 122                 FREE(pStVarFour);
 123                 pStVarFour = NULL;
 124             }
 125         }
 126         else
 127         {
 128             if (pStVarFour)
 129             {
 130                 FREE(pStVarFour);
 131                 pStVarFour = NULL;
 132             }
 133             Scierror(999, _("%s: Wrong value for input argument #%d: 'w' or 'u' string expected.\n"), fname, 4);
 134             return 0;
 135         }
 136     }
 137
 138     if (Rhs > 2)
 139     {
 140         int *piAddressVarThree = NULL;
 141         int *piData = NULL;
 142         int iType3 = 0;
 143         int m3 = 0, n3 = 0;
 144
 145         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
 146         if (sciErr.iErr)
 147         {
 148             printError(&sciErr, 0);
 149             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 150             return 0;
 151         }
 152
 153         sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
 154         if (sciErr.iErr)
 155         {
 156             printError(&sciErr, 0);
 157             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 158             return 0;
 159         }
 160
 161         if (iType3 != sci_boolean)
 162         {
 163             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
 164             return 0;
 165         }
 166
 167         sciErr = getVarDimension(pvApiCtx, piAddressVarThree, &m3, &n3);
 168         if (sciErr.iErr)
 169         {
 170             printError(&sciErr, 0);
 171             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 172             return 0;
 173         }
 174
 175         if ((m3 != n3) && (n3 != 1))
 176         {
 177             Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
 178             return 0;
 179         }
 180
 181         sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarThree, &m3, &n3, &piData);
 182         if (sciErr.iErr)
 183         {
 184             printError(&sciErr, 0);
 185             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 186             return 0;
 187         }
 188
 189         flagexpand = piData[0];
 190     }
 191
 192     if (Rhs > 1)
 193     {
 194         int *piAddressVarTwo = NULL;
 195         int *piData = NULL;
 196         int iType2 = 0;
 197         int m2 = 0, n2 = 0;
 198
 199         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
 200         if (sciErr.iErr)
 201         {
 202             printError(&sciErr, 0);
 203             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 204             return 0;
 205         }
 206
 207         sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
 208         if (sciErr.iErr)
 209         {
 210             printError(&sciErr, 0);
 211             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 212             return 0;
 213         }
 214
 215         if (iType2 != sci_boolean)
 216         {
 217             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
 218             return 0;
 219         }
 220
 221         sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &m2, &n2);
 222         if (sciErr.iErr)
 223         {
 224             printError(&sciErr, 0);
 225             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 226             return 0;
 227         }
 228
 229         if ((m2 != n2) && (n2 != 1))
 230         {
 231             Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 2);
 232             return 0;
 233         }
 234
 235         sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &piData);
 236         if (sciErr.iErr)
 237         {
 238             printError(&sciErr, 0);
 239             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 240             return 0;
 241         }
 242
 243         flagtrail = piData[0];
 244     }
 245
 246     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
 247     if (sciErr.iErr)
 248     {
 249         printError(&sciErr, 0);
 250         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 251         return 0;
 252     }
 253
 254     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
 255     if (sciErr.iErr)
 256     {
 257         printError(&sciErr, 0);
 258         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 259         return 0;
 260     }
 261
 262     if (iType1 == sci_matrix)
 263     {
 264         sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
 265         if (sciErr.iErr)
 266         {
 267             printError(&sciErr, 0);
 268             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 269             return 0;
 270         }
 271
 272         if ((m1 == n1) && (m1 == 0))
 273         {
 274             sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, m1, n1, NULL);
 275             if (sciErr.iErr)
 276             {
 277                 printError(&sciErr, 0);
 278                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 279                 return 0;
 280             }
 281
 282             LhsVar(1) = Rhs + 1;
 283             PutLhsVar();
 284         }
 285         else
 286         {
 287             Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
 288         }
 289     }
 290     else if (iType1 == sci_strings)
 291     {
 292         sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
 293         if (sciErr.iErr)
 294         {
 295             printError(&sciErr, 0);
 296             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 297             return 0;
 298         }
 299
 300         lenStVarOne = (int *)MALLOC(sizeof(int) * (m1 * n1));
 301         if (lenStVarOne == NULL)
 302         {
 303             Scierror(999, _("%s: Memory allocation error.\n"), fname);
 304             return 0;
 305         }
 306
 307         results = (wchar_t **) MALLOC(sizeof(wchar_t *) * (m1 * n1));
 308
 309         if (results == NULL)
 310         {
 311             FREE(lenStVarOne);
 312             lenStVarOne = NULL;
 313             freeArrayOfWideString(pStVarOne, m1 * n1);
 314             Scierror(999, _("%s: Memory allocation error.\n"), fname);
 315             return 0;
 316         }
 317
 318         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, NULL);
 319         if (sciErr.iErr)
 320         {
 321             printError(&sciErr, 0);
 322             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 323             return 0;
 324         }
 325
 326         pStVarOne = (wchar_t **) MALLOC(sizeof(wchar_t *) * (m1 * n1));
 327         if (pStVarOne == NULL)
 328         {
 329             if (lenStVarOne)
 330             {
 331                 FREE(lenStVarOne);
 332                 lenStVarOne = NULL;
 333             }
 334             Scierror(999, _("%s: Memory allocation error.\n"), fname);
 335             return 0;
 336         }
 337
 338         for (i = 0; i < m1 * n1; i++)
 339         {
 340             pStVarOne[i] = (wchar_t *) MALLOC(sizeof(wchar_t) * (lenStVarOne[i] + 1));
 341             if (pStVarOne[i] == NULL)
 342             {
 343                 if (lenStVarOne)
 344                 {
 345                     FREE(lenStVarOne);
 346                     lenStVarOne = NULL;
 347                 }
 348                 freeArrayOfWideString(pStVarOne, m1 * n1);
 349                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
 350                 return 0;
 351             }
 352         }
 353
 354         sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
 355         if (sciErr.iErr)
 356         {
 357             printError(&sciErr, 0);
 358             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 359             return 0;
 360         }
 361
 362         for (i = 0; i < m1 * n1; i++)
 363         {
 364             results[i] = pathconvertW(pStVarOne[i], flagtrail, flagexpand, PType);
 365         }
 366
 367         sciErr = createMatrixOfWideString(pvApiCtx, Rhs + 1, m1, n1, results);
 368         if (sciErr.iErr)
 369         {
 370             printError(&sciErr, 0);
 371             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 372             return 0;
 373         }
 374
 375         LhsVar(1) = Rhs + 1;
 376         if (lenStVarOne)
 377         {
 378             FREE(lenStVarOne);
 379             lenStVarOne = NULL;
 380         }
 381         freeArrayOfWideString(results, m1 * n1);
 382         freeArrayOfWideString(pStVarOne, m1 * n1);
 383         PutLhsVar();
 384     }
 385     else
 386     {
 387         Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
 388         return 0;
 389     }
 390     return 0;
 391 }
 392
 393 /*--------------------------------------------------------------------------*/