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