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