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