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