getVarNameFromPosition: he can read the name of the Callable
[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
438     if (_pvCtx == NULL)
439     {
440         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), "",
441                         "getVarNameFromPosition");
442         return sciErr;
443     }
444
445     GatewayStruct* pStr = (GatewayStruct*)_pvCtx;
446     typed_list in = *pStr->m_pIn;
447
448     if (in[_iVar - 1]->isCallable())
449     {
450         std::wstring pwstring = in[_iVar - 1]->getAs<types::Callable>()->getName();
451         const wchar_t* pwcName = pwstring.c_str();
452         char* pstNameTempo = wide_string_to_UTF8(pwcName);
453         strcpy(_pstName, pstNameTempo);
454         FREE(pstNameTempo);
455     }
456
457     return sciErr;
458 }
459 /*--------------------------------------------------------------------------*/
460 int getNewVarAddressFromPosition(void *_pvCtx, int _iVar, int **_piAddress)
461 {
462     // FIXME
463     return 0;
464 }
465
466 /*--------------------------------------------------------------------------*/
467 SciErr getVarAddressFromName(void *_pvCtx, const char *_pstName, int **_piAddress)
468 {
469     SciErr sciErr = sciErrInit();
470
471     wchar_t* pwstName = to_wide_string(_pstName);
472     symbol::Context* pCtx = symbol::Context::getInstance();
473     InternalType* pVar = pCtx->get(symbol::Symbol(pwstName));
474     FREE(pwstName);
475
476     if (pVar == NULL)
477     {
478         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get address of variable \"%s\""), "getVarAddressFromName", _pstName);
479     }
480     else
481     {
482         *_piAddress = (int*)pVar;
483     }
484
485     return sciErr;
486 }
487
488 /*--------------------------------------------------------------------------*/
489 SciErr getVarType(void *_pvCtx, int *_piAddress, int *_piType)
490 {
491     SciErr sciErr = sciErrInit();
492
493     if (_piAddress == NULL)
494     {
495         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
496         return sciErr;
497     }
498
499     switch (((InternalType*)_piAddress)->getType())
500     {
501         case GenericType::ScilabDouble :
502             *_piType = sci_matrix;
503             break;
504         case GenericType::ScilabDollar :
505         case GenericType::ScilabPolynom :
506             *_piType = sci_poly;
507             break;
508         case GenericType::ScilabBool :
509             *_piType = sci_boolean;
510             break;
511         case GenericType::ScilabSparse :
512             *_piType = sci_sparse;
513             break;
514         case GenericType::ScilabSparseBool :
515             *_piType = sci_boolean_sparse;
516             break;
517         //case GenericType::RealMatlabSparse :
518         //    *_piType = sci_matlab_sparse;
519         //    break;
520         case GenericType::ScilabInt8 :
521         case GenericType::ScilabUInt8 :
522         case GenericType::ScilabInt16 :
523         case GenericType::ScilabUInt16 :
524         case GenericType::ScilabInt32 :
525         case GenericType::ScilabUInt32 :
526         case GenericType::ScilabInt64 :
527         case GenericType::ScilabUInt64 :
528             *_piType = sci_ints;
529             break;
530         case GenericType::ScilabHandle :
531             *_piType = sci_handles;
532             break;
533         case GenericType::ScilabString :
534             *_piType = sci_strings;
535             break;
536         case GenericType::ScilabMacroFile :
537             *_piType = sci_u_function;
538             break;
539         case GenericType::ScilabMacro :
540             *_piType = sci_c_function;
541             break;
542         case GenericType::ScilabList :
543             *_piType = sci_list;
544             break;
545         case GenericType::ScilabCell :
546             *_piType = sci_mlist;
547             break;
548         case GenericType::ScilabTList :
549             *_piType = sci_tlist;
550             break;
551         case GenericType::ScilabMList :
552             *_piType = sci_mlist;
553             break;
554         case GenericType::ScilabStruct :
555             // Scilab < 6 compatibility... Struct have type 17;
556             *_piType = sci_mlist;
557             break;
558         case GenericType::ScilabUserType :
559             *_piType = sci_pointer;
560             break;
561         case GenericType::ScilabColon :
562         case GenericType::ScilabImplicitList :
563             *_piType = sci_implicit_poly;
564             break;
565         case GenericType::ScilabFunction:
566             *_piType = sci_intrinsic_function;
567             break;
568         case GenericType::ScilabLibrary:
569             *_piType = sci_lib;
570             break;
571         default:
572             *_piType = 0;
573     }
574
575     return sciErr;
576 }
577
578 /*--------------------------------------------------------------------------*/
579 // _pvCtx will not be used by getVarAddressFromName neither getVarType
580 // it can then be NULL.
581 SciErr getNamedVarType(void *_pvCtx, const char *_pstName, int *_piType)
582 {
583     int *piAddr = NULL;
584
585     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
586     if (sciErr.iErr)
587     {
588         addErrorMessage(&sciErr, API_ERROR_NAMED_UNDEFINED_VAR, _("%s: Unable to get variable \"%s\""), "getNamedVarType", _pstName);
589         return sciErr;
590     }
591
592     sciErr = getVarType(_pvCtx, piAddr, _piType);
593     if (sciErr.iErr)
594     {
595         addErrorMessage(&sciErr, API_ERROR_NAMED_TYPE, _("%s: Unable to get type of variable \"%s\""), "getNamedVarType", _pstName);
596         return sciErr;
597     }
598     return sciErr;
599 }
600
601 /*--------------------------------------------------------------------------*/
602 int isVarComplex(void *_pvCtx, int *_piAddress)
603 {
604     SciErr sciErr;
605     int iType = 0;
606     int iComplex = 0;
607
608     if (_piAddress == NULL)
609     {
610         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isVarComplex");
611         return 0;
612     }
613
614     InternalType* pIT = (InternalType*)_piAddress;
615     GenericType* pGT = dynamic_cast<GenericType*>(pIT);
616     if (pGT == NULL)
617     {
618         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isVarComplex");
619         return 0;
620     }
621
622     return pGT->isComplex();
623 }
624
625 /*--------------------------------------------------------------------------*/
626 int isNamedVarComplex(void *_pvCtx, const char *_pstName)
627 {
628     int *piAddr = NULL;
629
630     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
631     if (sciErr.iErr)
632     {
633         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "isNamedVarComplex");
634         return 0;
635     }
636     return isVarComplex(_pvCtx, piAddr);
637 }
638
639 /*--------------------------------------------------------------------------*/
640 void createNamedVariable(int *_piVarID)
641 {
642     //deprecated
643 }
644
645 /*--------------------------------------------------------------------------*/
646 int updateInterSCI(int _iVar, char _cType, int _iSCIAddress, int _iSCIDataAddress)
647 {
648     //deprecated
649     return 0;
650 }
651
652 /*--------------------------------------------------------------------------*/
653 int updateLstk(int _iNewpos, int _iSCIDataAddress, int _iVarSize)
654 {
655     //deprecated
656     return 0;
657 }
658
659 /*--------------------------------------------------------------------------*/
660 int isVarMatrixType(void *_pvCtx, int *_piAddress)
661 {
662     if (_piAddress != NULL)
663     {
664         int iType = 0;
665         getVarType(_pvCtx, _piAddress, &iType);
666
667         switch (iType)
668         {
669             case sci_matrix:
670             case sci_poly:
671             case sci_boolean:
672             case sci_sparse:
673             case sci_boolean_sparse:
674             case sci_matlab_sparse:
675             case sci_ints:
676             case sci_handles:
677             case sci_strings:
678                 return 1;
679             default:
680                 return 0;
681         }
682     }
683     else
684     {
685         return 0;
686     }
687     return 1;
688 }
689
690 /*--------------------------------------------------------------------------*/
691 int isNamedVarMatrixType(void *_pvCtx, const char *_pstName)
692 {
693     int *piAddr = NULL;
694
695     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
696     if (sciErr.iErr)
697     {
698         return 0;
699     }
700     return isVarMatrixType(_pvCtx, piAddr);
701 }
702
703 /*--------------------------------------------------------------------------*/
704 SciErr getProcessMode(void *_pvCtx, int _iPos, int *_piAddRef, int *_piMode)
705 {
706     int iRows1 = 0;
707     int iCols1 = 0;
708     int iRows2 = 0;
709     int iCols2 = 0;
710     int iType2 = 0;
711     int iMode = 0;
712     int *piAddr2 = NULL;
713
714     SciErr sciErr = getVarDimension(_pvCtx, _piAddRef, &iRows1, &iCols1);
715     if (sciErr.iErr)
716     {
717         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
718         return sciErr;
719     }
720
721     //sciprint("getProcessMode ->");
722     sciErr = getinternalVarAddress(_pvCtx, _iPos, &piAddr2);
723     if (sciErr.iErr)
724     {
725         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get variable address"), "getProcessMode");
726         return sciErr;
727     }
728
729     sciErr = getVarType(_pvCtx, piAddr2, &iType2);
730     if (sciErr.iErr)
731     {
732         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument type"), "getProcessMode");
733         return sciErr;
734     }
735
736     if (iType2 == sci_matrix && !isVarComplex(_pvCtx, piAddr2))
737     {
738         double *pdblReal2 = NULL;
739
740         sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblReal2);
741         if (sciErr.iErr)
742         {
743             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "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         iMode = (int)pdblReal2[0];
755     }
756     else if (iType2 == sci_strings)
757     {
758         int iLen = 0;
759         char initialValue = '\0';
760         char *pstMode[1] = { &initialValue };
761
762         sciErr = getVarDimension(_pvCtx, piAddr2, &iRows2, &iCols2);
763         if (sciErr.iErr)
764         {
765             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
766             return sciErr;
767         }
768
769         if (iRows2 != 1 || iCols2 != 1)
770         {
771             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument #%d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1,
772                             1);
773             return sciErr;
774         }
775
776         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, NULL);
777         if (sciErr.iErr)
778         {
779             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
780             return sciErr;
781         }
782
783         pstMode[0] = (char *)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
784         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, pstMode);
785         if (sciErr.iErr)
786         {
787             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
788             return sciErr;
789         }
790
791         iMode = (int)pstMode[0][0];
792         FREE(pstMode[0]);
793     }
794     else
795     {
796         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong type for input argument #%d: A string or a scalar expected.\n"),
797                         "getProcessMode", _iPos);
798         return sciErr;
799     }
800
801     if (iMode == ROW_LETTER || iMode == BY_ROWS)
802     {
803         *_piMode = BY_ROWS;
804     }
805     else if (iMode == COL_LETTER || iMode == BY_COLS)
806     {
807         *_piMode = BY_COLS;
808     }
809     else if (iMode == STAR_LETTER || iMode == BY_ALL)
810     {
811         *_piMode = BY_ALL;
812     }
813     else if (iMode == MTLB_LETTER || iMode == BY_MTLB)
814     {
815         *_piMode = 0;
816         if (iRows1 > 1)
817         {
818             *_piMode = 1;
819         }
820         else if (iCols1 > 1)
821         {
822             *_piMode = 2;
823         }
824     }
825     else
826     {
827         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), "getProcessMode",
828                         _iPos, "'*', 'r', 'c', 'm', '0', '1', '2'", "-1");
829         return sciErr;
830     }
831     return sciErr;
832 }
833
834 /*--------------------------------------------------------------------------*/
835 SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
836 {
837     int iType = 0;
838     int iRows = 0;
839     int iCols = 0;
840     double *pdblReal = NULL;
841
842     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
843     if (sciErr.iErr)
844     {
845         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
846         return sciErr;
847     }
848
849     if (iType == sci_matrix)
850     {
851         if (isVarComplex(_pvCtx, _piAddress))
852         {
853             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "getDimFromVar",
854                             getRhsFromAddress(_pvCtx, _piAddress));
855             return sciErr;
856         }
857
858         sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
859         if (sciErr.iErr)
860         {
861             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
862             return sciErr;
863         }
864
865         *_piVal = (int)std::max(pdblReal[0], double(0));
866     }
867     else if (iType == sci_ints)
868     {
869         int iPrec = 0;
870
871         sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
872         if (sciErr.iErr)
873         {
874             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
875             return sciErr;
876         }
877
878         if (iRows != 1 || iCols != 1)
879         {
880             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument #%d: (%d,%d) expected.\n"), "getProcessMode",
881                             getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
882             return sciErr;
883         }
884
885         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
886         if (sciErr.iErr)
887         {
888             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
889             return sciErr;
890         }
891
892         switch (iPrec)
893         {
894             case SCI_INT8:
895             {
896                 char *pcData = NULL;
897
898                 sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
899                 if (sciErr.iErr)
900                 {
901                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
902                     return sciErr;
903                 }
904                 *_piVal = pcData[0];
905             }
906             break;
907             case SCI_UINT8:
908             {
909                 unsigned char *pucData = NULL;
910
911                 sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
912                 if (sciErr.iErr)
913                 {
914                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
915                     return sciErr;
916                 }
917                 *_piVal = pucData[0];
918             }
919             break;
920             case SCI_INT16:
921             {
922                 short *psData = NULL;
923
924                 sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
925                 if (sciErr.iErr)
926                 {
927                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
928                     return sciErr;
929                 }
930                 *_piVal = psData[0];
931             }
932             break;
933             case SCI_UINT16:
934             {
935                 unsigned short *pusData = NULL;
936
937                 sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
938                 if (sciErr.iErr)
939                 {
940                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
941                     return sciErr;
942                 }
943                 *_piVal = pusData[0];
944             }
945             break;
946             case SCI_INT32:
947             {
948                 int *piData = NULL;
949
950                 sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
951                 if (sciErr.iErr)
952                 {
953                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
954                     return sciErr;
955                 }
956                 *_piVal = piData[0];
957             }
958             break;
959             case SCI_UINT32:
960             {
961                 unsigned int *puiData = NULL;
962
963                 sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
964                 if (sciErr.iErr)
965                 {
966                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
967                     return sciErr;
968                 }
969                 *_piVal = puiData[0];
970             }
971             break;
972 #ifdef __SCILAB_INT64__
973             case SCI_INT64:
974             {
975                 long long *pllData = NULL;
976
977                 sciErr = getMatrixOfInteger64(_pvCtx, _piAddress, &iRows, &iCols, &pllData);
978                 if (sciErr.iErr)
979                 {
980                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
981                     return sciErr;
982                 }
983                 *_piVal = (int)pllData[0];
984             }
985             break;
986             case SCI_UINT64:
987             {
988                 unsigned long long *pullData = NULL;
989
990                 sciErr = getMatrixOfUnsignedInteger64(_pvCtx, _piAddress, &iRows, &iCols, &pullData);
991                 if (sciErr.iErr)
992                 {
993                     addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
994                     return sciErr;
995                 }
996                 *_piVal = (int)pullData[0];
997             }
998             break;
999 #endif
1000         }
1001     }
1002     else
1003     {
1004         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or an integer scalar expected.\n"),
1005                         "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
1006         return sciErr;
1007     }
1008     return sciErr;
1009 }
1010
1011 /*--------------------------------------------------------------------------*/
1012 SciErr getDimFromNamedVar(void *_pvCtx, const char *_pstName, int *_piVal)
1013 {
1014     int *piAddr = NULL;
1015
1016     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
1017     if (sciErr.iErr)
1018     {
1019         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
1020                         _pstName);
1021         return sciErr;
1022     }
1023
1024     sciErr = getDimFromVar(_pvCtx, piAddr, _piVal);
1025     if (sciErr.iErr)
1026     {
1027         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
1028                         _pstName);
1029         return sciErr;
1030     }
1031
1032     return sciErr;
1033 }
1034
1035 /*--------------------------------------------------------------------------*/
1036 int getRhsFromAddress(void *_pvCtx, int *_piAddress)
1037 {
1038     int i = 0;
1039     GatewayStruct* pStr = (GatewayStruct*)_pvCtx;
1040     typed_list in = *pStr->m_pIn;
1041
1042     for (i = 0 ; i < in.size() ; i++)
1043     {
1044         if (_piAddress == (int*)in[i])
1045         {
1046             return i + 1;
1047         }
1048     }
1049     return -1;
1050 }
1051
1052 /*short cut functions*/
1053
1054 /*--------------------------------------------------------------------------*/
1055 int isRowVector(void *_pvCtx, int *_piAddress)
1056 {
1057     int iRows = 0;
1058     int iCols = 0;
1059
1060     if (_piAddress == NULL)
1061     {
1062         return 0;
1063     }
1064
1065     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1066     {
1067         return 0;
1068     }
1069
1070     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1071     if (sciErr.iErr)
1072     {
1073         addErrorMessage(&sciErr, API_ERROR_IS_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isRowVector");
1074         printError(&sciErr, 0);
1075         return sciErr.iErr;
1076     }
1077
1078     if (iRows == 1 && iCols > 1)
1079     {
1080         return 1;
1081     }
1082
1083     return 0;
1084 }
1085
1086 /*--------------------------------------------------------------------------*/
1087 int isNamedRowVector(void *_pvCtx, const char *_pstName)
1088 {
1089     int iRows = 0;
1090     int iCols = 0;
1091
1092     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1093     {
1094         return 0;
1095     }
1096
1097     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1098     if (sciErr.iErr)
1099     {
1100         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isNamedRowVector");
1101         printError(&sciErr, 0);
1102         return sciErr.iErr;
1103     }
1104
1105     if (iRows == 1 && iCols > 1)
1106     {
1107         return 1;
1108     }
1109
1110     return 0;
1111 }
1112
1113 /*--------------------------------------------------------------------------*/
1114 int isColumnVector(void *_pvCtx, int *_piAddress)
1115 {
1116     int iRows = 0;
1117     int iCols = 0;
1118
1119     if (_piAddress == NULL)
1120     {
1121         return 0;
1122     }
1123
1124     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1125     {
1126         return 0;
1127     }
1128
1129     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1130     if (sciErr.iErr)
1131     {
1132         addErrorMessage(&sciErr, API_ERROR_IS_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isColumnVector");
1133         printError(&sciErr, 0);
1134         return 0;
1135     }
1136
1137     if (iCols == 1 && iRows > 1)
1138     {
1139         return 1;
1140     }
1141
1142     return 0;
1143 }
1144
1145 /*--------------------------------------------------------------------------*/
1146 int isNamedColumnVector(void *_pvCtx, const char *_pstName)
1147 {
1148     int iRows = 0;
1149     int iCols = 0;
1150
1151     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1152     {
1153         return 0;
1154     }
1155
1156     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1157     if (sciErr.iErr)
1158     {
1159         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isNamedColumnVector");
1160         printError(&sciErr, 0);
1161         return 0;
1162     }
1163
1164     if (iCols == 1 && iRows > 1)
1165     {
1166         return 1;
1167     }
1168
1169     return 0;
1170 }
1171
1172 /*--------------------------------------------------------------------------*/
1173 int isVector(void *_pvCtx, int *_piAddress)
1174 {
1175     return isRowVector(_pvCtx, _piAddress) || isColumnVector(_pvCtx, _piAddress);
1176 }
1177
1178 /*--------------------------------------------------------------------------*/
1179 int isNamedVector(void *_pvCtx, const char *_pstName)
1180 {
1181     return isNamedRowVector(_pvCtx, _pstName) || isNamedColumnVector(_pvCtx, _pstName);
1182 }
1183
1184 /*--------------------------------------------------------------------------*/
1185 int isStruct(void *_pvCtx, int *_piAddress)
1186 {
1187     if (((InternalType*)_piAddress)->getType() == GenericType::ScilabStruct)
1188     {
1189         return 1;
1190     }
1191     return 0;
1192 }
1193 /*--------------------------------------------------------------------------*/
1194 int isCell(void *_pvCtx, int *_piAddress)
1195 {
1196     if (((InternalType*)_piAddress)->getType() == GenericType::ScilabCell)
1197     {
1198         return 1;
1199     }
1200     return 0;
1201 }
1202 /*--------------------------------------------------------------------------*/
1203 int isScalar(void *_pvCtx, int *_piAddress)
1204 {
1205     int iRows = 0;
1206     int iCols = 0;
1207
1208     if (_piAddress == NULL)
1209     {
1210         return 0;
1211     }
1212
1213     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1214     {
1215         return 0;
1216     }
1217
1218     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1219     if (sciErr.iErr)
1220     {
1221         addErrorMessage(&sciErr, API_ERROR_IS_SCALAR, _("%s: Unable to get argument dimension"), "isScalar");
1222         printError(&sciErr, 0);
1223         return 0;
1224     }
1225
1226     if (iCols == 1 && iRows == 1)
1227     {
1228         return 1;
1229     }
1230
1231     return 0;
1232 }
1233
1234 /*--------------------------------------------------------------------------*/
1235 int isNamedScalar(void *_pvCtx, const char *_pstName)
1236 {
1237     int iRows = 0;
1238     int iCols = 0;
1239
1240     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1241     {
1242         return 0;
1243     }
1244
1245     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1246     if (sciErr.iErr)
1247     {
1248         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SCALAR, _("%s: Unable to get argument dimension"), "isNamedScalar");
1249         printError(&sciErr, 0);
1250         return 0;
1251     }
1252
1253     if (iCols == 1 && iRows == 1)
1254     {
1255         return 1;
1256     }
1257
1258     return 0;
1259 }
1260
1261 /*--------------------------------------------------------------------------*/
1262 int isSquareMatrix(void *_pvCtx, int *_piAddress)
1263 {
1264     int iRows = 0;
1265     int iCols = 0;
1266
1267     if (_piAddress == NULL)
1268     {
1269         return 0;
1270     }
1271
1272     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1273     {
1274         return 0;
1275     }
1276
1277     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1278     if (sciErr.iErr)
1279     {
1280         addErrorMessage(&sciErr, API_ERROR_IS_SQUARE, _("%s: Unable to get argument dimension"), "isSquareMatrix");
1281         printError(&sciErr, 0);
1282         return 0;
1283     }
1284
1285     if (iRows > 1 && iCols == iRows)
1286     {
1287         return 1;
1288     }
1289
1290     return 0;
1291 }
1292
1293 /*--------------------------------------------------------------------------*/
1294 int isNamedSquareMatrix(void *_pvCtx, const char *_pstName)
1295 {
1296     int iRows = 0;
1297     int iCols = 0;
1298
1299     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1300     {
1301         return 0;
1302     }
1303
1304     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1305     if (sciErr.iErr)
1306     {
1307         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SQUARE, _("%s: Unable to get argument dimension"), "isNamedSquareMatrix");
1308         printError(&sciErr, 0);
1309         return 0;
1310     }
1311
1312     if (iRows > 1 && iCols == iRows)
1313     {
1314         return 1;
1315     }
1316
1317     return 0;
1318 }
1319
1320 /*--------------------------------------------------------------------------*/
1321 int checkVarDimension(void *_pvCtx, int *_piAddress, int _iRows, int _iCols)
1322 {
1323     int iRows = 0;
1324     int iCols = 0;
1325
1326     if (_piAddress == NULL)
1327     {
1328         return 0;
1329     }
1330
1331     if (isVarMatrixType(_pvCtx, _piAddress) == 0)
1332     {
1333         return 0;
1334     }
1335
1336     SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
1337     if (sciErr.iErr)
1338     {
1339         addErrorMessage(&sciErr, API_ERROR_CHECK_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkVarDimension");
1340         printError(&sciErr, 0);
1341         return 0;
1342     }
1343
1344     if ((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
1345     {
1346         return 1;
1347     }
1348
1349     return 0;
1350 }
1351
1352 /*--------------------------------------------------------------------------*/
1353 int checkNamedVarDimension(void *_pvCtx, const char *_pstName, int _iRows, int _iCols)
1354 {
1355     int iRows = 0;
1356     int iCols = 0;
1357
1358     if (isNamedVarMatrixType(_pvCtx, _pstName) == 0)
1359     {
1360         return 0;
1361     }
1362
1363     SciErr sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
1364     if (sciErr.iErr)
1365     {
1366         addErrorMessage(&sciErr, API_ERROR_CHECK_NAMED_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkNamedVarDimension");
1367         printError(&sciErr, 0);
1368         return 0;
1369     }
1370
1371     if ((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
1372     {
1373         return 1;
1374     }
1375
1376     return 0;
1377 }
1378
1379 /*--------------------------------------------------------------------------*/
1380 int checkVarType(void *_pvCtx, int *_piAddress, int _iType)
1381 {
1382     int iType = 0;
1383
1384     if (_piAddress == NULL)
1385     {
1386         return 0;
1387     }
1388
1389     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
1390     if (sciErr.iErr)
1391     {
1392         return 0;
1393     }
1394
1395     if (iType == _iType)
1396     {
1397         return 1;
1398     }
1399
1400     return 0;
1401 }
1402
1403 /*--------------------------------------------------------------------------*/
1404 int checkNamedVarType(void *_pvCtx, const char *_pstName, int _iType)
1405 {
1406     int iType = 0;
1407
1408     SciErr sciErr = getNamedVarType(_pvCtx, _pstName, &iType);
1409     if (sciErr.iErr)
1410     {
1411         return 0;
1412     }
1413
1414     if (iType == _iType)
1415     {
1416         return 1;
1417     }
1418
1419     return 0;
1420 }
1421
1422 /*--------------------------------------------------------------------------*/
1423 int getInputArgumentType(void* _pvCtx, int _iVar)
1424 {
1425     int* piAddr = NULL;
1426     int iType = 0;
1427
1428     SciErr sciErr = getinternalVarAddress(_pvCtx, _iVar, &piAddr);
1429     if (sciErr.iErr)
1430     {
1431         return 0;
1432     }
1433
1434     sciErr = getVarType(_pvCtx, piAddr, &iType);
1435     if (sciErr.iErr)
1436     {
1437         return 0;
1438     }
1439
1440     return iType;
1441 }
1442
1443 /*--------------------------------------------------------------------------*/
1444 int checkInputArgumentType(void* _pvCtx, int _iVar, int _iType)
1445 {
1446     return getInputArgumentType(_pvCtx, _iVar) == _iType;
1447 }
1448
1449 /*--------------------------------------------------------------------------*/
1450 int isEmptyMatrix(void *_pvCtx, int *_piAddress)
1451 {
1452     if (checkVarType(_pvCtx, _piAddress, sci_matrix))
1453     {
1454         return checkVarDimension(_pvCtx, _piAddress, 0, 0);
1455     }
1456     return 0;
1457 }
1458
1459 /*--------------------------------------------------------------------------*/
1460 int isNamedEmptyMatrix(void *_pvCtx, const char *_pstName)
1461 {
1462     if (checkNamedVarType(_pvCtx, _pstName, sci_matrix))
1463     {
1464         return checkNamedVarDimension(_pvCtx, _pstName, 0, 0);
1465     }
1466     return 0;
1467 }
1468
1469 /*--------------------------------------------------------------------------*/
1470 int createEmptyMatrix(void *_pvCtx, int _iVar)
1471 {
1472     double dblReal = 0;
1473
1474     SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
1475     if (sciErr.iErr)
1476     {
1477         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1478         printError(&sciErr, 0);
1479         return sciErr.iErr;
1480     }
1481
1482     return 0;
1483 }
1484
1485 /*--------------------------------------------------------------------------*/
1486 int createNamedEmptyMatrix(void *_pvCtx, const char *_pstName)
1487 {
1488     double dblOne = 0;
1489
1490     SciErr sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblOne);
1491     if (sciErr.iErr)
1492     {
1493         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
1494         printError(&sciErr, 0);
1495         return sciErr.iErr;
1496     }
1497
1498     return 0;
1499 }
1500
1501 /*--------------------------------------------------------------------------*/
1502 int isNamedVarExist(void *_pvCtx, const char *_pstName)
1503 {
1504     SciErr sciErr = sciErrInit();
1505     int *piAddr = NULL;
1506
1507     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
1508     if (sciErr.iErr || piAddr == NULL)
1509     {
1510         return 0;
1511     }
1512
1513     return 1;
1514 }
1515
1516 /*--------------------------------------------------------------------------*/
1517 int checkNamedVarFormat(void* _pvCtx, const char *_pstName)
1518 {
1519     // check pointer
1520     if (_pstName == NULL)
1521     {
1522         return 0;
1523     }
1524
1525     // check length _pstName <> 0
1526     if (symbol::Context::getInstance()->isValidVariableName(_pstName) == false)
1527     {
1528         return 0;
1529     }
1530
1531     return 1;
1532 }
1533 /*--------------------------------------------------------------------------*/
1534 int deleteNamedVariable(void* _pvCtx, const char* _pstName)
1535 {
1536     SciErr sciErr = sciErrInit();
1537
1538     if (isNamedVarExist(_pvCtx, _pstName) == 0)
1539     {
1540         return 0;
1541     }
1542
1543     if (!checkNamedVarFormat(_pvCtx, _pstName))
1544     {
1545         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedComplexZMatrixOfDouble", _pstName);
1546         return 0;
1547     }
1548
1549     wchar_t* pwstName = to_wide_string(_pstName);
1550     symbol::Context* ctx = symbol::Context::getInstance();
1551     symbol::Symbol sym = symbol::Symbol(pwstName);
1552     FREE(pwstName);
1553     bool ret = false;
1554     if (ctx->isprotected(sym) == false)
1555     {
1556         ret = ctx->remove(sym);
1557     }
1558     else
1559     {
1560         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
1561     }
1562
1563     return ret ? 1 : 0;
1564 }
1565 /*--------------------------------------------------------------------------*/
1566 int increaseValRef(void* _pvCtx, int* _piAddress)
1567 {
1568     if (_piAddress)
1569     {
1570         types::InternalType* pIT = (types::InternalType*)_piAddress;
1571         types::InternalType* pIT2 = dynamic_cast<types::InternalType*>(pIT);
1572         if (pIT2)
1573         {
1574             pIT->IncreaseRef();
1575             return 1;
1576         }
1577         else
1578         {
1579             Scierror(999, _("Invalid type pointer in '%s'\n"), "increaseValRef");
1580             return -1;
1581         }
1582     }
1583     return 0;
1584 }
1585 /*--------------------------------------------------------------------------*/
1586 int decreaseValRef(void* _pvCtx, int* _piAddress)
1587 {
1588     if (_piAddress)
1589     {
1590         types::InternalType* pIT = (types::InternalType*)_piAddress;
1591         types::InternalType* pIT2 = dynamic_cast<types::InternalType*>(pIT);
1592         if (pIT2)
1593         {
1594             pIT->DecreaseRef();
1595             if (pIT->isDeletable())
1596             {
1597                 delete pIT;
1598             }
1599             return 1;
1600         }
1601         else
1602         {
1603             Scierror(999, _("Invalid type pointer in '%s'\n"), "decreaseValRef");
1604             return -1;
1605         }
1606     }
1607     return 0;
1608 }
1609 /*--------------------------------------------------------------------------*/
1610 static char eostr = '\0';
1611 SciErr sciErrInit()
1612 {
1613     int i = 0 ;
1614     SciErr sciErr;
1615     sciErr.iErr = 0;
1616     sciErr.iMsgCount = 0;
1617
1618     for (; i < MESSAGE_STACK_SIZE ; i++)
1619     {
1620         sciErr.pstMsg[i] = &eostr;
1621     }
1622
1623     return sciErr;
1624 }
1625