Coverity: api_scilab module memory errors fixed
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_common.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 "types.hxx"
20 #include "internal.hxx"
21 #include "double.hxx"
22 #include "polynom.hxx"
23 #include "gatewaystruct.hxx"
24 #include "double.hxx"
25 #include "polynom.hxx"
26 #include "list.hxx"
27 #include "overload.hxx"
28 #include "context.hxx"
29 #include "symbol.hxx"
30
31 extern "C"
32 {
33 #include <string.h>
34 #include <stdlib.h>
35 #include "api_scilab.h"
36 #include "api_internal_common.h"
37 #include "call_scilab.h"
38 #include "Scierror.h"
39 #include "sciprint.h"
40 #include "localization.h"
41 #include "sci_malloc.h"
42 }
43
44 static int api_fake_int; //only for compatibility with Scilab 5 stack functions
45 /*Global structure for scilab 5.x*/
46 extern "C"
47 {
48     //StrCtx *pvApiCtx = NULL;
49 }
50
51 /*--------------------------------------------------------------------------*/
52 static SciErr getinternalVarAddress(void* _pvCtx, int _iVar, int** _piAddress);
53
54 /*--------------------------------------------------------------------------*/
55 /* Replaces Rhs */
56 int* getNbInputArgument(void* _pvCtx)
57 {
58     types::GatewayStruct *pStr = (types::GatewayStruct*)_pvCtx;
59
60     if (pStr == NULL)
61     {
62         std::cout << "pStr == NULL" << std::endl;
63         return NULL;
64     }
65
66     if (pStr->m_pIn == NULL)
67     {
68         std::cout << "pStr->m_pin == NULL" << std::endl;
69         return NULL;
70     }
71
72     return &pStr->m_iIn;;
73 }
74
75 /* Replaces Lhs */
76 int* getNbOutputArgument(void* _pvCtx)
77 {
78     types::GatewayStruct *pStr =  (types::GatewayStruct*)_pvCtx;
79
80     if (pStr == NULL)
81     {
82         return 0;
83     }
84
85     if (pStr->m_piRetCount == NULL)
86     {
87         return 0;
88     }
89
90     return &pStr->m_iOut;
91 }
92
93 int* assignOutputVariable(void* _pvCtx, int _iVal)
94 {
95     //do nothing but don't crash
96     if (_pvCtx == NULL)
97     {
98         return &api_fake_int;
99     }
100
101     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
102
103     //do nothing but don't crash
104     if (_iVal > *pStr->m_piRetCount || (_iVal - 1) < 0)
105     {
106         return &api_fake_int;
107     }
108
109     int* pVal = &(pStr->m_pOutOrder[_iVal - 1]);
110     return pVal;
111 }
112
113 int returnArguments(void* _pvCtx)
114 {
115     return 1;
116 }
117
118 int checkInputArgument(void* _pvCtx, int _iMin, int _iMax)
119 {
120     types::GatewayStruct *pStr = (types::GatewayStruct*)_pvCtx;
121     int iRhs            = *getNbInputArgument(_pvCtx);
122
123     if (_iMin <= nbInputArgument(_pvCtx) && _iMax >= nbInputArgument(_pvCtx))
124     {
125         return 1;
126     }
127
128     if (_iMin == _iMax)
129     {
130         /* No optional argument */
131         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), pStr->m_pstName, _iMax);
132     }
133     else
134     {
135         Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), pStr->m_pstName, _iMin, _iMax);
136     }
137     return 0;
138 }
139
140 SciErr reshapeArray(void* _pvCtx, int* _piAddress, int* _iDimsArray, int _iDims)
141 {
142     SciErr sciErr = sciErrInit();
143
144     types::InternalType* pIT = (types::InternalType*)_piAddress;
145     if (pIT->isGenericType() == false)
146     {
147         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "resizeArray", _("matrix"));
148         return sciErr;
149     }
150
151     pIT->getAs<types::GenericType>()->reshape(_iDimsArray, _iDims);
152
153     return sciErr;
154 }
155
156 /*--------------------------------------------------------------------------*/
157 int checkInputArgumentAtLeast(void* _pvCtx, int _iMin)
158 {
159     if (_iMin <= nbInputArgument(_pvCtx))
160     {
161         return 1;
162     }
163
164     Scierror(77, _("%s: Wrong number of input argument(s): at least %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMin);
165     return 0;
166 }
167
168 /*--------------------------------------------------------------------------*/
169 int checkInputArgumentAtMost(void* _pvCtx, int _iMax)
170 {
171     if (_iMax >= nbInputArgument(_pvCtx))
172     {
173         return 1;
174     }
175
176     Scierror(77, _("%s: Wrong number of input argument(s): at most %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMax);
177     return 0;
178 }
179
180 /*--------------------------------------------------------------------------*/
181 int checkOutputArgument(void* _pvCtx, int _iMin, int _iMax)
182 {
183     if (_iMin <= nbOutputArgument(_pvCtx) && _iMax >= nbOutputArgument(_pvCtx))
184     {
185         return 1;
186     }
187
188     if (_iMax == _iMin)
189     {
190         Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMax);
191     }
192     else
193     {
194         Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMin, _iMax);
195     }
196
197     return 0;
198 }
199
200 /*--------------------------------------------------------------------------*/
201 int checkOutputArgumentAtLeast(void* _pvCtx, int _iMin)
202 {
203     if (_iMin <= nbOutputArgument(_pvCtx))
204     {
205         return 1;
206     }
207
208     Scierror(78, _("%s: Wrong number of output argument(s): at least %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMin);
209     return 0;
210 }
211
212 /*--------------------------------------------------------------------------*/
213 int checkOutputArgumentAtMost(void* _pvCtx, int _iMax)
214 {
215     if (_iMax >= nbOutputArgument(_pvCtx))
216     {
217         return 1;
218     }
219
220     Scierror(78, _("%s: Wrong number of output argument(s): at most %d expected.\n"), ((types::GatewayStruct*)_pvCtx)->m_pstName, _iMax);
221     return 0;
222 }
223
224 /*--------------------------------------------------------------------------*/
225 int callScilabFunction(void* _pvCtx, char const* _pstName, int _iStart, int _iLhs, int _iRhs)
226 {
227     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
228     types::Function::ReturnValue callResult;
229
230     wchar_t* pwstName = to_wide_string(_pstName);
231     std::wstring wsFunName(pwstName);
232
233     types::typed_list in;
234     types::typed_list out;
235
236
237     for (int i = 0 ; i < _iRhs ; i++)
238     {
239         in.push_back((*pStr->m_pIn)[i + (_iStart - 1)]);
240         in[i]->IncreaseRef();
241     }
242
243     callResult = Overload::call(wsFunName, in, _iLhs, out);
244
245     //unprotect input arguments
246     for (int i = 0 ; i < _iRhs ; i++)
247     {
248         in[i]->DecreaseRef();
249     }
250
251     if (callResult == types::Function::OK)
252     {
253         int iCallerRhs = (int)pStr->m_pIn->size();
254         pStr->m_pIn->resize(iCallerRhs + _iRhs + _iLhs, NULL);
255         for (int i = 0 ; i < _iLhs ; i++)
256         {
257             (*pStr->m_pIn)[iCallerRhs + _iRhs + i] = out[i];
258             //pStr->m_pOutOrder[i] = i + 1;
259         }
260     }
261
262     FREE(pwstName);
263     return 0;
264 }
265
266 int callOverloadFunction(void* _pvCtx, int _iVar, char* _pstName, unsigned int _iNameLen)
267 {
268     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
269     types::Function::ReturnValue callResult;
270     types::typed_list tlReturnedValues;
271
272     wchar_t* pwstName = NULL;
273     if (_pstName == NULL || strlen(_pstName) == 0)
274     {
275         pwstName = to_wide_string(pStr->m_pstName);
276     }
277     else
278     {
279         pwstName = to_wide_string(_pstName);
280     }
281     std::wstring wsFunName;
282
283     if (_iVar == 0)
284     {
285         wsFunName = std::wstring(L"%_") + std::wstring(pwstName);
286     }
287     else
288     {
289         wsFunName = std::wstring(L"%") + (*pStr->m_pIn)[_iVar - 1]->getShortTypeStr() + L"_" + std::wstring(pwstName);
290     }
291
292     //protect input arguments
293     for (int i = 0 ; i < pStr->m_pIn->size() ; i++)
294     {
295         (*pStr->m_pIn)[i]->IncreaseRef();
296     }
297
298     callResult = Overload::call(wsFunName, *(pStr->m_pIn), *(pStr->m_piRetCount), tlReturnedValues);
299
300     //unprotect input arguments
301     for (int i = 0 ; i < pStr->m_pIn->size() ; i++)
302     {
303         (*pStr->m_pIn)[i]->DecreaseRef();
304     }
305
306     if (callResult == types::Function::OK)
307     {
308         int i = 0;
309         types::typed_list::iterator it;
310         for (it = tlReturnedValues.begin() ; it != tlReturnedValues.end() ; ++it, ++i)
311         {
312             (pStr->m_pOut)[i] = *it;
313             pStr->m_pOutOrder[i] = (int)pStr->m_pIn->size() + i + 1;
314         }
315     }
316
317     FREE(pwstName);
318     return 0;
319 }
320
321 /*--------------------------------------------------------------------------*/
322 SciErr getVarDimension(void *_pvCtx, int *_piAddress, int *_piRows, int *_piCols)
323 {
324     SciErr sciErr = sciErrInit();
325
326     if (_piAddress != NULL && isVarMatrixType(_pvCtx, _piAddress))
327     {
328         *_piRows = ((types::InternalType*)_piAddress)->getAs<types::GenericType>()->getRows();
329         *_piCols = ((types::InternalType*)_piAddress)->getAs<types::GenericType>()->getCols();
330     }
331     else
332     {
333         *_piRows = 0;
334         *_piCols = 0;
335         if (_piAddress == NULL)
336         {
337             addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarDimension");
338         }
339         else
340         {
341             addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument expected"), "getVarDimension");
342         }
343     }
344     return sciErr;
345 }
346
347 /*--------------------------------------------------------------------------*/
348 SciErr getNamedVarDimension(void *_pvCtx, const char *_pstName, int *_piRows, int *_piCols)
349 {
350     SciErr sciErr = sciErrInit();
351     int *piAddr = NULL;
352
353     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
354     if (sciErr.iErr)
355     {
356         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
357         return sciErr;
358     }
359
360     sciErr = getVarDimension(_pvCtx, piAddr, _piRows, _piCols);
361     if (sciErr.iErr)
362     {
363         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
364         return sciErr;
365     }
366
367     return sciErr;
368 }
369
370 /*--------------------------------------------------------------------------*/
371 SciErr getVarAddressFromPosition(void *_pvCtx, int _iVar, int **_piAddress)
372 {
373     SciErr sciErr = getinternalVarAddress(_pvCtx, _iVar, _piAddress);
374     return sciErr;
375 }
376
377 /*--------------------------------------------------------------------------*/
378 static SciErr getinternalVarAddress(void *_pvCtx, int _iVar, int **_piAddress)
379 {
380     SciErr sciErr = sciErrInit();
381     int iAddr = 0;
382     int iValType = 0;
383
384     if (_pvCtx == NULL)
385     {
386         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), "",
387                         "getVarAddressFromPosition");
388         return sciErr;
389     }
390
391     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
392     types::typed_list in = *pStr->m_pIn;
393     types::optional_list opt = *pStr->m_pOpt;
394     int* piRetCount = pStr->m_piRetCount;
395     int iInputSize = static_cast<int>(in.size()) + static_cast<int>(opt.size());
396
397     /* we accept a call to getVarAddressFromPosition after a create... call */
398     if (_iVar > *piRetCount + iInputSize)
399     {
400         //manage case where _iVar > in.size(), then look in out to get recent create variable.
401         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), pStr->m_pstName, "getVarAddressFromPosition");
402         return sciErr;
403     }
404
405     if (_iVar > iInputSize)
406     {
407         *_piAddress = (int*)pStr->m_pOut[_iVar - iInputSize - 1];
408     }
409     else if (_iVar > in.size())
410     {
411         *_piAddress = NULL; //never happend, I hope !
412     }
413     else
414     {
415         *_piAddress = (int*)in[_iVar - 1];
416     }
417     return sciErr;
418 }
419 /*--------------------------------------------------------------------------*/
420 SciErr getVarNameFromPosition(void *_pvCtx, int _iVar, char *_pstName)
421 {
422     SciErr sciErr = sciErrInit();
423
424     if (_pvCtx == NULL)
425     {
426         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), "",
427                         "getVarNameFromPosition");
428         return sciErr;
429     }
430
431     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
432     types::typed_list in = *pStr->m_pIn;
433
434     if (in[_iVar - 1]->isCallable())
435     {
436         std::wstring pwstring = in[_iVar - 1]->getAs<types::Callable>()->getName();
437         const wchar_t* pwcName = pwstring.c_str();
438         char* pstNameTempo = wide_string_to_UTF8(pwcName);
439         strcpy(_pstName, pstNameTempo);
440         FREE(pstNameTempo);
441     }
442
443     return sciErr;
444 }
445 /*--------------------------------------------------------------------------*/
446 int getNewVarAddressFromPosition(void *_pvCtx, int _iVar, int **_piAddress)
447 {
448     // FIXME
449     return 0;
450 }
451
452 /*--------------------------------------------------------------------------*/
453 SciErr getVarAddressFromName(void *_pvCtx, const char *_pstName, int **_piAddress)
454 {
455     SciErr sciErr = sciErrInit();
456
457     wchar_t* pwstName = to_wide_string(_pstName);
458     symbol::Context* pCtx = symbol::Context::getInstance();
459     types::InternalType* pVar = pCtx->get(symbol::Symbol(pwstName));
460     FREE(pwstName);
461
462     if (pVar == NULL)
463     {
464         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get address of variable \"%s\""), "getVarAddressFromName", _pstName);
465     }
466     else
467     {
468         *_piAddress = (int*)pVar;
469     }
470
471     return sciErr;
472 }
473
474 /*--------------------------------------------------------------------------*/
475 SciErr getVarType(void *_pvCtx, int *_piAddress, int *_piType)
476 {
477     SciErr sciErr = sciErrInit();
478
479     if (_piAddress == NULL)
480     {
481         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
482         return sciErr;
483     }
484
485     switch (((types::InternalType*)_piAddress)->getType())
486     {
487         case types::InternalType::ScilabDouble :
488             *_piType = sci_matrix;
489             break;
490         case types::InternalType::ScilabPolynom :
491             *_piType = sci_poly;
492             break;
493         case types::InternalType::ScilabBool :
494             *_piType = sci_boolean;
495             break;
496         case types::InternalType::ScilabSparse :
497             *_piType = sci_sparse;
498             break;
499         case types::InternalType::ScilabSparseBool :
500             *_piType = sci_boolean_sparse;
501             break;
502             //case types::InternalType::RealMatlabSparse :
503             //    *_piType = sci_matlab_sparse;
504             //    break;
505         case types::InternalType::ScilabInt8 :
506         case types::InternalType::ScilabUInt8 :
507         case types::InternalType::ScilabInt16 :
508         case types::InternalType::ScilabUInt16 :
509         case types::InternalType::ScilabInt32 :
510         case types::InternalType::ScilabUInt32 :
511         case types::InternalType::ScilabInt64 :
512         case types::InternalType::ScilabUInt64 :
513             *_piType = sci_ints;
514             break;
515         case types::InternalType::ScilabHandle :
516             *_piType = sci_handles;
517             break;
518         case types::InternalType::ScilabString :
519             *_piType = sci_strings;
520             break;
521         case types::InternalType::ScilabMacroFile :
522             *_piType = sci_u_function;
523             break;
524         case types::InternalType::ScilabMacro :
525             *_piType = sci_c_function;
526             break;
527         case types::InternalType::ScilabList :
528             *_piType = sci_list;
529             break;
530         case types::InternalType::ScilabCell :
531             *_piType = sci_mlist;
532             break;
533         case types::InternalType::ScilabTList :
534             *_piType = sci_tlist;
535             break;
536         case types::InternalType::ScilabMList :
537             *_piType = sci_mlist;
538             break;
539         case types::InternalType::ScilabStruct :
540             // Scilab < 6 compatibility... Struct have type 17;
541             *_piType = sci_mlist;
542             break;
543         case types::InternalType::ScilabUserType :
544             *_piType = sci_pointer;
545             break;
546         case types::InternalType::ScilabColon :
547         case types::InternalType::ScilabImplicitList :
548             *_piType = sci_implicit_poly;
549             break;
550         case types::InternalType::ScilabFunction:
551             *_piType = sci_intrinsic_function;
552             break;
553         case types::InternalType::ScilabLibrary:
554             *_piType = sci_lib;
555             break;
556         default:
557             *_piType = 0;
558     }
559
560     return sciErr;
561 }
562
563 /*--------------------------------------------------------------------------*/
564 // _pvCtx will not be used by getVarAddressFromName neither getVarType
565 // it can then be NULL.
566 SciErr getNamedVarType(void *_pvCtx, const char *_pstName, int *_piType)
567 {
568     int *piAddr = NULL;
569
570     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
571     if (sciErr.iErr)
572     {
573         addErrorMessage(&sciErr, API_ERROR_NAMED_UNDEFINED_VAR, _("%s: Unable to get variable \"%s\""), "getNamedVarType", _pstName);
574         return sciErr;
575     }
576
577     sciErr = getVarType(_pvCtx, piAddr, _piType);
578     if (sciErr.iErr)
579     {
580         addErrorMessage(&sciErr, API_ERROR_NAMED_TYPE, _("%s: Unable to get type of variable \"%s\""), "getNamedVarType", _pstName);
581         return sciErr;
582     }
583     return sciErr;
584 }
585
586 /*--------------------------------------------------------------------------*/
587 int isVarComplex(void *_pvCtx, int *_piAddress)
588 {
589     SciErr sciErr = sciErrInit();
590     int iType = 0;
591     int iComplex = 0;
592
593     if (_piAddress == NULL)
594     {
595         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isVarComplex");
596         return 0;
597     }
598
599     types::InternalType* pIT = (types::InternalType*)_piAddress;
600     types::GenericType* pGT = dynamic_cast<types::GenericType*>(pIT);
601     if (pGT == NULL)
602     {
603         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isVarComplex");
604         return 0;
605     }
606
607     return pGT->isComplex();
608 }
609
610 /*--------------------------------------------------------------------------*/
611 int isNamedVarComplex(void *_pvCtx, const char *_pstName)
612 {
613     int *piAddr = NULL;
614
615     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
616     if (sciErr.iErr)
617     {
618         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isNamedVarComplex");
619         return 0;
620     }
621     return isVarComplex(_pvCtx, piAddr);
622 }
623
624 /*--------------------------------------------------------------------------*/
625 void createNamedVariable(int *_piVarID)
626 {
627     //deprecated
628 }
629
630 /*--------------------------------------------------------------------------*/
631 int updateLstk(int _iNewpos, int _iSCIDataAddress, int _iVarSize)
632 {
633     //deprecated
634     return 0;
635 }
636
637 /*--------------------------------------------------------------------------*/
638 int isVarMatrixType(void *_pvCtx, int *_piAddress)
639 {
640     if (_piAddress != NULL)
641     {
642         int iType = 0;
643         getVarType(_pvCtx, _piAddress, &iType);
644
645         switch (iType)
646         {
647             case sci_matrix:
648             case sci_poly:
649             case sci_boolean:
650             case sci_sparse:
651             case sci_boolean_sparse:
652             case sci_matlab_sparse:
653             case sci_ints:
654             case sci_handles:
655             case sci_strings:
656                 return 1;
657             default:
658                 return 0;
659         }
660     }
661     else
662     {
663         return 0;
664     }
665     return 1;
666 }
667
668 /*--------------------------------------------------------------------------*/
669 int isNamedVarMatrixType(void *_pvCtx, const char *_pstName)
670 {
671     int *piAddr = NULL;
672
673     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
674     if (sciErr.iErr)
675     {
676         return 0;
677     }
678     return isVarMatrixType(_pvCtx, piAddr);
679 }
680
681 /*--------------------------------------------------------------------------*/
682 SciErr getProcessMode(void *_pvCtx, int _iPos, int *_piAddRef, int *_piMode)
683 {
684     int iRows1 = 0;
685     int iCols1 = 0;
686     int iRows2 = 0;
687     int iCols2 = 0;
688     int iType2 = 0;
689     int iMode = 0;
690     int *piAddr2 = NULL;
691
692     SciErr sciErr = getVarDimension(_pvCtx, _piAddRef, &iRows1, &iCols1);
693     if (sciErr.iErr)
694     {
695         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
696         return sciErr;
697     }
698
699     //sciprint("getProcessMode ->");
700     sciErr = getinternalVarAddress(_pvCtx, _iPos, &piAddr2);
701     if (sciErr.iErr)
702     {
703         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get variable address"), "getProcessMode");
704         return sciErr;
705     }
706
707     sciErr = getVarType(_pvCtx, piAddr2, &iType2);
708     if (sciErr.iErr)
709     {
710         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument type"), "getProcessMode");
711         return sciErr;
712     }
713
714     if (iType2 == sci_matrix && !isVarComplex(_pvCtx, piAddr2))
715     {
716         double *pdblReal2 = NULL;
717
718         sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblReal2);
719         if (sciErr.iErr)
720         {
721             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
722             return sciErr;
723         }
724
725         if (iRows2 != 1 || iCols2 != 1)
726         {
727             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument #%d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1,
728                             1);
729             return sciErr;
730         }
731
732         iMode = (int)pdblReal2[0];
733     }
734     else if (iType2 == sci_strings)
735     {
736         int iLen = 0;
737         char initialValue = '\0';
738         char *pstMode[1] = { &initialValue };
739
740         sciErr = getVarDimension(_pvCtx, piAddr2, &iRows2, &iCols2);
741         if (sciErr.iErr)
742         {
743             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
744             return sciErr;
745         }
746
747         if (iRows2 != 1 || iCols2 != 1)
748         {
749             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument #%d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1,
750                             1);
751             return sciErr;
752         }
753
754         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, NULL);
755         if (sciErr.iErr)
756         {
757             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
758             return sciErr;
759         }
760
761         pstMode[0] = (char *)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
762         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, pstMode);
763         if (sciErr.iErr)
764         {
765             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
766             return sciErr;
767         }
768
769         iMode = (int)pstMode[0][0];
770         FREE(pstMode[0]);
771     }
772     else
773     {
774         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong type for input argument #%d: string or scalar expected.\n"),
775                         "getProcessMode", _iPos);
776         return sciErr;
777     }
778
779     if (iMode == ROW_LETTER || iMode == BY_ROWS)
780     {
781         *_piMode = BY_ROWS;
782     }
783     else if (iMode == COL_LETTER || iMode == BY_COLS)
784     {
785         *_piMode = BY_COLS;
786     }
787     else if (iMode == STAR_LETTER || iMode == BY_ALL)
788     {
789         *_piMode = BY_ALL;
790     }
791     else if (iMode == MTLB_LETTER || iMode == BY_MTLB)
792     {
793         *_piMode = 0;
794         if (iRows1 > 1)
795         {
796             *_piMode = 1;
797         }
798         else if (iCols1 > 1)
799         {
800             *_piMode = 2;
801         }
802     }
803     else
804     {
805         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), "getProcessMode",
806                         _iPos, "'*', 'r', 'c', 'm', '0', '1', '2'", "-1");
807         return sciErr;
808     }
809     return sciErr;
810 }
811
812 /*--------------------------------------------------------------------------*/
813 SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
814 {
815     int iType = 0;
816     int iRows = 0;
817     int iCols = 0;
818     double *pdblReal = NULL;
819
820     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
821     if (sciErr.iErr)
822     {
823         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
824         return sciErr;
825     }
826
827     if (iType == sci_matrix)
828     {
829         if (isVarComplex(_pvCtx, _piAddress))
830         {
831             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "getDimFromVar",
832                             getRhsFromAddress(_pvCtx, _piAddress));
833             return sciErr;
834         }
835
836         sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
837         if (sciErr.iErr)
838         {
839             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
840             return sciErr;
841         }
842
843         *_piVal = (int)std::max(pdblReal[0], double(0));
844     }
845     else if (iType == sci_ints)
846     {
847         int iPrec = 0;
848
849         sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
850         if (sciErr.iErr)
851         {
852             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
853             return sciErr;
854         }
855
856         if (iRows != 1 || iCols != 1)
857         {
858             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument #%d: (%d,%d) expected.\n"), "getProcessMode",
859                             getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
860             return sciErr;
861         }
862
863         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
864         if (sciErr.iErr)
865         {
866             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
867             return sciErr;
868         }
869
870         switch (iPrec)
871         {
872             case SCI_INT8:
873             {
874                 char *pcData = NULL;
875
876                 sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
877                 if (sciErr.iErr)
878                 {
879                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
880                     return sciErr;
881                 }
882                 *_piVal = pcData[0];
883             }
884             break;
885             case SCI_UINT8:
886             {
887                 unsigned char *pucData = NULL;
888
889                 sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
890                 if (sciErr.iErr)
891                 {
892                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
893                     return sciErr;
894                 }
895                 *_piVal = pucData[0];
896             }
897             break;
898             case SCI_INT16:
899             {
900                 short *psData = NULL;
901
902                 sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
903                 if (sciErr.iErr)
904                 {
905                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
906                     return sciErr;
907                 }
908                 *_piVal = psData[0];
909             }
910             break;
911             case SCI_UINT16:
912             {
913                 unsigned short *pusData = NULL;
914
915                 sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
916                 if (sciErr.iErr)
917                 {
918                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
919                     return sciErr;
920                 }
921                 *_piVal = pusData[0];
922             }
923             break;
924             case SCI_INT32:
925             {
926                 int *piData = NULL;
927
928                 sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
929                 if (sciErr.iErr)
930                 {
931                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
932                     return sciErr;
933                 }
934                 *_piVal = piData[0];
935             }
936             break;
937             case SCI_UINT32:
938             {
939                 unsigned int *puiData = NULL;
940
941                 sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
942                 if (sciErr.iErr)
943                 {
944                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
945                     return sciErr;
946                 }
947                 *_piVal = puiData[0];
948             }
949             break;
950 #ifdef __SCILAB_INT64__
951             case SCI_INT64:
952             {
953                 long long *pllData = NULL;
954
955                 sciErr = getMatrixOfInteger64(_pvCtx, _piAddress, &iRows, &iCols, &pllData);
956                 if (sciErr.iErr)
957                 {
958                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
959                     return sciErr;
960                 }
961                 *_piVal = (int)pllData[0];
962             }
963             break;
964             case SCI_UINT64:
965             {
966                 unsigned long long *pullData = NULL;
967
968                 sciErr = getMatrixOfUnsignedInteger64(_pvCtx, _piAddress, &iRows, &iCols, &pullData);
969                 if (sciErr.iErr)
970                 {
971                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
972                     return sciErr;
973                 }
974                 *_piVal = (int)pullData[0];
975             }
976             break;
977 #endif
978         }
979     }
980     else
981     {
982         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or an integer scalar expected.\n"),
983                         "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
984         return sciErr;
985     }
986     return sciErr;
987 }
988
989 /*--------------------------------------------------------------------------*/
990 SciErr getDimFromNamedVar(void *_pvCtx, const char *_pstName, int *_piVal)
991 {
992     int *piAddr = NULL;
993
994     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
995     if (sciErr.iErr)
996     {
997         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
998                         _pstName);
999         return sciErr;
1000     }
1001
1002     sciErr = getDimFromVar(_pvCtx, piAddr, _piVal);
1003     if (sciErr.iErr)
1004     {
1005         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
1006                         _pstName);
1007         return sciErr;
1008     }
1009
1010     return sciErr;
1011 }
1012
1013 /*--------------------------------------------------------------------------*/
1014 int getRhsFromAddress(void *_pvCtx, int *_piAddress)
1015 {
1016     int i = 0;
1017     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
1018     types::typed_list in = *pStr->m_pIn;
1019
1020     for (i = 0 ; i < in.size() ; i++)
1021     {
1022         if (_piAddress == (int*)in[i])
1023         {
1024             return i + 1;
1025         }
1026     }
1027     return -1;
1028 }
1029
1030 /*short cut functions*/
1031
1032 /*--------------------------------------------------------------------------*/
1033 int isRowVector(void *_pvCtx, int *_piAddress)
1034 {
1035     int iRows = 0;
1036     int iCols = 0;
1037
1038     if (_piAddress == NULL)
1039     {
1040         return 0;
1041     }
1042
1043     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1044     {
1045         return 0;
1046     }
1047
1048     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1049     if (sciErr.iErr)
1050     {
1051         addErrorMessage(&sciErr, API_ERROR_IS_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isRowVector");
1052         printError(&sciErr, 0);
1053         return sciErr.iErr;
1054     }
1055
1056     if (iRows == 1 && iCols > 1)
1057     {
1058         return 1;
1059     }
1060
1061     return 0;
1062 }
1063
1064 /*--------------------------------------------------------------------------*/
1065 int isNamedRowVector(void *_pvCtx, const char *_pstName)
1066 {
1067     int iRows = 0;
1068     int iCols = 0;
1069
1070     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1071     {
1072         return 0;
1073     }
1074
1075     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1076     if (sciErr.iErr)
1077     {
1078         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isNamedRowVector");
1079         printError(&sciErr, 0);
1080         return sciErr.iErr;
1081     }
1082
1083     if (iRows == 1 && iCols > 1)
1084     {
1085         return 1;
1086     }
1087
1088     return 0;
1089 }
1090
1091 /*--------------------------------------------------------------------------*/
1092 int isColumnVector(void *_pvCtx, int *_piAddress)
1093 {
1094     int iRows = 0;
1095     int iCols = 0;
1096
1097     if (_piAddress == NULL)
1098     {
1099         return 0;
1100     }
1101
1102     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1103     {
1104         return 0;
1105     }
1106
1107     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1108     if (sciErr.iErr)
1109     {
1110         addErrorMessage(&sciErr, API_ERROR_IS_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isColumnVector");
1111         printError(&sciErr, 0);
1112         return 0;
1113     }
1114
1115     if (iCols == 1 && iRows > 1)
1116     {
1117         return 1;
1118     }
1119
1120     return 0;
1121 }
1122
1123 /*--------------------------------------------------------------------------*/
1124 int isNamedColumnVector(void *_pvCtx, const char *_pstName)
1125 {
1126     int iRows = 0;
1127     int iCols = 0;
1128
1129     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1130     {
1131         return 0;
1132     }
1133
1134     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1135     if (sciErr.iErr)
1136     {
1137         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isNamedColumnVector");
1138         printError(&sciErr, 0);
1139         return 0;
1140     }
1141
1142     if (iCols == 1 && iRows > 1)
1143     {
1144         return 1;
1145     }
1146
1147     return 0;
1148 }
1149
1150 /*--------------------------------------------------------------------------*/
1151 int isVector(void *_pvCtx, int *_piAddress)
1152 {
1153     return isRowVector(_pvCtx, _piAddress) || isColumnVector(_pvCtx, _piAddress);
1154 }
1155
1156 /*--------------------------------------------------------------------------*/
1157 int isNamedVector(void *_pvCtx, const char *_pstName)
1158 {
1159     return isNamedRowVector(_pvCtx, _pstName) || isNamedColumnVector(_pvCtx, _pstName);
1160 }
1161
1162 /*--------------------------------------------------------------------------*/
1163 int isStruct(void *_pvCtx, int *_piAddress)
1164 {
1165     if (((types::InternalType*)_piAddress)->getType() == types::InternalType::ScilabStruct)
1166     {
1167         return 1;
1168     }
1169     return 0;
1170 }
1171 /*--------------------------------------------------------------------------*/
1172 int isCell(void *_pvCtx, int *_piAddress)
1173 {
1174     if (((types::InternalType*)_piAddress)->getType() == types::InternalType::ScilabCell)
1175     {
1176         return 1;
1177     }
1178     return 0;
1179 }
1180 /*--------------------------------------------------------------------------*/
1181 int isScalar(void *_pvCtx, int *_piAddress)
1182 {
1183     int iRows = 0;
1184     int iCols = 0;
1185
1186     if (_piAddress == NULL)
1187     {
1188         return 0;
1189     }
1190
1191     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1192     {
1193         return 0;
1194     }
1195
1196     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1197     if (sciErr.iErr)
1198     {
1199         addErrorMessage(&sciErr, API_ERROR_IS_SCALAR, _("%s: Unable to get argument dimension"), "isScalar");
1200         printError(&sciErr, 0);
1201         return 0;
1202     }
1203
1204     if (iCols == 1 && iRows == 1)
1205     {
1206         return 1;
1207     }
1208
1209     return 0;
1210 }
1211
1212 /*--------------------------------------------------------------------------*/
1213 int isNamedScalar(void *_pvCtx, const char *_pstName)
1214 {
1215     int iRows = 0;
1216     int iCols = 0;
1217
1218     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1219     {
1220         return 0;
1221     }
1222
1223     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1224     if (sciErr.iErr)
1225     {
1226         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SCALAR, _("%s: Unable to get argument dimension"), "isNamedScalar");
1227         printError(&sciErr, 0);
1228         return 0;
1229     }
1230
1231     if (iCols == 1 && iRows == 1)
1232     {
1233         return 1;
1234     }
1235
1236     return 0;
1237 }
1238
1239 /*--------------------------------------------------------------------------*/
1240 int isSquareMatrix(void *_pvCtx, int *_piAddress)
1241 {
1242     int iRows = 0;
1243     int iCols = 0;
1244
1245     if (_piAddress == NULL)
1246     {
1247         return 0;
1248     }
1249
1250     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1251     {
1252         return 0;
1253     }
1254
1255     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1256     if (sciErr.iErr)
1257     {
1258         addErrorMessage(&sciErr, API_ERROR_IS_SQUARE, _("%s: Unable to get argument dimension"), "isSquareMatrix");
1259         printError(&sciErr, 0);
1260         return 0;
1261     }
1262
1263     if (iRows > 1 && iCols == iRows)
1264     {
1265         return 1;
1266     }
1267
1268     return 0;
1269 }
1270
1271 /*--------------------------------------------------------------------------*/
1272 int isNamedSquareMatrix(void *_pvCtx, const char *_pstName)
1273 {
1274     int iRows = 0;
1275     int iCols = 0;
1276
1277     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1278     {
1279         return 0;
1280     }
1281
1282     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1283     if (sciErr.iErr)
1284     {
1285         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SQUARE, _("%s: Unable to get argument dimension"), "isNamedSquareMatrix");
1286         printError(&sciErr, 0);
1287         return 0;
1288     }
1289
1290     if (iRows > 1 && iCols == iRows)
1291     {
1292         return 1;
1293     }
1294
1295     return 0;
1296 }
1297
1298 /*--------------------------------------------------------------------------*/
1299 int checkVarDimension(void *_pvCtx, int *_piAddress, int _iRows, int _iCols)
1300 {
1301     int iRows = 0;
1302     int iCols = 0;
1303
1304     if (_piAddress == NULL)
1305     {
1306         return 0;
1307     }
1308
1309     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1310     {
1311         return 0;
1312     }
1313
1314     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1315     if (sciErr.iErr)
1316     {
1317         addErrorMessage(&sciErr, API_ERROR_CHECK_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkVarDimension");
1318         printError(&sciErr, 0);
1319         return 0;
1320     }
1321
1322     if ((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
1323     {
1324         return 1;
1325     }
1326
1327     return 0;
1328 }
1329
1330 /*--------------------------------------------------------------------------*/
1331 int checkNamedVarDimension(void *_pvCtx, const char *_pstName, int _iRows, int _iCols)
1332 {
1333     int iRows = 0;
1334     int iCols = 0;
1335
1336     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1337     {
1338         return 0;
1339     }
1340
1341     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1342     if (sciErr.iErr)
1343     {
1344         addErrorMessage(&sciErr, API_ERROR_CHECK_NAMED_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkNamedVarDimension");
1345         printError(&sciErr, 0);
1346         return 0;
1347     }
1348
1349     if ((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
1350     {
1351         return 1;
1352     }
1353
1354     return 0;
1355 }
1356
1357 /*--------------------------------------------------------------------------*/
1358 int checkVarType(void *_pvCtx, int *_piAddress, int _iType)
1359 {
1360     int iType = 0;
1361
1362     if (_piAddress == NULL)
1363     {
1364         return 0;
1365     }
1366
1367     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
1368     if (sciErr.iErr)
1369     {
1370         return 0;
1371     }
1372
1373     if (iType == _iType)
1374     {
1375         return 1;
1376     }
1377
1378     return 0;
1379 }
1380
1381 /*--------------------------------------------------------------------------*/
1382 int checkNamedVarType(void *_pvCtx, const char *_pstName, int _iType)
1383 {
1384     int iType = 0;
1385
1386     SciErr sciErr = getNamedVarType(_pvCtx, _pstName, &iType);
1387     if (sciErr.iErr)
1388     {
1389         return 0;
1390     }
1391
1392     if (iType == _iType)
1393     {
1394         return 1;
1395     }
1396
1397     return 0;
1398 }
1399
1400 /*--------------------------------------------------------------------------*/
1401 int getInputArgumentType(void* _pvCtx, int _iVar)
1402 {
1403     int* piAddr = NULL;
1404     int iType = 0;
1405
1406     SciErr sciErr = getinternalVarAddress(_pvCtx, _iVar, &piAddr);
1407     if (sciErr.iErr)
1408     {
1409         return 0;
1410     }
1411
1412     sciErr = getVarType(_pvCtx, piAddr, &iType);
1413     if (sciErr.iErr)
1414     {
1415         return 0;
1416     }
1417
1418     return iType;
1419 }
1420
1421 /*--------------------------------------------------------------------------*/
1422 int checkInputArgumentType(void* _pvCtx, int _iVar, int _iType)
1423 {
1424     return getInputArgumentType(_pvCtx, _iVar) == _iType;
1425 }
1426
1427 /*--------------------------------------------------------------------------*/
1428 int isEmptyMatrix(void *_pvCtx, int *_piAddress)
1429 {
1430     if (checkVarType(_pvCtx, _piAddress, sci_matrix))
1431     {
1432         return checkVarDimension(_pvCtx, _piAddress, 0, 0);
1433     }
1434     return 0;
1435 }
1436
1437 /*--------------------------------------------------------------------------*/
1438 int isNamedEmptyMatrix(void *_pvCtx, const char *_pstName)
1439 {
1440     if (checkNamedVarType(_pvCtx, _pstName, sci_matrix))
1441     {
1442         return checkNamedVarDimension(_pvCtx, _pstName, 0, 0);
1443     }
1444     return 0;
1445 }
1446
1447 /*--------------------------------------------------------------------------*/
1448 int createEmptyMatrix(void *_pvCtx, int _iVar)
1449 {
1450     double dblReal = 0;
1451
1452     SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
1453     if (sciErr.iErr)
1454     {
1455         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1456         printError(&sciErr, 0);
1457         return sciErr.iErr;
1458     }
1459
1460     return 0;
1461 }
1462
1463 /*--------------------------------------------------------------------------*/
1464 int createNamedEmptyMatrix(void *_pvCtx, const char *_pstName)
1465 {
1466     double dblOne = 0;
1467
1468     SciErr sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblOne);
1469     if (sciErr.iErr)
1470     {
1471         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
1472         printError(&sciErr, 0);
1473         return sciErr.iErr;
1474     }
1475
1476     return 0;
1477 }
1478
1479 /*--------------------------------------------------------------------------*/
1480 int isNamedVarExist(void *_pvCtx, const char *_pstName)
1481 {
1482     SciErr sciErr = sciErrInit();
1483     int *piAddr = NULL;
1484
1485     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
1486     if (sciErr.iErr || piAddr == NULL)
1487     {
1488         sciErrClean(&sciErr);
1489         return 0;
1490     }
1491
1492     return 1;
1493 }
1494
1495 /*--------------------------------------------------------------------------*/
1496 int checkNamedVarFormat(void* _pvCtx, const char *_pstName)
1497 {
1498     // check pointer
1499     if (_pstName == NULL)
1500     {
1501         return 0;
1502     }
1503
1504     // check length _pstName <> 0
1505     if (symbol::Context::getInstance()->isValidVariableName(_pstName) == false)
1506     {
1507         return 0;
1508     }
1509
1510     return 1;
1511 }
1512 /*--------------------------------------------------------------------------*/
1513 int deleteNamedVariable(void* _pvCtx, const char* _pstName)
1514 {
1515     SciErr sciErr = sciErrInit();
1516
1517     if (isNamedVarExist(_pvCtx, _pstName) == 0)
1518     {
1519         return 0;
1520     }
1521
1522     if (!checkNamedVarFormat(_pvCtx, _pstName))
1523     {
1524         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedComplexZMatrixOfDouble", _pstName);
1525         return 0;
1526     }
1527
1528     wchar_t* pwstName = to_wide_string(_pstName);
1529     symbol::Context* ctx = symbol::Context::getInstance();
1530     symbol::Symbol sym = symbol::Symbol(pwstName);
1531     FREE(pwstName);
1532     bool ret = false;
1533     if (ctx->isprotected(sym) == false)
1534     {
1535         ret = ctx->remove(sym);
1536     }
1537     else
1538     {
1539         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
1540     }
1541
1542     return ret ? 1 : 0;
1543 }
1544 /*--------------------------------------------------------------------------*/
1545 int increaseValRef(void* _pvCtx, int* _piAddress)
1546 {
1547     if (_piAddress)
1548     {
1549         types::InternalType* pIT = (types::InternalType*)_piAddress;
1550         types::InternalType* pIT2 = dynamic_cast<types::InternalType*>(pIT);
1551         if (pIT2)
1552         {
1553             pIT->IncreaseRef();
1554             return 1;
1555         }
1556         else
1557         {
1558             Scierror(999, _("Invalid type pointer in '%s'\n"), "increaseValRef");
1559             return -1;
1560         }
1561     }
1562     return 0;
1563 }
1564 /*--------------------------------------------------------------------------*/
1565 int decreaseValRef(void* _pvCtx, int* _piAddress)
1566 {
1567     if (_piAddress)
1568     {
1569         types::InternalType* pIT = (types::InternalType*)_piAddress;
1570         types::InternalType* pIT2 = dynamic_cast<types::InternalType*>(pIT);
1571         if (pIT2)
1572         {
1573             pIT->DecreaseRef();
1574             if (pIT->isDeletable())
1575             {
1576                 delete pIT;
1577             }
1578             return 1;
1579         }
1580         else
1581         {
1582             Scierror(999, _("Invalid type pointer in '%s'\n"), "decreaseValRef");
1583             return -1;
1584         }
1585     }
1586     return 0;
1587 }
1588 /*--------------------------------------------------------------------------*/
1589 static char eostr = '\0';
1590 SciErr sciErrInit()
1591 {
1592     int i = 0 ;
1593     SciErr sciErr;
1594     sciErr.iErr = 0;
1595     sciErr.iMsgCount = 0;
1596
1597     for (; i < MESSAGE_STACK_SIZE ; i++)
1598     {
1599         sciErr.pstMsg[i] = &eostr;
1600     }
1601
1602     return sciErr;
1603 }
1604
1605 void sciErrClean(SciErr* _psciErr)
1606 {
1607     //reset error
1608     for (int i = _psciErr->iMsgCount - 1; i >= 0; i--)
1609     {
1610         FREE(_psciErr->pstMsg[i]);
1611     }
1612
1613     _psciErr->iMsgCount = 0;
1614 }