License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_int.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  * Please note that piece of code will be rewrited for the Scilab 6 family
15  * However, the API (profile of the functions in the header files) will be
16  * still available and supported in Scilab 6.
17  */
18
19 #include "gatewaystruct.hxx"
20 #include "int.hxx"
21 #include "context.hxx"
22
23 extern "C"
24 {
25 #include <string.h>
26 #include <stdlib.h>
27 #include "localization.h"
28 #include "api_scilab.h"
29 #include "api_internal_int.h"
30 #include "api_internal_common.h"
31 }
32
33 static int getCommonScalarInteger(void* _pvCtx, int* _piAddress, int _iPrec, void** _pvData);
34 static int getCommonNamedScalarInteger(void* _pvCtx, const char* _pstName, int _iPrec, void** _pvData);
35
36
37 SciErr getMatrixOfIntegerPrecision(void* _pvCtx, int* _piAddress, int* _piPrecision)
38 {
39     SciErr sciErr = sciErrInit();
40     if (_piAddress == NULL)
41     {
42         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfIntegerPrecision");
43         return sciErr;
44     }
45
46     if (!((types::InternalType*)_piAddress)->isInt())
47     {
48         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfIntegerPrecision", _("int matrix"));
49         return sciErr;
50     }
51
52     switch (((types::InternalType*)_piAddress)->getType())
53     {
54         case types::InternalType::ScilabInt8 :
55             *_piPrecision = SCI_INT8;
56             break;
57         case types::InternalType::ScilabUInt8 :
58             *_piPrecision = SCI_UINT8;
59             break;
60         case types::InternalType::ScilabInt16 :
61             *_piPrecision = SCI_INT16;
62             break;
63         case types::InternalType::ScilabUInt16 :
64             *_piPrecision = SCI_UINT16;
65             break;
66         case types::InternalType::ScilabInt32 :
67             *_piPrecision = SCI_INT32;
68             break;
69         case types::InternalType::ScilabUInt32 :
70             *_piPrecision = SCI_UINT32;
71             break;
72         case types::InternalType::ScilabInt64 :
73             *_piPrecision = SCI_INT64;
74             break;
75         case types::InternalType::ScilabUInt64 :
76             *_piPrecision = SCI_UINT64;
77             break;
78         default:
79             return sciErr;
80     }
81     return sciErr;
82 }
83
84 SciErr getMatrixOfUnsignedInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned char** _pucData8)
85 {
86     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_UINT8, _piRows, _piCols, (void**)_pucData8);
87 }
88
89 SciErr getMatrixOfUnsignedInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned short** _pusData16)
90 {
91     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_UINT16, _piRows, _piCols, (void**)_pusData16);
92 }
93
94 SciErr getMatrixOfUnsignedInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned int** _puiData32)
95 {
96     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_UINT32, _piRows, _piCols, (void**)_puiData32);
97 }
98
99 #ifdef __SCILAB_INT64__
100 SciErr getMatrixOfUnsignedInteger64(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned long long** _pullData64)
101 {
102     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_UINT64, _piRows, _piCols, (void**)_pullData64);
103 }
104 #endif
105
106 SciErr getMatrixOfInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, char** _pcData8)
107 {
108     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_INT8, _piRows, _piCols, (void**)_pcData8);
109 }
110
111 SciErr getMatrixOfInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, short** _psData16)
112 {
113     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_INT16, _piRows, _piCols, (void**)_psData16);
114 }
115
116 SciErr getMatrixOfInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piData32)
117 {
118     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_INT32, _piRows, _piCols, (void**)_piData32);
119 }
120
121 #ifdef __SCILAB_INT64__
122 SciErr getMatrixOfInteger64(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, long long** _pllData64)
123 {
124     return getCommonMatrixOfInteger(_pvCtx, _piAddress, SCI_INT64, _piRows, _piCols, (void**)_pllData64);
125 }
126 #endif
127
128 SciErr getCommonMatrixOfInteger(void* _pvCtx, int* _piAddress, int _iPrecision, int* _piRows, int* _piCols, void** _piData)
129 {
130     SciErr sciErr = sciErrInit();
131     int iPrec = 0;
132
133     if (_piAddress == NULL)
134     {
135         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfInteger");
136         return sciErr;
137     }
138
139     sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
140     if (sciErr.iErr)
141     {
142         addErrorMessage(&sciErr, API_ERROR_GET_INT, _("%s: Unable to get argument #%d"), "getMatrixOfInteger", getRhsFromAddress(_pvCtx, _piAddress));
143         return sciErr;
144     }
145
146     if (iPrec != _iPrecision)
147     {
148         addErrorMessage(&sciErr, API_ERROR_GET_INT, _("%s: Unable to get argument #%d"), "getMatrixOfInteger", getRhsFromAddress(_pvCtx, _piAddress));
149         return sciErr;
150     }
151
152     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
153     if (sciErr.iErr)
154     {
155         addErrorMessage(&sciErr, API_ERROR_GET_INT, _("%s: Unable to get argument #%d"), "getMatrixOfInteger", getRhsFromAddress(_pvCtx, _piAddress));
156         return sciErr;
157     }
158
159     switch (((types::InternalType*)_piAddress)->getType())
160     {
161         case types::InternalType::ScilabInt8 :
162             *_piData = (void*)((types::InternalType*)_piAddress)->getAs<types::Int8>()->get();
163             break;
164         case types::InternalType::ScilabUInt8 :
165             *_piData = (void*)((types::InternalType*)_piAddress)->getAs<types::UInt8>()->get();
166             break;
167         case types::InternalType::ScilabInt16 :
168             *_piData = (void*)((types::InternalType*)_piAddress)->getAs<types::Int16>()->get();
169             break;
170         case types::InternalType::ScilabUInt16 :
171             *_piData    = (void*)((types::InternalType*)_piAddress)->getAs<types::UInt16>()->get();
172             break;
173         case types::InternalType::ScilabInt32 :
174             *_piData    = (void*)((types::InternalType*)_piAddress)->getAs<types::Int32>()->get();
175             break;
176         case types::InternalType::ScilabUInt32 :
177             *_piData    = (void*)((types::InternalType*)_piAddress)->getAs<types::UInt32>()->get();
178             break;
179         case types::InternalType::ScilabInt64 :
180             *_piData    = (void*)((types::InternalType*)_piAddress)->getAs<types::Int64>()->get();
181             break;
182         case types::InternalType::ScilabUInt64 :
183             *_piData    = (void*)((types::InternalType*)_piAddress)->getAs<types::UInt64>()->get();
184             break;
185         default:
186             return sciErr;
187     }
188
189     return sciErr;
190 }
191
192 SciErr createMatrixOfUnsignedInteger8(void* _pvCtx, int _iVar, int _iRows, int _iCols, const unsigned char* _pucData8)
193 {
194     unsigned char *pucData8 = NULL;
195     int iSize = _iRows * _iCols;
196
197     if (_iRows == 0 && _iCols == 0)
198     {
199         double dblReal = 0;
200         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
201         if (sciErr.iErr)
202         {
203             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
204         }
205         return sciErr;
206     }
207
208     SciErr sciErr = allocMatrixOfUnsignedInteger8(_pvCtx, _iVar, _iRows, _iCols, &pucData8);
209     if (sciErr.iErr)
210     {
211         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfUnsignedInteger8");
212         return sciErr;
213     }
214
215     memcpy(pucData8, _pucData8, sizeof(unsigned char) * iSize);
216     return sciErr;
217 }
218
219 SciErr createMatrixOfUnsignedInteger16(void* _pvCtx, int _iVar, int _iRows, int _iCols, const unsigned short* _pusData16)
220 {
221     unsigned short *psData16 = NULL;
222     int iSize = _iRows * _iCols;
223
224     if (_iRows == 0 && _iCols == 0)
225     {
226         double dblReal = 0;
227         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
228         if (sciErr.iErr)
229         {
230             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
231         }
232         return sciErr;
233     }
234
235     SciErr sciErr = allocMatrixOfUnsignedInteger16(_pvCtx, _iVar, _iRows, _iCols, &psData16);
236     if (sciErr.iErr)
237     {
238         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfUnsignedInteger16");
239         return sciErr;
240     }
241
242     memcpy(psData16, _pusData16, sizeof(unsigned short) * iSize);
243     return sciErr;
244 }
245
246 SciErr createMatrixOfUnsignedInteger32(void* _pvCtx, int _iVar, int _iRows, int _iCols, const unsigned int* _puiData32)
247 {
248     unsigned int *piData32 = NULL;
249     int iSize = _iRows * _iCols;
250
251     if (_iRows == 0 && _iCols == 0)
252     {
253         double dblReal = 0;
254         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
255         if (sciErr.iErr)
256         {
257             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
258         }
259         return sciErr;
260     }
261
262     SciErr sciErr = allocMatrixOfUnsignedInteger32(_pvCtx, _iVar, _iRows, _iCols, &piData32);
263     if (sciErr.iErr)
264     {
265         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfUnsignedInteger32");
266         return sciErr;
267     }
268
269     memcpy(piData32, _puiData32, sizeof(unsigned int) * iSize);
270     return sciErr;
271 }
272
273 #ifdef __SCILAB_INT64__
274 SciErr createMatrixOfUnsignedInteger64(void* _pvCtx, int _iVar, int _iRows, int _iCols, const unsigned long long* _pullData64)
275 {
276     SciErr sciErr = sciErrInit();
277     unsigned long long *pullData64      = NULL;
278     int iSize                   = _iRows * _iCols;
279
280     sciErr = allocMatrixOfUnsignedInteger64(_pvCtx, _iVar, _iRows, _iCols, &pullData64);
281     if (sciErr.iErr)
282     {
283         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfUnsignedInteger64");
284         return sciErr;
285     }
286
287     memcpy(pullData64, _pullData64, sizeof(unsigned long long) * iSize);
288     return sciErr;
289 }
290 #endif
291
292 SciErr createMatrixOfInteger8(void* _pvCtx, int _iVar, int _iRows, int _iCols, const char* _pcData8)
293 {
294     char *pcData8 = NULL;
295     int iSize = _iRows * _iCols;
296
297     if (_iRows == 0 && _iCols == 0)
298     {
299         double dblReal = 0;
300         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
301         if (sciErr.iErr)
302         {
303             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
304         }
305         return sciErr;
306     }
307
308     SciErr sciErr = allocMatrixOfInteger8(_pvCtx, _iVar, _iRows, _iCols, &pcData8);
309     if (sciErr.iErr)
310     {
311         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfInteger8");
312         return sciErr;
313     }
314
315     memcpy(pcData8, _pcData8, sizeof(char) * iSize);
316     return sciErr;
317 }
318
319 SciErr createMatrixOfInteger16(void* _pvCtx, int _iVar, int _iRows, int _iCols, const short* _psData16)
320 {
321     short *psData16 = NULL;
322     int iSize = _iRows * _iCols;
323
324     if (_iRows == 0 && _iCols == 0)
325     {
326         double dblReal = 0;
327         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
328         if (sciErr.iErr)
329         {
330             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
331         }
332         return sciErr;
333     }
334
335     SciErr sciErr = allocMatrixOfInteger16(_pvCtx, _iVar, _iRows, _iCols, &psData16);
336     if (sciErr.iErr)
337     {
338         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfInteger16");
339         return sciErr;
340     }
341
342     memcpy(psData16, _psData16, sizeof(short) * iSize);
343     return sciErr;
344 }
345
346 SciErr createMatrixOfInteger32(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piData32)
347 {
348     int *piData32 = NULL;
349     int iSize = _iRows * _iCols;
350
351     if (_iRows == 0 && _iCols == 0)
352     {
353         double dblReal = 0;
354         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
355         if (sciErr.iErr)
356         {
357             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
358         }
359         return sciErr;
360     }
361
362     SciErr sciErr = allocMatrixOfInteger32(_pvCtx, _iVar, _iRows, _iCols, &piData32);
363     if (sciErr.iErr)
364     {
365         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfInteger32");
366         return sciErr;
367     }
368
369     memcpy(piData32, _piData32, sizeof(int) * iSize);
370     return sciErr;
371 }
372
373 #ifdef __SCILAB_INT64__
374 SciErr createMatrixOfInteger64(void* _pvCtx, int _iVar, int _iRows, int _iCols, const long long* _pllData64)
375 {
376     SciErr sciErr = sciErrInit();
377     long long  *pllData64 = NULL;
378     int iSize = _iRows * _iCols;
379
380     if (_iRows == 0 && _iCols == 0)
381     {
382         double dblReal = 0;
383         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
384         if (sciErr.iErr)
385         {
386             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
387         }
388         return sciErr;
389     }
390
391     sciErr = allocMatrixOfInteger64(_pvCtx, _iVar, _iRows, _iCols, &pllData64);
392     if (sciErr.iErr)
393     {
394         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfInteger64");
395         return sciErr;
396     }
397
398     memcpy(pllData64, _pllData64, sizeof(long long) * iSize);
399     return sciErr;
400 }
401 #endif
402
403 SciErr allocMatrixOfInteger8(void* _pvCtx, int _iVar, int _iRows, int _iCols, char** _pcData8)
404 {
405     SciErr sciErr   = sciErrInit();
406     int *piAddr     = NULL;
407     char *pcData8   = NULL;
408
409     if (_iRows == 0 && _iCols == 0)
410     {
411         double dblReal = 0;
412         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
413         if (sciErr.iErr)
414         {
415             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
416         }
417         return sciErr;
418     }
419
420     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
421
422     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_INT8, _iRows, _iCols, (void**)&pcData8);
423     if (sciErr.iErr)
424     {
425         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfInteger8");
426         return sciErr;
427     }
428
429     *_pcData8 = pcData8;
430     return sciErr;
431 }
432
433 SciErr allocMatrixOfInteger16(void* _pvCtx, int _iVar, int _iRows, int _iCols, short** _psData16)
434 {
435     SciErr sciErr = sciErrInit();
436     int *piAddr                 = NULL;
437     short *psData16     = NULL;
438
439     if (_iRows == 0 && _iCols == 0)
440     {
441         double dblReal = 0;
442         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
443         if (sciErr.iErr)
444         {
445             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
446         }
447         return sciErr;
448     }
449
450     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
451
452     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_INT16, _iRows, _iCols, (void**)&psData16);
453     if (sciErr.iErr)
454     {
455         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfInteger16");
456         return sciErr;
457     }
458
459     *_psData16  = psData16;
460     return sciErr;
461 }
462
463 SciErr allocMatrixOfInteger32(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piData32)
464 {
465     SciErr sciErr = sciErrInit();
466     int *piAddr         = NULL;
467     int *piData32       = NULL;
468     //  int iNewPos             = api_Top((int*)_pvCtx) - *getInputArgument(_pvCtx) + _iVar;
469
470     if (_iRows == 0 && _iCols == 0)
471     {
472         double dblReal = 0;
473         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
474         if (sciErr.iErr)
475         {
476             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
477         }
478         return sciErr;
479     }
480
481     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
482
483     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_INT32, _iRows, _iCols, (void**)&piData32);
484     if (sciErr.iErr)
485     {
486         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfInteger32");
487         return sciErr;
488     }
489
490     *_piData32  = piData32;
491     return sciErr;
492 }
493
494 #ifdef __SCILAB_INT64__
495 SciErr allocMatrixOfInteger64(void* _pvCtx, int _iVar, int _iRows, int _iCols, long long** _pllData64)
496 {
497     SciErr sciErr = sciErrInit();
498     int *piAddr             = NULL;
499     long long *pllData64    = NULL;
500     //  int iNewPos             = api_Top((int*)_pvCtx) - *getInputArgument(_pvCtx) + _iVar;
501
502     if (_iRows == 0 && _iCols == 0)
503     {
504         double dblReal = 0;
505         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
506         if (sciErr.iErr)
507         {
508             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
509         }
510         return sciErr;
511     }
512
513     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
514
515     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_INT64, _iRows, _iCols, (void**)&pllData64);
516     if (sciErr.iErr)
517     {
518         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfInteger64");
519         return sciErr;
520     }
521
522     *_pllData64 = pllData64;
523     return sciErr;
524 }
525 #endif
526
527 SciErr allocMatrixOfUnsignedInteger8(void* _pvCtx, int _iVar, int _iRows, int _iCols, unsigned char** _pucData8)
528 {
529     SciErr sciErr = sciErrInit();
530     int *piAddr                                                 = NULL;
531     unsigned char *pucData8     = NULL;
532
533     if (_iRows == 0 && _iCols == 0)
534     {
535         double dblReal = 0;
536         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
537         if (sciErr.iErr)
538         {
539             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
540         }
541         return sciErr;
542     }
543
544     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
545
546     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_UINT8, _iRows, _iCols, (void**)&pucData8);
547     if (sciErr.iErr)
548     {
549         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfUnsignedInteger8");
550         return sciErr;
551     }
552
553     *_pucData8 = pucData8;
554     return sciErr;
555 }
556
557 SciErr allocMatrixOfUnsignedInteger16(void* _pvCtx, int _iVar, int _iRows, int _iCols, unsigned short** _pusData16)
558 {
559     SciErr sciErr = sciErrInit();
560     int *piAddr = NULL;
561     unsigned short *pusData16   = NULL;
562
563     if (_iRows == 0 && _iCols == 0)
564     {
565         double dblReal = 0;
566         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
567         if (sciErr.iErr)
568         {
569             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
570         }
571         return sciErr;
572     }
573
574     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
575
576     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_UINT16, _iRows, _iCols, (void**)&pusData16);
577     if (sciErr.iErr)
578     {
579         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfUnsignedInteger16");
580         return sciErr;
581     }
582
583     *_pusData16 = pusData16;
584     return sciErr;
585 }
586
587 SciErr allocMatrixOfUnsignedInteger32(void* _pvCtx, int _iVar, int _iRows, int _iCols, unsigned int** _puiData32)
588 {
589     SciErr sciErr = sciErrInit();
590     int *piAddr = NULL;
591     unsigned int *puiData32     = NULL;
592
593     if (_iRows == 0 && _iCols == 0)
594     {
595         double dblReal = 0;
596         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
597         if (sciErr.iErr)
598         {
599             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
600         }
601         return sciErr;
602     }
603
604     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
605
606     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_UINT32, _iRows, _iCols, (void**)&puiData32);
607     if (sciErr.iErr)
608     {
609         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfUnsignedInteger32");
610         return sciErr;
611     }
612
613     *_puiData32 = puiData32;
614     return sciErr;
615 }
616
617 #ifdef __SCILAB_INT64__
618 SciErr allocMatrixOfUnsignedInteger64(void* _pvCtx, int _iVar, int _iRows, int _iCols, unsigned long long** _pullData64)
619 {
620     SciErr sciErr = sciErrInit();
621     int *piAddr = NULL;
622     unsigned long long *pullData64      = NULL;
623
624     if (_iRows == 0 && _iCols == 0)
625     {
626         double dblReal = 0;
627         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
628         if (sciErr.iErr)
629         {
630             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
631         }
632         return sciErr;
633     }
634
635     getNewVarAddressFromPosition(_pvCtx, _iVar/*iNewPos*/, &piAddr);
636
637     sciErr = allocCommonMatrixOfInteger(_pvCtx, _iVar, piAddr, SCI_UINT64, _iRows, _iCols, (void**)&pullData64);
638     if (sciErr.iErr)
639     {
640         addErrorMessage(&sciErr, API_ERROR_CREATE_INT, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfUnsignedInteger64");
641         return sciErr;
642     }
643
644     *_pullData64        = pullData64;
645     return sciErr;
646 }
647 #endif
648
649 SciErr allocCommonMatrixOfInteger(void* _pvCtx, int _iVar, int *_piAddress, int _iPrecision, int _iRows, int _iCols, void** _pvData)
650 {
651     SciErr sciErr = sciErrInit();
652
653     //return empty matrix
654     if (_iRows == 0 && _iCols == 0)
655     {
656         double dblReal = 0;
657         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
658         if (sciErr.iErr)
659         {
660             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
661         }
662         return sciErr;
663     }
664
665     if (_pvCtx == NULL)
666     {
667         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "allocMatrixOfInteger");
668         return sciErr;
669     }
670
671     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
672     types::InternalType** out = pStr->m_pOut;
673
674     types::InternalType *pIT = nullptr;
675     switch (_iPrecision)
676     {
677         case SCI_INT8 :
678             pIT = new types::Int8(_iRows, _iCols, (char**)_pvData);
679             break;
680         case SCI_UINT8 :
681             pIT = new types::UInt8(_iRows, _iCols, (unsigned char**)_pvData);
682             break;
683         case SCI_INT16 :
684             pIT = new types::Int16(_iRows, _iCols, (short**)_pvData);
685             break;
686         case SCI_UINT16 :
687             pIT = new types::UInt16(_iRows, _iCols, (unsigned short**)_pvData);
688             break;
689         case SCI_INT32 :
690             pIT = new types::Int32(_iRows, _iCols, (int**)_pvData);
691             break;
692         case SCI_UINT32 :
693             pIT = new types::UInt32(_iRows, _iCols, (unsigned int**)_pvData);
694             break;
695         case SCI_INT64 :
696             pIT = new types::Int64(_iRows, _iCols, (long long**)_pvData);
697             break;
698         case SCI_UINT64 :
699             pIT = new types::UInt64(_iRows, _iCols, (unsigned long long**)_pvData);
700             break;
701     }
702
703     if (pIT == NULL)
704     {
705         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), "allocMatrixOfInteger");
706         return sciErr;
707     }
708
709     int rhs = _iVar - *getNbInputArgument(_pvCtx);
710     out[rhs - 1] = pIT;
711     return sciErr;
712 }
713
714 SciErr createNamedMatrixOfUnsignedInteger8(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const unsigned char* _pucData8)
715 {
716     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT8, _iRows, _iCols, _pucData8);
717 }
718
719 SciErr createNamedMatrixOfUnsignedInteger16(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const unsigned short* _pusData16)
720 {
721     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT16, _iRows, _iCols, _pusData16);
722 }
723
724 SciErr createNamedMatrixOfUnsignedInteger32(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const unsigned int* _puiData32)
725 {
726     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT32, _iRows, _iCols, _puiData32);
727 }
728
729 #ifdef __SCILAB_INT64__
730 SciErr createNamedMatrixOfUnsignedInteger64(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const unsigned long long* _pullData64)
731 {
732     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT64, _iRows, _iCols, _pullData64);
733 }
734 #endif
735
736 SciErr createNamedMatrixOfInteger8(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const char* _pcData8)
737 {
738     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT8, _iRows, _iCols, _pcData8);
739 }
740
741 SciErr createNamedMatrixOfInteger16(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const short* _psData16)
742 {
743     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT16, _iRows, _iCols, _psData16);
744 }
745
746 SciErr createNamedMatrixOfInteger32(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const int* _piData32)
747 {
748     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT32, _iRows, _iCols, _piData32);
749 }
750
751 #ifdef __SCILAB_INT64__
752 SciErr createNamedMatrixOfInteger64(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const long long* _pllData64)
753 {
754     return createCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT64, _iRows, _iCols, _pllData64);
755 }
756 #endif
757
758 SciErr createCommonNamedMatrixOfInteger(void* _pvCtx, const char* _pstName, int _iPrecision, int _iRows, int _iCols, const void* _pvData)
759 {
760     SciErr sciErr = sciErrInit();
761
762     // check variable name
763     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
764     {
765         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createCommonNamedMatrixOfInteger", _pstName);
766         return sciErr;
767     }
768
769     //return empty matrix
770     if (_iRows == 0 && _iCols == 0)
771     {
772         if (createNamedEmptyMatrix(_pvCtx, _pstName))
773         {
774             addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
775         }
776
777         return sciErr;
778     }
779
780     types::InternalType *pIT = nullptr;
781     switch (_iPrecision)
782     {
783         case SCI_INT8 :
784         {
785             types::Int8 *pInt8 = new types::Int8(_iRows, _iCols);
786             pInt8->set((char*)_pvData);
787             pIT = pInt8;
788             break;
789         }
790         case SCI_UINT8:
791         {
792             types::UInt8 *pUInt8 = new types::UInt8(_iRows, _iCols);
793             pUInt8->set((unsigned char*)_pvData);
794             pIT = pUInt8;
795             break;
796         }
797         case SCI_INT16 :
798         {
799             types::Int16 *pInt16 = new types::Int16(_iRows, _iCols);
800             pInt16->set((short*)_pvData);
801             pIT = pInt16;
802             break;
803         }
804         case SCI_UINT16:
805         {
806             types::UInt16 *pUInt16 = new types::UInt16(_iRows, _iCols);
807             pUInt16->set((unsigned short*)_pvData);
808             pIT = pUInt16;
809             break;
810         }
811         case SCI_INT32:
812         {
813             types::Int32 *pInt32 = new types::Int32(_iRows, _iCols);
814             pInt32->set((int*)_pvData);
815             pIT = pInt32;
816             break;
817         }
818         case SCI_UINT32:
819         {
820             types::UInt32 *pUInt32 = new types::UInt32(_iRows, _iCols);
821             pUInt32->set((unsigned int*)_pvData);
822             pIT = pUInt32;
823             break;
824         }
825         case SCI_INT64:
826         {
827             types::Int64 *pInt64 = new types::Int64(_iRows, _iCols);
828             pInt64->set((long long*)_pvData);
829             pIT = pInt64;
830             break;
831         }
832         case SCI_UINT64:
833         {
834             types::UInt64 *pUInt64 = new types::UInt64(_iRows, _iCols);
835             pUInt64->set((unsigned long long*)_pvData);
836             pIT = pUInt64;
837             break;
838         }
839     }
840
841     if (pIT == NULL)
842     {
843         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), "allocMatrixOfInteger");
844         return sciErr;
845     }
846
847     wchar_t* pwstName = to_wide_string(_pstName);
848     symbol::Context* ctx = symbol::Context::getInstance();
849     symbol::Symbol sym = symbol::Symbol(pwstName);
850     FREE(pwstName);
851     if (ctx->isprotected(sym) == false)
852     {
853         ctx->put(sym, pIT);
854     }
855     else
856     {
857         delete pIT;
858         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
859     }
860     return sciErr;
861 }
862
863 SciErr getNamedMatrixOfIntegerPrecision(void* _pvCtx, const char* _pstName, int* _piPrecision)
864 {
865     int* piAddr = NULL;
866
867     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
868     if (sciErr.iErr)
869     {
870         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_INT_PRECISION, _("%s: Unable to get precision of variable \"%s\""), "getNamedMatrixOfIntegerPrecision", _pstName);
871         return sciErr;
872     }
873
874     types::InternalType* pIT = (types::InternalType*)piAddr;
875
876     //check variable type
877     if (pIT->isInt() == false)
878     {
879         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getNamedMatrixOfIntegerPrecision", _("int matrix"));
880         return sciErr;
881     }
882
883     switch (pIT->getType())
884     {
885         case types::InternalType::ScilabInt8 :
886             *_piPrecision = sci_int8;
887             break;
888         case types::InternalType::ScilabUInt8 :
889             *_piPrecision = sci_uint8;
890             break;
891         case types::InternalType::ScilabInt16 :
892             *_piPrecision = sci_int16;
893             break;
894         case types::InternalType::ScilabUInt16 :
895             *_piPrecision = sci_uint16;
896             break;
897         case types::InternalType::ScilabInt32 :
898             *_piPrecision = sci_int32;
899             break;
900         case types::InternalType::ScilabUInt32 :
901             *_piPrecision = sci_uint32;
902             break;
903         case types::InternalType::ScilabInt64 :
904             *_piPrecision = sci_int64;
905             break;
906         case types::InternalType::ScilabUInt64 :
907             *_piPrecision = sci_uint64;
908             break;
909         default :
910             // That never occurs, the previous test prevents that.
911             *_piPrecision = -1;
912             break;
913     }
914
915     return sciErr;
916 }
917
918 SciErr readNamedMatrixOfUnsignedInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned char* _pucData8)
919 {
920     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT8, _piRows, _piCols, _pucData8);
921 }
922
923 SciErr readNamedMatrixOfUnsignedInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned short* _pusData16)
924 {
925     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT16, _piRows, _piCols, _pusData16);
926 }
927
928 SciErr readNamedMatrixOfUnsignedInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned int* _puiData32)
929 {
930     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT32, _piRows, _piCols, _puiData32);
931 }
932
933 #ifdef __SCILAB_INT64__
934 SciErr readNamedMatrixOfUnsignedInteger64(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned long long* _pullData64)
935 {
936     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_UINT64, _piRows, _piCols, _pullData64);
937 }
938 #endif
939
940 SciErr readNamedMatrixOfInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, char* _pcData8)
941 {
942     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT8, _piRows, _piCols, _pcData8);
943 }
944
945 SciErr readNamedMatrixOfInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, short* _psData16)
946 {
947     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT16, _piRows, _piCols, _psData16);
948 }
949
950 SciErr readNamedMatrixOfInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piData32)
951 {
952     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT32, _piRows, _piCols, _piData32);
953 }
954
955 #ifdef __SCILAB_INT64__
956 SciErr readNamedMatrixOfInteger64(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, long long* _pllData64)
957 {
958     return readCommonNamedMatrixOfInteger(_pvCtx, _pstName, SCI_INT64, _piRows, _piCols, _pllData64);
959 }
960 #endif
961
962 SciErr readCommonNamedMatrixOfInteger(void* _pvCtx, const char* _pstName, int _iPrecision, int* _piRows, int* _piCols, void* _pvData)
963 {
964     int* piAddr = NULL;
965     int iSize = 0;
966     void* pvData = NULL;
967
968     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
969     if (sciErr.iErr)
970     {
971         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_INT, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfInteger", _pstName);
972         return sciErr;
973     }
974
975     sciErr = getCommonMatrixOfInteger(_pvCtx, piAddr, _iPrecision, _piRows, _piCols, &pvData);
976     if (sciErr.iErr)
977     {
978         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_INT, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfInteger", _pstName);
979         return sciErr;
980     }
981     iSize = *_piRows **_piCols;
982
983     if (pvData == NULL || _pvData == NULL)
984     {
985         return sciErr;
986     }
987
988     memcpy(_pvData, pvData, (_iPrecision % 10) * iSize);
989     return sciErr;
990 }
991
992 /* shortcut functions */
993
994 int isIntegerType(void* _pvCtx, int* _piAddress)
995 {
996     return checkVarType(_pvCtx, _piAddress, sci_ints);
997 }
998 /*--------------------------------------------------------------------------*/
999 int isNamedIntegerType(void* _pvCtx, const char* _pstName)
1000 {
1001     return checkNamedVarType(_pvCtx, _pstName, sci_ints);
1002 }
1003 /*--------------------------------------------------------------------------*/
1004 int getScalarInteger8(void* _pvCtx, int* _piAddress, char* _pcData)
1005 {
1006     char* pcData = NULL;
1007
1008     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_INT8, (void**)&pcData);
1009     if (iRet)
1010     {
1011         return iRet;
1012     }
1013
1014     *_pcData = pcData[0];
1015     return 0;
1016 }
1017 /*--------------------------------------------------------------------------*/
1018 int getScalarInteger16(void* _pvCtx, int* _piAddress, short* _psData)
1019 {
1020     short* psData = NULL;
1021
1022     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_INT16, (void**)&psData);
1023     if (iRet)
1024     {
1025         return iRet;
1026     }
1027
1028     *_psData = psData[0];
1029     return 0;
1030 }
1031 /*--------------------------------------------------------------------------*/
1032 int getScalarInteger32(void* _pvCtx, int* _piAddress, int* _piData)
1033 {
1034     int* piData = NULL;
1035
1036     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_INT32, (void**)&piData);
1037     if (iRet)
1038     {
1039         return iRet;
1040     }
1041
1042     *_piData = piData[0];
1043     return 0;
1044 }
1045 /*--------------------------------------------------------------------------*/
1046 #ifdef __SCILAB_INT64__
1047 int getScalarInteger64(void* _pvCtx, int* _piAddress, long long* _pllData)
1048 {
1049     long long* pllData = NULL;
1050
1051     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_INT64, (void**)&pllData);
1052     if (iRet)
1053     {
1054         return iRet;
1055     }
1056
1057     *_pllData = pllData[0];
1058     return 0;
1059 }
1060 #endif
1061 /*--------------------------------------------------------------------------*/
1062 int getScalarUnsignedInteger8(void* _pvCtx, int* _piAddress, unsigned char* _pucData)
1063 {
1064     unsigned char* pucData = NULL;
1065
1066     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_UINT8, (void**)&pucData);
1067     if (iRet)
1068     {
1069         return iRet;
1070     }
1071
1072     *_pucData = pucData[0];
1073     return 0;
1074 }
1075 /*--------------------------------------------------------------------------*/
1076 int getScalarUnsignedInteger16(void* _pvCtx, int* _piAddress, unsigned short* _pusData)
1077 {
1078     unsigned short* pusData = NULL;
1079
1080     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_UINT16, (void**)&pusData);
1081     if (iRet)
1082     {
1083         return iRet;
1084     }
1085
1086     *_pusData = pusData[0];
1087     return 0;
1088 }
1089 /*--------------------------------------------------------------------------*/
1090 int getScalarUnsignedInteger32(void* _pvCtx, int* _piAddress, unsigned int* _puiData)
1091 {
1092     unsigned int* puiData = NULL;
1093
1094     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_UINT32, (void**)&puiData);
1095     if (iRet)
1096     {
1097         return iRet;
1098     }
1099
1100     *_puiData = puiData[0];
1101     return 0;
1102 }
1103 /*--------------------------------------------------------------------------*/
1104 #ifdef __SCILAB_INT64__
1105 int getScalarUnsignedInteger64(void* _pvCtx, int* _piAddress, unsigned long long* _pullData)
1106 {
1107     unsigned long long* pullData = NULL;
1108
1109     int iRet = getCommonScalarInteger(_pvCtx, _piAddress, SCI_UINT64, (void**)&pullData);
1110     if (iRet)
1111     {
1112         return iRet;
1113     }
1114
1115     *_pullData = pullData[0];
1116     return 0;
1117 }
1118 #endif
1119 /*--------------------------------------------------------------------------*/
1120 static int getCommonScalarInteger(void* _pvCtx, int* _piAddress, int _iPrec, void** _pvData)
1121 {
1122     SciErr sciErr = sciErrInit();
1123     int iRows   = 0;
1124     int iCols   = 0;
1125
1126     if (isScalar(_pvCtx, _piAddress) == 0)
1127     {
1128         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_INTEGER, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "getScalarInteger", getRhsFromAddress(_pvCtx, _piAddress));
1129         printError(&sciErr, 0);
1130         return sciErr.iErr;
1131     }
1132
1133     sciErr = getCommonMatrixOfInteger(_pvCtx, _piAddress, _iPrec, &iRows, &iCols, _pvData);
1134     if (sciErr.iErr)
1135     {
1136         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_INTEGER, _("%s: Unable to get argument #%d"), "getScalarInteger", getRhsFromAddress(_pvCtx, _piAddress));
1137         printError(&sciErr, 0);
1138         return sciErr.iErr;
1139     }
1140
1141     return 0;
1142 }
1143 /*--------------------------------------------------------------------------*/
1144 int getNamedScalarInteger8(void* _pvCtx, const char* _pstName, char* _pcData)
1145 {
1146     char* pcData = NULL;
1147
1148     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_INT8, (void**)&pcData);
1149     if (iRet)
1150     {
1151         return iRet;
1152     }
1153
1154     *_pcData = pcData[0];
1155     return 0;
1156 }
1157 /*--------------------------------------------------------------------------*/
1158 int getNamedScalarInteger16(void* _pvCtx, const char* _pstName, short* _psData)
1159 {
1160     short* psData = NULL;
1161
1162     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_INT16, (void**)&psData);
1163     if (iRet)
1164     {
1165         return iRet;
1166     }
1167
1168     *_psData = psData[0];
1169     return 0;
1170 }
1171 /*--------------------------------------------------------------------------*/
1172 int getNamedScalarInteger32(void* _pvCtx, const char* _pstName, int* _piData)
1173 {
1174     int* piData = NULL;
1175
1176     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_INT32, (void**)&piData);
1177     if (iRet)
1178     {
1179         return iRet;
1180     }
1181
1182     *_piData = piData[0];
1183     return 0;
1184 }
1185 /*--------------------------------------------------------------------------*/
1186 #ifdef __SCILAB_INT64__
1187 int getNamedScalarInteger64(void* _pvCtx, const char* _pstName, long long* _pllData)
1188 {
1189     long long* pllData = NULL;
1190
1191     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_INT64, (void**)&pllData);
1192     if (iRet)
1193     {
1194         return iRet;
1195     }
1196
1197     *_pllData = pllData[0];
1198     return 0;
1199 }
1200 #endif
1201 /*--------------------------------------------------------------------------*/
1202 int getNamedScalarUnsignedInteger8(void* _pvCtx, const char* _pstName, unsigned char* _pucData)
1203 {
1204     unsigned char* pucData = NULL;
1205
1206     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_UINT8, (void**)&pucData);
1207     if (iRet)
1208     {
1209         return iRet;
1210     }
1211
1212     *_pucData = pucData[0];
1213     return 0;
1214 }
1215 /*--------------------------------------------------------------------------*/
1216 int getNamedScalarUnsignedInteger16(void* _pvCtx, const char* _pstName, unsigned short* _pusData)
1217 {
1218     unsigned short* pusData = NULL;
1219
1220     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_UINT16, (void**)&pusData);
1221     if (iRet)
1222     {
1223         return iRet;
1224     }
1225
1226     *_pusData = pusData[0];
1227     return 0;
1228 }
1229 /*--------------------------------------------------------------------------*/
1230 int getNamedScalarUnsignedInteger32(void* _pvCtx, const char* _pstName, unsigned int* _puiData)
1231 {
1232     unsigned int* puiData = NULL;
1233
1234     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_UINT32, (void**)&puiData);
1235     if (iRet)
1236     {
1237         return iRet;
1238     }
1239
1240     *_puiData = puiData[0];
1241     return 0;
1242 }
1243 /*--------------------------------------------------------------------------*/
1244 #ifdef __SCILAB_INT64__
1245 int getNamedScalarUnsignedInteger64(void* _pvCtx, const char* _pstName, unsigned long long* _pullData)
1246 {
1247     unsigned long long* pullData = NULL;
1248
1249     int iRet = getCommonNamedScalarInteger(_pvCtx, _pstName, SCI_UINT64, (void**)&pullData);
1250     if (iRet)
1251     {
1252         return iRet;
1253     }
1254
1255     *_pullData = pullData[0];
1256     return 0;
1257 }
1258 #endif
1259 /*--------------------------------------------------------------------------*/
1260 static int getCommonNamedScalarInteger(void* _pvCtx, const char* _pstName, int _iPrec, void** _pvData)
1261 {
1262     SciErr sciErr = sciErrInit();
1263     int iRows   = 0;
1264     int iCols   = 0;
1265
1266     if (isNamedScalar(_pvCtx, _pstName) == 0)
1267     {
1268         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_INTEGER, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), "getNamedScalarInteger", _pstName);
1269         printError(&sciErr, 0);
1270         return sciErr.iErr;
1271     }
1272
1273     sciErr = readCommonNamedMatrixOfInteger(_pvCtx, _pstName, _iPrec, &iRows, &iCols, _pvData);
1274     if (sciErr.iErr)
1275     {
1276         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_INTEGER, _("%s: Unable to get argument \"%s\""), "getNamedScalarInteger", _pstName);
1277         printError(&sciErr, 0);
1278         return sciErr.iErr;
1279     }
1280
1281     return 0;
1282 }
1283 /*--------------------------------------------------------------------------*/
1284 int createScalarInteger8(void* _pvCtx, int _iVar, char _cData)
1285 {
1286     SciErr sciErr = createMatrixOfInteger8(_pvCtx, _iVar, 1, 1, &_cData);
1287     if (sciErr.iErr)
1288     {
1289         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarInteger8");
1290         printError(&sciErr, 0);
1291         return sciErr.iErr;
1292     }
1293
1294     return 0;
1295 }
1296 /*--------------------------------------------------------------------------*/
1297 int createScalarInteger16(void* _pvCtx, int _iVar, short _sData)
1298 {
1299     SciErr sciErr = createMatrixOfInteger16(_pvCtx, _iVar, 1, 1, &_sData);
1300     if (sciErr.iErr)
1301     {
1302         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarInteger16");
1303         printError(&sciErr, 0);
1304         return sciErr.iErr;
1305     }
1306
1307     return 0;
1308 }
1309 /*--------------------------------------------------------------------------*/
1310 int createScalarInteger32(void* _pvCtx, int _iVar, int _iData)
1311 {
1312     SciErr sciErr = createMatrixOfInteger32(_pvCtx, _iVar, 1, 1, &_iData);
1313     if (sciErr.iErr)
1314     {
1315         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarInteger32");
1316         printError(&sciErr, 0);
1317         return sciErr.iErr;
1318     }
1319
1320     return 0;
1321 }
1322 /*--------------------------------------------------------------------------*/
1323 #ifdef __SCILAB_INT64__
1324 int createScalarInteger64(void* _pvCtx, int _iVar, long long _llData)
1325 {
1326     SciErr sciErr = sciErrInit();
1327     sciErr = createMatrixOfInteger64(_pvCtx, _iVar, 1, 1, &_llData);
1328     if (sciErr.iErr)
1329     {
1330         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarInteger64");
1331         printError(&sciErr, 0);
1332         return sciErr.iErr;
1333     }
1334
1335     return 0;
1336 }
1337 #endif
1338 /*--------------------------------------------------------------------------*/
1339 int createScalarUnsignedInteger8(void* _pvCtx, int _iVar, unsigned char _ucData)
1340 {
1341     SciErr sciErr = createMatrixOfUnsignedInteger8(_pvCtx, _iVar, 1, 1, &_ucData);
1342     if (sciErr.iErr)
1343     {
1344         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarUnsignedInteger8");
1345         printError(&sciErr, 0);
1346         return sciErr.iErr;
1347     }
1348
1349     return 0;
1350 }
1351 /*--------------------------------------------------------------------------*/
1352 int createScalarUnsignedInteger16(void* _pvCtx, int _iVar, unsigned short _usData)
1353 {
1354     SciErr sciErr = createMatrixOfUnsignedInteger16(_pvCtx, _iVar, 1, 1, &_usData);
1355     if (sciErr.iErr)
1356     {
1357         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarUnsignedInteger16");
1358         printError(&sciErr, 0);
1359         return sciErr.iErr;
1360     }
1361
1362     return 0;
1363 }
1364 /*--------------------------------------------------------------------------*/
1365 int createScalarUnsignedInteger32(void* _pvCtx, int _iVar, unsigned int _uiData)
1366 {
1367     SciErr sciErr = createMatrixOfUnsignedInteger32(_pvCtx, _iVar, 1, 1, &_uiData);
1368     if (sciErr.iErr)
1369     {
1370         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarUnsignedInteger32");
1371         printError(&sciErr, 0);
1372         return sciErr.iErr;
1373     }
1374
1375     return 0;
1376 }
1377 /*--------------------------------------------------------------------------*/
1378 #ifdef __SCILAB_INT64__
1379 int createScalarUnsignedInteger64(void* _pvCtx, int _iVar, unsigned long long _ullData)
1380 {
1381     SciErr sciErr = createMatrixOfUnsignedInteger64(_pvCtx, _iVar, 1, 1, &_ullData);
1382     if (sciErr.iErr)
1383     {
1384         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createScalarUnsignedInteger64");
1385         printError(&sciErr, 0);
1386         return sciErr.iErr;
1387     }
1388
1389     return 0;
1390 }
1391 #endif
1392 /*--------------------------------------------------------------------------*/
1393 int createNamedScalarInteger8(void* _pvCtx, const char* _pstName, char _cData)
1394 {
1395     SciErr sciErr = createNamedMatrixOfInteger8(_pvCtx, _pstName, 1, 1, &_cData);
1396     if (sciErr.iErr)
1397     {
1398         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarInteger8");
1399         printError(&sciErr, 0);
1400         return sciErr.iErr;
1401     }
1402
1403     return 0;
1404 }
1405 /*--------------------------------------------------------------------------*/
1406 int createNamedScalarInteger16(void* _pvCtx, const char* _pstName, short _sData)
1407 {
1408     SciErr sciErr = createNamedMatrixOfInteger16(_pvCtx, _pstName, 1, 1, &_sData);
1409     if (sciErr.iErr)
1410     {
1411         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarInteger16");
1412         printError(&sciErr, 0);
1413         return sciErr.iErr;
1414     }
1415
1416     return 0;
1417 }
1418 /*--------------------------------------------------------------------------*/
1419 int createNamedScalarInteger32(void* _pvCtx, const char* _pstName, int _iData)
1420 {
1421     SciErr sciErr = createNamedMatrixOfInteger32(_pvCtx, _pstName, 1, 1, &_iData);
1422     if (sciErr.iErr)
1423     {
1424         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarInteger32");
1425         printError(&sciErr, 0);
1426         return sciErr.iErr;
1427     }
1428
1429     return 0;
1430 }
1431 /*--------------------------------------------------------------------------*/
1432 #ifdef __SCILAB_INT64__
1433 int createNamedScalarInteger64(void* _pvCtx, const char* _pstName, long long _llData)
1434 {
1435     SciErr sciErr = createNamedMatrixOfInteger64(_pvCtx, _pstName, 1, 1, &_llData);
1436     if (sciErr.iErr)
1437     {
1438         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarInteger64");
1439         printError(&sciErr, 0);
1440         return sciErr.iErr;
1441     }
1442
1443     return 0;
1444 }
1445 #endif
1446 /*--------------------------------------------------------------------------*/
1447 int createNamedScalarUnsignedInteger8(void* _pvCtx, const char* _pstName, unsigned char _ucData)
1448 {
1449     SciErr sciErr = createNamedMatrixOfUnsignedInteger8(_pvCtx, _pstName, 1, 1, &_ucData);
1450     if (sciErr.iErr)
1451     {
1452         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarUnsignedInteger8");
1453         printError(&sciErr, 0);
1454         return sciErr.iErr;
1455     }
1456
1457     return 0;
1458 }
1459 /*--------------------------------------------------------------------------*/
1460 int createNamedScalarUnsignedInteger16(void* _pvCtx, const char* _pstName, unsigned short _usData)
1461 {
1462     SciErr sciErr = createNamedMatrixOfUnsignedInteger16(_pvCtx, _pstName, 1, 1, &_usData);
1463     if (sciErr.iErr)
1464     {
1465         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarUnsignedInteger16");
1466         printError(&sciErr, 0);
1467         return sciErr.iErr;
1468     }
1469
1470     return 0;
1471 }
1472 /*--------------------------------------------------------------------------*/
1473 int createNamedScalarUnsignedInteger32(void* _pvCtx, const char* _pstName, unsigned int _uiData)
1474 {
1475     SciErr sciErr = createNamedMatrixOfUnsignedInteger32(_pvCtx, _pstName, 1, 1, &_uiData);
1476     if (sciErr.iErr)
1477     {
1478         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarUnsignedInteger32");
1479         printError(&sciErr, 0);
1480         return sciErr.iErr;
1481     }
1482
1483     return 0;
1484 }
1485 /*--------------------------------------------------------------------------*/
1486 #ifdef __SCILAB_INT64__
1487 int createNamedScalarUnsignedInteger64(void* _pvCtx, const char* _pstName, unsigned long long _ullData)
1488 {
1489     SciErr sciErr = createNamedMatrixOfUnsignedInteger64(_pvCtx, _pstName, 1, 1, &_ullData);
1490     if (sciErr.iErr)
1491     {
1492         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR_INT, _("%s: Unable to create variable in Scilab memory"), "createNamedScalarUnsignedInteger64");
1493         printError(&sciErr, 0);
1494         return sciErr.iErr;
1495     }
1496
1497     return 0;
1498 }
1499 #endif
1500 /*--------------------------------------------------------------------------*/