scilab/modules/api_scilab/src/cpp/api_string.cpp

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
   4  * Copyright (C) 2009-2011 - DIGITEO - Allan CORNET
   5  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11  *
  12  * Please note that piece of code will be rewrited for the Scilab 6 family
  13  * However, the API (profile of the functions in the header files) will be
  14  * still available and supported in Scilab 6.
  15  */
  16
  17 /*--------------------------------------------------------------------------*/
  18 #include "gatewaystruct.hxx"
  19 #include "string.hxx"
  20 #include "double.hxx"
  21 #include "context.hxx"
  22
  23 extern "C"
  24 {
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include "machine.h"
  28 #include "charEncoding.h"
  29 #include "sci_malloc.h"
  30 #include "api_scilab.h"
  31 #include "api_internal_common.h"
  32 #include "call_scilab.h"
  33 #include "localization.h"
  34 #include "sci_malloc.h"
  35 #include "freeArrayOfString.h"
  36 #include "os_string.h"
  37 }
  38
  39 using namespace types;
  40 /*--------------------------------------------------------------------------*/
  41
  42 /*******************************/
  43 /*   string matrix functions   */
  44 /*******************************/
  45
  46 SciErr getMatrixOfString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
  47 {
  48     SciErr sciErr = sciErrInit();
  49     int *piOffset = NULL;
  50     int *piData = NULL;
  51     int iType = 0;
  52
  53     if (_piAddress == NULL)
  54     {
  55         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
  56         return sciErr;
  57     }
  58
  59     sciErr = getVarType(_pvCtx, _piAddress, &iType);
  60     if (sciErr.iErr)
  61     {
  62         addErrorMessage(&sciErr, API_ERROR_GET_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfString", getRhsFromAddress(_pvCtx, _piAddress));
  63         return sciErr;
  64     }
  65
  66     if (iType != sci_strings)
  67     {
  68         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfString", _("string matrix"));
  69         return sciErr;
  70     }
  71
  72     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
  73     if (sciErr.iErr)
  74     {
  75         addErrorMessage(&sciErr, API_ERROR_GET_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfString", getRhsFromAddress(_pvCtx, _piAddress));
  76         return sciErr;
  77     }
  78
  79     if (_piLength == NULL)
  80     {
  81         return sciErr;
  82     }
  83
  84     String *pS = ((InternalType*)_piAddress)->getAs<types::String>();
  85
  86     //non cummulative length
  87     int iSize = pS->getSize();
  88     if (_pstStrings == NULL || *_pstStrings == NULL)
  89     {
  90         for (int i = 0 ; i < iSize; i++)
  91         {
  92             char* pstTemp = wide_string_to_UTF8(pS->get(i));
  93             _piLength[i] = (int)strlen(pstTemp);
  94             FREE(pstTemp);
  95         }
  96     }
  97     else
  98     {
  99         for (int i = 0 ; i < iSize; i++)
 100         {
 101             if (_pstStrings[i] == NULL)
 102             {
 103                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
 104                 return sciErr;
 105             }
 106
 107             char* c = wide_string_to_UTF8(pS->get(i));
 108             strcpy(_pstStrings[i], c);
 109             FREE(c);
 110         }
 111     }
 112
 113     return sciErr;
 114 }
 115 /*--------------------------------------------------------------------------*/
 116 SciErr createMatrixOfString(void* _pvCtx, int _iVar, int _iRows, int _iCols, const char* const * _pstStrings)
 117 {
 118     SciErr sciErr = sciErrInit();
 119
 120     int rhs = _iVar - *getNbInputArgument(_pvCtx);
 121     GatewayStruct* pStr = (GatewayStruct*)_pvCtx;
 122     InternalType** out = pStr->m_pOut;
 123
 124     //return empty matrix
 125     if (_iRows == 0 && _iCols == 0)
 126     {
 127         Double *pDbl = new Double(_iRows, _iCols);
 128         if (pDbl == NULL)
 129         {
 130             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
 131             return sciErr;
 132         }
 133
 134         out[rhs - 1] = pDbl;
 135         return sciErr;
 136     }
 137
 138     String* pS = new String(_iRows, _iCols);
 139     if (pS == NULL)
 140     {
 141         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), "createMatrixOfString");
 142         return sciErr;
 143     }
 144
 145     for (int i = 0 ; i < pS->getSize() ; i++)
 146     {
 147         wchar_t* pstTemp = to_wide_string(_pstStrings[i]);
 148         pS->set(i, pstTemp);
 149         FREE(pstTemp);
 150     }
 151
 152     out[rhs - 1] = pS;
 153
 154     return sciErr;
 155 }
 156 /*--------------------------------------------------------------------------*/
 157 SciErr createNamedMatrixOfString(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const char* const* _pstStrings)
 158 {
 159     SciErr sciErr;
 160     sciErr.iErr = 0;
 161     sciErr.iMsgCount = 0;
 162
 163     // check variable name
 164     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
 165     {
 166         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createNamedMatrixOfString", _pstName);
 167         return sciErr;
 168     }
 169
 170     //return empty matrix
 171     if (_iRows == 0 && _iCols == 0)
 172     {
 173         if (createNamedEmptyMatrix(_pvCtx, _pstName))
 174         {
 175             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
 176             return sciErr;
 177         }
 178
 179         return sciErr;
 180     }
 181
 182     String* pS = new String(_iRows, _iCols);
 183     if (pS == NULL)
 184     {
 185         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedMatrixOfString", _pstName);
 186         return sciErr;
 187     }
 188
 189     for (int i = 0 ; i < pS->getSize() ; i++)
 190     {
 191         wchar_t* pstTemp = to_wide_string(_pstStrings[i]);
 192         pS->set(i, pstTemp);
 193         FREE(pstTemp);
 194     }
 195
 196     wchar_t* pwstName = to_wide_string(_pstName);
 197     symbol::Context* ctx = symbol::Context::getInstance();
 198     symbol::Symbol sym = symbol::Symbol(pwstName);
 199     FREE(pwstName);
 200     if (ctx->isprotected(sym) == false)
 201     {
 202         ctx->put(sym, pS);
 203     }
 204     else
 205     {
 206         delete pS;
 207         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
 208     }
 209     return sciErr;
 210 }
 211 /*--------------------------------------------------------------------------*/
 212 SciErr readNamedMatrixOfString(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
 213 {
 214     int* piAddr = NULL;
 215
 216     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
 217     if (sciErr.iErr)
 218     {
 219         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_STRING, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfString", _pstName);
 220         return sciErr;
 221     }
 222
 223     sciErr = getMatrixOfString(_pvCtx, piAddr, _piRows, _piCols, _piLength, _pstStrings);
 224     if (sciErr.iErr)
 225     {
 226         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_STRING, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfString", _pstName);
 227         return sciErr;
 228     }
 229
 230     return sciErr;
 231 }
 232 /*--------------------------------------------------------------------------*/
 233 SciErr getMatrixOfWideString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piwLength, wchar_t** _pwstStrings)
 234 {
 235     SciErr sciErr = sciErrInit();
 236     int iType = 0;
 237     char **pstStrings = NULL;
 238     int *piLenStrings = NULL;
 239     int strSize = 0;
 240
 241     if (_piAddress == NULL)
 242     {
 243         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfWideString");
 244         return sciErr;
 245     }
 246
 247     sciErr = getVarType(_pvCtx, _piAddress, &iType);
 248     if (sciErr.iErr)
 249     {
 250         addErrorMessage(&sciErr, API_ERROR_GET_WIDE_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfWideString", getRhsFromAddress(_pvCtx, _piAddress));
 251         return sciErr;
 252     }
 253
 254     if (iType != sci_strings)
 255     {
 256         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfWideString", _("string matrix"));
 257         return sciErr;
 258     }
 259
 260     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
 261     if (sciErr.iErr)
 262     {
 263         addErrorMessage(&sciErr, API_ERROR_GET_WIDE_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfWideString", getRhsFromAddress(_pvCtx, _piAddress));
 264         return sciErr;
 265     }
 266
 267     if (_piwLength == NULL)
 268     {
 269         return sciErr;
 270     }
 271
 272     String *pS = ((InternalType*)_piAddress)->getAs<types::String>();
 273
 274     int iSize = pS->getSize();
 275     if (_pwstStrings == NULL || *_pwstStrings == NULL)
 276     {
 277         for (int i = 0 ; i < iSize; i++)
 278         {
 279             _piwLength[i] = (int)wcslen(pS->get(i));
 280         }
 281     }
 282     else
 283     {
 284         for (int i = 0 ; i < pS->getSize() ; i++)
 285         {
 286             if (_pwstStrings[i] == NULL)
 287             {
 288                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
 289                 return sciErr;
 290             }
 291
 292             wcscpy(_pwstStrings[i], pS->get(i));
 293         }
 294     }
 295
 296     return sciErr;
 297 }
 298 /*--------------------------------------------------------------------------*/
 299 SciErr createMatrixOfWideString(void* _pvCtx, int _iVar, int _iRows, int _iCols, const wchar_t* const* _pstwStrings)
 300 {
 301     char **pStrings = NULL;
 302
 303     //return empty matrix
 304     if (_iRows == 0 && _iCols == 0)
 305     {
 306         double dblReal = 0;
 307         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
 308         if (sciErr.iErr)
 309         {
 310             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
 311         }
 312         return sciErr;
 313     }
 314
 315     pStrings = (char**)MALLOC( sizeof(char*) * (_iRows * _iCols) );
 316
 317     for (int i = 0; i < (_iRows * _iCols) ; i++)
 318     {
 319         pStrings[i] = wide_string_to_UTF8(_pstwStrings[i]);
 320     }
 321
 322     SciErr sciErr = createMatrixOfString(_pvCtx, _iVar, _iRows, _iCols, pStrings);
 323     if (sciErr.iErr)
 324     {
 325         addErrorMessage(&sciErr, API_ERROR_CREATE_WIDE_STRING, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfWideString");
 326     }
 327
 328     freeArrayOfString(pStrings, _iRows * _iCols);
 329
 330     return sciErr;
 331 }
 332 /*--------------------------------------------------------------------------*/
 333 SciErr createNamedMatrixOfWideString(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const wchar_t* const* _pwstStrings)
 334 {
 335     SciErr sciErr = sciErrInit();
 336     char **pStrings = NULL;
 337
 338     // check variable name
 339     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
 340     {
 341         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createNamedMatrixOfWideString", _pstName);
 342         return sciErr;
 343     }
 344
 345     //return named empty matrix
 346     if (_iRows == 0 && _iCols == 0)
 347     {
 348         double dblReal = 0;
 349         sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblReal);
 350         if (sciErr.iErr)
 351         {
 352             addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
 353         }
 354         return sciErr;
 355     }
 356
 357     String* pS = new String(_iRows, _iCols);
 358     if (pS == NULL)
 359     {
 360         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedMatrixOfWideString", _pstName);
 361         return sciErr;
 362     }
 363
 364     for (int i = 0 ; i < pS->getSize() ; i++)
 365     {
 366         pS->set(i, _pwstStrings[i]);
 367     }
 368
 369     wchar_t* pwstName = to_wide_string(_pstName);
 370     symbol::Context* ctx = symbol::Context::getInstance();
 371     symbol::Symbol sym = symbol::Symbol(pwstName);
 372     FREE(pwstName);
 373     if (ctx->isprotected(sym) == false)
 374     {
 375         ctx->put(sym, pS);
 376     }
 377     else
 378     {
 379         delete pS;
 380         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
 381     }
 382     return sciErr;
 383 }
 384 /*--------------------------------------------------------------------------*/
 385 SciErr readNamedMatrixOfWideString(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piwLength, wchar_t** _pwstStrings)
 386 {
 387     int* piAddr = NULL;
 388
 389     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
 390     if (sciErr.iErr)
 391     {
 392         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_WIDE_STRING, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfWideString", _pstName);
 393         return sciErr;
 394     }
 395
 396     sciErr = getMatrixOfWideString(_pvCtx, piAddr, _piRows, _piCols, _piwLength, _pwstStrings);
 397     if (sciErr.iErr)
 398     {
 399         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_WIDE_STRING, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfWideString", _pstName);
 400         return sciErr;
 401     }
 402
 403     return sciErr;
 404 }
 405
 406 /*shortcut functions*/
 407 /*--------------------------------------------------------------------------*/
 408 int isStringType(void* _pvCtx, int* _piAddress)
 409 {
 410     return checkVarType(_pvCtx, _piAddress, sci_strings);
 411 }
 412 /*--------------------------------------------------------------------------*/
 413 int isNamedStringType(void* _pvCtx, const char* _pstName)
 414 {
 415     return checkNamedVarType(_pvCtx, _pstName, sci_strings);
 416 }
 417 /*--------------------------------------------------------------------------*/
 418 int getAllocatedSingleString(void* _pvCtx, int* _piAddress, char** _pstData)
 419 {
 420     SciErr sciErr = sciErrInit();
 421     int iRows = 0;
 422     int iCols = 0;
 423     int iLen = 0;
 424
 425     if (isScalar(_pvCtx, _piAddress) == 0 || isStringType(_pvCtx, _piAddress) == 0)
 426     {
 427         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "getAllocatedSingleString", getRhsFromAddress(_pvCtx, _piAddress));
 428         printError(&sciErr, 0);
 429         return sciErr.iErr;
 430     }
 431
 432     sciErr = getMatrixOfString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, NULL);
 433     if (sciErr.iErr)
 434     {
 435         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleString");
 436         printError(&sciErr, 0);
 437         return sciErr.iErr;
 438     }
 439
 440     *_pstData = (char*)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
 441
 442     sciErr = getMatrixOfString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, _pstData);
 443     if (sciErr.iErr)
 444     {
 445         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleString");
 446         printError(&sciErr, 0);
 447         return sciErr.iErr;
 448     }
 449
 450     return 0;
 451 }
 452
 453 /*--------------------------------------------------------------------------*/
 454 int getAllocatedSingleWideString(void* _pvCtx, int* _piAddress, wchar_t** _pwstData)
 455 {
 456     SciErr sciErr = sciErrInit();
 457     int iRows = 0;
 458     int iCols = 0;
 459     int iLen = 0;
 460
 461     if (isScalar(_pvCtx, _piAddress) == 0 || isStringType(_pvCtx, _piAddress) == 0)
 462     {
 463         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_WIDE_STRING, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "getAllocatedSingleWideString", getRhsFromAddress(_pvCtx, _piAddress));
 464         printError(&sciErr, 0);
 465         return sciErr.iErr;
 466     }
 467
 468     sciErr = getMatrixOfWideString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, NULL);
 469     if (sciErr.iErr)
 470     {
 471         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleWideString");
 472         printError(&sciErr, 0);
 473         return sciErr.iErr;
 474     }
 475
 476     *_pwstData = (wchar_t*)MALLOC(sizeof(wchar_t) * (iLen + 1)); //+1 for null termination
 477
 478     sciErr = getMatrixOfWideString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, _pwstData);
 479     if (sciErr.iErr)
 480     {
 481         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleWideString");
 482         printError(&sciErr, 0);
 483         return sciErr.iErr;
 484     }
 485
 486     return 0;
 487 }
 488 /*--------------------------------------------------------------------------*/
 489 int getAllocatedMatrixOfString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, char*** _pstData)
 490 {
 491     SciErr sciErr = getMatrixOfString(_pvCtx, _piAddress, _piRows, _piCols, NULL, NULL);
 492     if (sciErr.iErr)
 493     {
 494         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfString");
 495         printError(&sciErr, 0);
 496         return sciErr.iErr;
 497     }
 498
 499     int* piLen = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
 500     *_pstData = (char**)MALLOC(sizeof(char*) **_piRows **_piCols);
 501
 502     sciErr = getMatrixOfString(_pvCtx, _piAddress, _piRows, _piCols, piLen, NULL);
 503     if (sciErr.iErr)
 504     {
 505         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfString");
 506         printError(&sciErr, 0);
 507         if (piLen)
 508         {
 509             FREE(piLen);
 510             piLen = NULL;
 511         }
 512         return sciErr.iErr;
 513     }
 514
 515     for (int i = 0 ; i < *_piRows **_piCols ; i++)
 516     {
 517         (*_pstData)[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));//+1 for null termination
 518     }
 519
 520     sciErr = getMatrixOfString(_pvCtx, _piAddress, _piRows, _piCols, piLen, *_pstData);
 521     if (piLen)
 522     {
 523         FREE(piLen);
 524         piLen = NULL;
 525     }
 526     if (sciErr.iErr)
 527     {
 528         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfString");
 529         printError(&sciErr, 0);
 530         return sciErr.iErr;
 531     }
 532
 533     return 0;
 534 }
 535 /*--------------------------------------------------------------------------*/
 536 int getAllocatedMatrixOfWideString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, wchar_t*** _pwstData)
 537 {
 538     SciErr sciErr = getMatrixOfWideString(_pvCtx, _piAddress, _piRows, _piCols, NULL, NULL);
 539     if (sciErr.iErr)
 540     {
 541         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfWideString");
 542         printError(&sciErr, 0);
 543         return sciErr.iErr;
 544     }
 545
 546     int* piLen = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
 547     *_pwstData = (wchar_t**)MALLOC(sizeof(wchar_t*) **_piRows **_piCols);
 548
 549     sciErr = getMatrixOfWideString(_pvCtx, _piAddress, _piRows, _piCols, piLen, NULL);
 550     if (sciErr.iErr)
 551     {
 552         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfWideString");
 553         if (piLen)
 554         {
 555             FREE(piLen);
 556             piLen = NULL;
 557         }
 558         if (*_pwstData)
 559         {
 560             FREE(*_pwstData);
 561             *_pwstData = NULL;
 562         }
 563         printError(&sciErr, 0);
 564         return sciErr.iErr;
 565     }
 566
 567     for (int i = 0 ; i < *_piRows **_piCols ; i++)
 568     {
 569         (*_pwstData)[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (piLen[i] + 1));//+1 for null termination
 570     }
 571
 572     sciErr = getMatrixOfWideString(_pvCtx, _piAddress, _piRows, _piCols, piLen, *_pwstData);
 573
 574     if (piLen)
 575     {
 576         FREE(piLen);
 577         piLen = NULL;
 578     }
 579
 580     if (sciErr.iErr)
 581     {
 582         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedMatrixOfWideString");
 583         printError(&sciErr, 0);
 584         return sciErr.iErr;
 585     }
 586     return 0;
 587 }
 588 /*--------------------------------------------------------------------------*/
 589 int getAllocatedNamedSingleString(void* _pvCtx, const char* _pstName, char** _pstData)
 590 {
 591     SciErr sciErr = sciErrInit();
 592     int iRows = 0;
 593     int iCols = 0;
 594     int iLen = 0;
 595
 596     if (isNamedScalar(_pvCtx, _pstName) == 0 || isNamedStringType(_pvCtx, _pstName) == 0)
 597     {
 598         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_STRING, _("%s: Wrong type for input argument \"%s\": A single string expected.\n"), "getAllocatedNamedSingleString", _pstName);
 599         printError(&sciErr, 0);
 600         return sciErr.iErr;
 601     }
 602
 603     sciErr = readNamedMatrixOfString(_pvCtx, _pstName, &iRows, &iCols, &iLen, NULL);
 604     if (sciErr.iErr)
 605     {
 606         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleString");
 607         printError(&sciErr, 0);
 608         return sciErr.iErr;
 609     }
 610
 611     *_pstData = (char*)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
 612
 613     sciErr = readNamedMatrixOfString(_pvCtx, _pstName, &iRows, &iCols, &iLen, _pstData);
 614     if (sciErr.iErr)
 615     {
 616         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleString");
 617         printError(&sciErr, 0);
 618         return sciErr.iErr;
 619     }
 620
 621     return 0;
 622 }
 623 /*--------------------------------------------------------------------------*/
 624 int getAllocatedNamedSingleWideString(void* _pvCtx, const char* _pstName, wchar_t** _pwstData)
 625 {
 626     SciErr sciErr = sciErrInit();
 627     int iRows = 0;
 628     int iCols = 0;
 629     int iLen = 0;
 630
 631     if (isNamedScalar(_pvCtx, _pstName) == 0 || isNamedStringType(_pvCtx, _pstName) == 0)
 632     {
 633         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Wrong type for input argument \"%s\": A single string expected.\n"), "getAllocatedNamedSingleWideString", _pstName);
 634         printError(&sciErr, 0);
 635         return sciErr.iErr;
 636     }
 637
 638     sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, &iLen, NULL);
 639     if (sciErr.iErr)
 640     {
 641         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleWideString");
 642         printError(&sciErr, 0);
 643         return sciErr.iErr;
 644     }
 645
 646     *_pwstData = (wchar_t*)MALLOC(sizeof(wchar_t) * (iLen + 1)); //+1 for null termination
 647
 648     sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, &iLen, _pwstData);
 649     if (sciErr.iErr)
 650     {
 651         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleWideString");
 652         printError(&sciErr, 0);
 653         return sciErr.iErr;
 654     }
 655
 656     return 0;
 657 }
 658 /*--------------------------------------------------------------------------*/
 659 int getAllocatedNamedMatrixOfString(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, char*** _pstData)
 660 {
 661     SciErr sciErr = readNamedMatrixOfString(_pvCtx, _pstName, _piRows, _piCols, NULL, NULL);
 662     if (sciErr.iErr)
 663     {
 664         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfString");
 665         printError(&sciErr, 0);
 666         return sciErr.iErr;
 667     }
 668
 669     int* piLen = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
 670
 671     sciErr = readNamedMatrixOfString(_pvCtx, _pstName, _piRows, _piCols, piLen, NULL);
 672     if (sciErr.iErr)
 673     {
 674         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfString");
 675         if (piLen)
 676         {
 677             FREE(piLen);
 678             piLen = NULL;
 679         }
 680         printError(&sciErr, 0);
 681         return sciErr.iErr;
 682     }
 683
 684     *_pstData = (char**)MALLOC(sizeof(char*) **_piRows **_piCols);
 685     for (int i = 0 ; i < *_piRows **_piCols ; i++)
 686     {
 687         (*_pstData)[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));//+1 for null termination
 688     }
 689
 690     sciErr = readNamedMatrixOfString(_pvCtx, _pstName, _piRows, _piCols, piLen, *_pstData);
 691     if (piLen)
 692     {
 693         FREE(piLen);
 694         piLen = NULL;
 695     }
 696     if (sciErr.iErr)
 697     {
 698         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfString");
 699         printError(&sciErr, 0);
 700         return sciErr.iErr;
 701     }
 702
 703     return 0;
 704 }
 705 /*--------------------------------------------------------------------------*/
 706 int getAllocatedNamedMatrixOfWideString(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, wchar_t*** _pwstData)
 707 {
 708     int iRows = 0;
 709     int iCols = 0;
 710     int* piLen = 0;
 711
 712     SciErr sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, NULL, NULL);
 713     if (sciErr.iErr)
 714     {
 715         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
 716         printError(&sciErr, 0);
 717         return sciErr.iErr;
 718     }
 719
 720     piLen = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
 721
 722     sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, piLen, NULL);
 723     if (sciErr.iErr)
 724     {
 725         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
 726         if (piLen)
 727         {
 728             FREE(piLen);
 729             piLen = NULL;
 730         }
 731         printError(&sciErr, 0);
 732         return sciErr.iErr;
 733     }
 734
 735     *_pwstData = (wchar_t**)MALLOC(sizeof(wchar_t*) **_piRows **_piCols);
 736
 737     for (int i = 0 ; i < *_piRows **_piCols ; i++)
 738     {
 739         *_pwstData[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (piLen[i] + 1));//+1 for null termination
 740     }
 741
 742     sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, piLen, *_pwstData);
 743     if (piLen)
 744     {
 745         FREE(piLen);
 746         piLen = NULL;
 747     }
 748     if (sciErr.iErr)
 749     {
 750         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
 751         printError(&sciErr, 0);
 752         return sciErr.iErr;
 753     }
 754
 755     return 0;
 756 }
 757 /*--------------------------------------------------------------------------*/
 758 int createSingleString(void* _pvCtx, int _iVar, const char* _pstStrings)
 759 {
 760     SciErr sciErr = createMatrixOfString(_pvCtx, _iVar, 1, 1,   &_pstStrings);
 761     if (sciErr.iErr)
 762     {
 763         addErrorMessage(&sciErr, API_ERROR_CREATE_SINGLE_STRING, _("%s: Unable to get argument data"), "createSingleString");
 764         printError(&sciErr, 0);
 765         return sciErr.iErr;
 766     }
 767
 768     return 0;
 769 }
 770
 771 int allocSingleString(void* _pvCtx, int _iVar, int _iLen, const char** _pstStrings)
 772 {
 773     SciErr sciErr = sciErrInit();
 774 #if 0
 775     int iNewPos     = Top - Rhs + _iVar;
 776     int iAddr       = *Lstk(iNewPos);
 777     int* piAddr     = NULL;
 778     int* piOffset   = NULL;
 779     char* pstString = NULL;
 780
 781     int iFreeSpace = iadr(*Lstk(Bot)) - (iadr(*Lstk(Top)));
 782
 783     if (_iLen + 2 > iFreeSpace)
 784     {
 785         addStackSizeError(&sciErr, ((StrCtx*)_pvCtx)->pstName, _iLen + 2);
 786         return sciErr.iErr;
 787     }
 788
 789     getNewVarAddressFromPosition(_pvCtx, iNewPos, &piAddr);
 790
 791     piAddr[0]   = sci_strings;
 792     piAddr[1]   = 1;
 793     piAddr[2]   = 1;
 794     piAddr[3]   = 0;
 795
 796     piOffset    = piAddr + 4;
 797     piOffset[0] = 1; //Always 1
 798     piOffset[1] = _iLen + 1;
 799     pstString   = (char*)(piOffset + 2); //2 offsets
 800 #endif
 801     return 0;
 802 }
 803
 804 /*--------------------------------------------------------------------------*/
 805 int createSingleWideString(void* _pvCtx, int _iVar, const wchar_t* _pwstStrings)
 806 {
 807     SciErr sciErr = createMatrixOfWideString(_pvCtx, _iVar, 1, 1,       &_pwstStrings);
 808     if (sciErr.iErr)
 809     {
 810         addErrorMessage(&sciErr, API_ERROR_CREATE_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "createSingleWideString");
 811         printError(&sciErr, 0);
 812         return sciErr.iErr;
 813     }
 814
 815     return 0;
 816 }
 817 /*--------------------------------------------------------------------------*/
 818 int createNamedSingleString(void* _pvCtx, const char* _pstName, const char* _pstStrings)
 819 {
 820     SciErr sciErr = createNamedMatrixOfString(_pvCtx, _pstName, 1, 1,   &_pstStrings);
 821     if (sciErr.iErr)
 822     {
 823         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SINGLE_STRING, _("%s: Unable to get argument data"), "createSingleString");
 824         printError(&sciErr, 0);
 825         return sciErr.iErr;
 826     }
 827
 828     return 0;
 829 }
 830 /*--------------------------------------------------------------------------*/
 831 int createNamedSingleWideString(void* _pvCtx, const char* _pstName, const wchar_t* _pwstStrings)
 832 {
 833     SciErr sciErr = createNamedMatrixOfWideString(_pvCtx, _pstName, 1, 1,       &_pwstStrings);
 834     if (sciErr.iErr)
 835     {
 836         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "createSingleWideString");
 837         printError(&sciErr, 0);
 838         return sciErr.iErr;
 839     }
 840
 841     return 0;
 842 }
 843 /*--------------------------------------------------------------------------*/
 844 void freeAllocatedSingleString(char* _pstData)
 845 {
 846     FREE(_pstData);
 847 }
 848 /*--------------------------------------------------------------------------*/
 849 void freeAllocatedSingleWideString(wchar_t* _pwstData)
 850 {
 851     FREE(_pwstData);
 852 }
 853 /*--------------------------------------------------------------------------*/
 854 void freeAllocatedMatrixOfString(int _iRows, int _iCols, char** _pstData)
 855 {
 856     for (int i = 0 ; i < _iRows * _iCols ; i++)
 857     {
 858         FREE(_pstData[i]);
 859     }
 860     FREE(_pstData);
 861 }
 862 /*--------------------------------------------------------------------------*/
 863 void freeAllocatedMatrixOfWideString(int _iRows, int _iCols, wchar_t** _pwstData)
 864 {
 865     for (int i = 0 ; i < _iRows * _iCols ; i++)
 866     {
 867         FREE(_pwstData[i]);
 868     }
 869     FREE(_pwstData);
 870 }
 871 /*--------------------------------------------------------------------------*/