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