signal_processing plugged.
[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-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
17 #include "internal.hxx"
18 #include "double.hxx"
19 #include "polynom.hxx"
20 #include "function.hxx"
21
22 extern "C"
23 {
24 #include <string.h>
25 #include <stdlib.h>
26 #include "machine.h"
27 #include "core_math.h"
28 #include "call_scilab.h"
29 #include "api_scilab.h"
30 #include "api_common.h"
31 #include "api_internal_common.h"
32 #include "localization.h"
33 #include "MALLOC.h"
34 #include "api_oldstack.h"
35 }
36
37 /*Global structure for scilab 5.x*/
38 extern "C"
39 {
40     StrCtx* pvApiCtx = NULL;
41 }
42
43 using namespace types;
44 /*--------------------------------------------------------------------------*/
45 /* Defined in SCI/modules/core/src/fortran/cvname.f */
46 extern "C" {
47     extern int C2F(cvnamel)(int *id,char *str,int *jobptr,int *str_len);
48 /* *jobptr==0: Get Scilab codes from C-string */
49 /* *jobptr==1: Get C-string from Scilab codes */
50
51     extern int C2F(stackp)(int *,int *);
52 };
53 /*--------------------------------------------------------------------------*/
54 #define idstk(x,y) (C2F(vstk).idstk+(x-1)+(y-1)*nsiz)
55 #define CvNameL(id,str,jobptr,str_len) C2F(cvnamel)(id,str,jobptr,str_len);
56 /*--------------------------------------------------------------------------*/
57
58 SciErr getVarDimension(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols)
59 {
60     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
61     if(_piAddress != NULL && isVarMatrixType(_pvCtx, _piAddress))
62     {
63         *_piRows        = ((types::InternalType*)_piAddress)->getAsGenericType()->getRows();
64         *_piCols        = ((types::InternalType*)_piAddress)->getAsGenericType()->getCols();
65     }
66     else
67     {
68         *_piRows        = 0;
69         *_piCols        = 0;
70         if(_piAddress == NULL)
71         {
72             addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarDimension");
73         }
74         else
75         {
76             addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument excepted"), "getVarDimension");
77         }
78     }
79     return sciErr;
80 }
81 /*--------------------------------------------------------------------------*/
82 SciErr getNamedVarDimension(void* _pvCtx, const char *_pstName, int* _piRows, int* _piCols)
83 {
84     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
85     int* piAddr                = NULL;
86     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
87     if(sciErr.iErr)
88     {
89         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
90         return sciErr;
91     }
92
93     sciErr = getVarDimension(_pvCtx, piAddr, _piRows, _piCols);
94     if(sciErr.iErr)
95     {
96         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
97         return sciErr;
98     }
99
100     return sciErr;
101 }
102 /*--------------------------------------------------------------------------*/
103 SciErr getVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
104 {
105     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
106
107     if(_pvCtx == NULL)
108     {
109         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarAddressFromPosition");
110         return sciErr;
111     }
112
113     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
114     types::typed_list in = *pStr->m_pIn;
115     int*    piRetCount = pStr->m_piRetCount;
116     wchar_t* pstName = pStr->m_pstName;
117
118     int iAddr            = 0;
119
120     int iValType    = 0;
121     /* we accept a call to getVarAddressFromPosition after a create... call */
122     if(_iVar > in.size())
123     {
124         //manage case where _iVar > in.size(), then look in out to get recent create variable.
125         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), pstName, "getVarAddressFromPosition");
126         return sciErr;
127     }
128
129     *_piAddress        = (int*)in[_iVar - 1];
130     return sciErr;
131 }
132 /*--------------------------------------------------------------------------*/
133 SciErr getVarNameFromPosition(void* _pvCtx, int _iVar, char* _pstName)
134 {
135     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
136     //int iNameLen                = 0;
137     //int iJob1                        = 1;
138     //CvNameL(&vstk_.idstk[(_iVar - 1) * 6], _pstName, &iJob1, &iNameLen);
139     //if(iNameLen == 0)
140     //{
141     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get name of argument #%d"), "getVarNameFromPosition", _iVar);
142     //    return sciErr;
143     //}
144
145     //_pstName[iNameLen]    = '\0';
146     return sciErr;
147 }
148 /*--------------------------------------------------------------------------*/
149 int getNewVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
150 {
151     //int iAddr            = iadr(*Lstk(_iVar));
152     //*_piAddress        = istk(iAddr);
153     return 0;
154 }
155 /*--------------------------------------------------------------------------*/
156 SciErr getVarAddressFromName(void* _pvCtx, const char* _pstName, int** _piAddress)
157 {
158     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
159     //int iVarID[nsiz];
160     //int* piAddr                = NULL;
161
162     ////get variable id from name
163     //C2F(str2name)(_pstName, iVarID, (int)strlen(_pstName));
164
165     ////define scope of search
166     //Fin = -1;
167     //Err = 0;
168     ////search variable
169     //C2F(stackg)(iVarID);
170
171     ////No idea :(
172     //if ( *Infstk(Fin) == 2)
173     //    Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
174
175     //if (Err > 0 || Fin == 0)
176     //{
177     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get address of variable \"%s\""), "getVarAddressFromName", _pstName);
178     //    return sciErr;
179     //}
180
181
182     ////get variable address
183     //getNewVarAddressFromPosition(_pvCtx, Fin, &piAddr);
184
185     //*_piAddress = piAddr;
186
187     return sciErr;
188 }
189
190 /*--------------------------------------------------------------------------*/
191 SciErr getVarType(void* _pvCtx, int* _piAddress, int* _piType)
192 {
193     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
194
195     if(_piAddress == NULL)
196     {
197         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
198         return sciErr;
199     }
200
201     switch(((types::InternalType*)_piAddress)->getType())
202     {
203     case GenericType::RealDouble :
204         *_piType = sci_matrix;
205         break;
206     case types::GenericType::RealPoly :
207         *_piType = sci_poly;
208         break;
209     case types::GenericType::RealBool :
210         *_piType = sci_boolean;
211         break;
212         //case GenericType::RealSparse :
213         //    *_piType = sci_sparse;
214         //    break;
215         //case GenericType::RealBoolSparse :
216         //    *_piType = sci_boolean_sparse;
217         //    break;
218         //case GenericType::RealMatlabSparse :
219         //    *_piType = sci_matlab_sparse;
220         //    break;
221     case GenericType::RealInt8 :
222     case GenericType::RealUInt8 :
223     case GenericType::RealInt16 :
224     case GenericType::RealUInt16 :
225     case GenericType::RealInt32 :
226     case GenericType::RealUInt32 :
227     case GenericType::RealInt64 :
228     case GenericType::RealUInt64 :
229         *_piType = sci_ints;
230         break;
231         //case GenericType::RealHandle :
232         //    *_piType = sci_handles;
233         //    break;
234     case GenericType::RealString :
235         *_piType = sci_strings;
236         break;
237     case GenericType::RealMacroFile :
238         *_piType = sci_u_function;
239         break;
240     case GenericType::RealMacro :
241         *_piType = sci_c_function;
242         break;
243     case GenericType::RealList :
244         *_piType = sci_list;
245         break;
246     case GenericType::RealCell :
247         *_piType = sci_mlist;
248         break;
249     case GenericType::RealTList :
250         *_piType = sci_tlist;
251         break;
252     case GenericType::RealMList :
253         *_piType = sci_mlist;
254         break;
255     case GenericType::RealStruct :
256         // Scilab < 6 compatibility... Struct have type 17;
257         *_piType = sci_mlist;
258         break;
259     case GenericType::RealUserType :
260         *_piType = sci_pointer;
261         break;
262     case GenericType::RealImplicitList :
263         *_piType = sci_implicit_poly;
264         break;
265     case GenericType::RealFunction :
266         *_piType = sci_intrinsic_function;
267         break;
268     default :
269         *_piType = 0;
270     }
271
272
273     return sciErr;
274 }
275 /*--------------------------------------------------------------------------*/
276 // _pvCtx will not be used by getVarAddressFromName neither getVarType
277 // it can then be NULL.
278 SciErr getNamedVarType(void* _pvCtx, const char* _pstName, int* _piType)
279 {
280     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
281     int* piAddr                = NULL;
282
283     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
284     if(sciErr.iErr)
285     {
286         addErrorMessage(&sciErr, API_ERROR_NAMED_UNDEFINED_VAR, _("%s: Unable to get variable \"%s\""), "getNamedVarType", _pstName);
287         return sciErr;
288     }
289
290     sciErr = getVarType(_pvCtx, piAddr, _piType);
291     if(sciErr.iErr)
292     {
293         addErrorMessage(&sciErr, API_ERROR_NAMED_TYPE, _("%s: Unable to get type of variable \"%s\""), "getNamedVarType", _pstName);
294         return sciErr;
295     }
296     return sciErr;
297 }
298 /*--------------------------------------------------------------------------*/
299 int isVarComplex(void* _pvCtx, int* _piAddress)
300 {
301     SciErr sciErr;
302     int iType            = 0;
303     int iComplex    = 0;
304
305     if(_piAddress == NULL)
306     {
307         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
308         return 0;
309     }
310
311
312     getVarType(_pvCtx, _piAddress, &iType);
313     switch(iType)
314     {
315     case sci_matrix :
316         iComplex = ((types::InternalType*)_piAddress)->getAs<Double>()->isComplex();
317         break;
318     case sci_poly :
319         iComplex = ((types::InternalType*)_piAddress)->getAs<Polynom>()->isComplex();
320     case sci_sparse :
321         //iComplex = ((InternalType*)_piAddress)->getAsSparse()->isComplex();
322         break;
323     }
324     return iComplex;
325 }
326 /*--------------------------------------------------------------------------*/
327 int isNamedVarComplex(void* _pvCtx, const char *_pstName)
328 {
329     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
330     int* piAddr                = NULL;
331
332     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
333     if(sciErr.iErr)
334     {
335         return 0;
336     }
337     return isVarComplex(_pvCtx, piAddr);
338 }
339 /*--------------------------------------------------------------------------*/
340 void createNamedVariable(int *_piVarID)
341 {
342     //int iOne                = 1;
343     //C2F(stackp)(_piVarID, &iOne);
344 }
345 /*--------------------------------------------------------------------------*/
346 int updateInterSCI(int _iVar, char _cType, int _iSCIAddress, int _iSCIDataAddress)
347 {
348     //intersci_.ntypes[_iVar - 1]    = _cType;
349     //intersci_.iwhere[_iVar - 1]    = _iSCIAddress;
350     //intersci_.lad[_iVar - 1]        = _iSCIDataAddress;
351     return 0;
352 }
353 /*--------------------------------------------------------------------------*/
354 int updateLstk(int _iNewpos, int _iSCIDataAddress, int _iVarSize)
355 {
356     //*Lstk(_iNewpos + 1) = _iSCIDataAddress + _iVarSize;
357     return 0;
358 }
359 /*--------------------------------------------------------------------------*/
360 int isVarMatrixType(void* _pvCtx, int* _piAddress)
361 {
362     if(_piAddress != NULL)
363     {
364         int iType = 0;
365         getVarType(_pvCtx, _piAddress, &iType);
366
367         switch(iType)
368         {
369         case sci_matrix :
370         case sci_poly :
371         case sci_boolean :
372         case sci_sparse :
373         case sci_boolean_sparse :
374         case sci_matlab_sparse :
375         case sci_ints :
376         case sci_handles :
377         case sci_strings :
378             return 1;
379         default :
380             return 0;
381         }
382     }
383     else
384     {
385         return 0;
386     }
387     return 1;
388 }
389 /*--------------------------------------------------------------------------*/
390 int isNamedVarMatrixType(void* _pvCtx, const char *_pstName)
391 {
392     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
393     int* piAddr                = NULL;
394
395     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
396     if(sciErr.iErr)
397     {
398         return 0;
399     }
400     return isVarMatrixType(_pvCtx, piAddr);
401 }
402 /*--------------------------------------------------------------------------*/
403 SciErr getProcessMode(void* _pvCtx, int _iPos, int* _piAddRef, int *_piMode)
404 {
405     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
406     int iRows1            = 0;
407     int iCols1            = 0;
408     int iRows2            = 0;
409     int iCols2            = 0;
410     int iType2            = 0;
411     int iMode                = 0;
412     int* piAddr2        = NULL;
413
414     sciErr = getVarDimension(_pvCtx, _piAddRef, &iRows1, &iCols1);
415     if(sciErr.iErr)
416     {
417         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
418         return sciErr;
419     }
420
421     sciErr = getVarAddressFromPosition(_pvCtx, _iPos, &piAddr2);
422     if(sciErr.iErr)
423     {
424         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get variable address"), "getProcessMode");
425         return sciErr;
426     }
427
428     sciErr = getVarType(_pvCtx, piAddr2, &iType2);
429     if(sciErr.iErr)
430     {
431         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument type"), "getProcessMode");
432         return sciErr;
433     }
434
435     if(iType2 == sci_matrix && !isVarComplex(_pvCtx, piAddr2))
436     {
437         double *pdblReal2 = NULL;
438         sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblReal2);
439         if(sciErr.iErr)
440         {
441             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
442             return sciErr;
443         }
444
445         if(iRows2 != 1 || iCols2 != 1)
446         {
447             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1, 1);
448             return sciErr;
449         }
450
451         iMode = (int)pdblReal2[0];
452     }
453     else if(iType2 == sci_strings)
454     {
455         int iLen                    = 0;
456         char *pstMode[1]    = {""};
457
458         sciErr = getVarDimension(_pvCtx, piAddr2, &iRows2, &iCols2);
459         if(sciErr.iErr)
460         {
461             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
462             return sciErr;
463         }
464
465         if(iRows2 != 1 || iCols2 != 1)
466         {
467             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1, 1);
468             return sciErr;
469         }
470
471         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, NULL);
472         if(sciErr.iErr)
473         {
474             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
475             return sciErr;
476         }
477
478         pstMode[0] = (char*)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
479         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, pstMode);
480         if(sciErr.iErr)
481         {
482             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
483             return sciErr;
484         }
485
486         iMode = (int)pstMode[0][0];
487         FREE(pstMode[0]);
488     }
489     else
490     {
491         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong type for input argument #%d: A string or a scalar expected.\n"), "getProcessMode", _iPos);
492         return sciErr;
493     }
494
495     if(iMode == ROW_LETTER || iMode == BY_ROWS)
496         *_piMode = BY_ROWS;
497     else if(iMode == COL_LETTER || iMode == BY_COLS)
498         *_piMode = BY_COLS;
499     else if(iMode == STAR_LETTER || iMode == BY_ALL)
500         *_piMode = BY_ALL;
501     else if(iMode == MTLB_LETTER || iMode == BY_MTLB)
502     {
503         *_piMode = 0;
504         if(iRows1 > 1)
505             *_piMode = 1;
506         else if(iCols1 > 1)
507             *_piMode = 2;
508     }
509     else
510     {
511         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong value for input argument #%d: ''%s'' or ''%s'' expected.\n"), "getProcessMode", _iPos, "'*', 'r', 'c', 'm', '0', '1', '2'", "-1");
512         return sciErr;
513     }
514     return sciErr;
515 }
516 /*--------------------------------------------------------------------------*/
517 SciErr getDimFromVar(void* _pvCtx, int* _piAddress, int* _piVal)
518 {
519     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
520     int iType                    = 0;
521     int iRows                    = 0;
522     int iCols                    = 0;
523     double *pdblReal    = NULL;
524
525     sciErr = getVarType(_pvCtx, _piAddress, &iType);
526     if(sciErr.iErr)
527     {
528         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
529         return sciErr;
530     }
531
532     if(iType == sci_matrix)
533     {
534         if(isVarComplex(_pvCtx, _piAddress))
535         {
536             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument %d: Real matrix expected.\n"), "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
537             return sciErr;
538         }
539
540         sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
541         if(sciErr.iErr)
542         {
543             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
544             return sciErr;
545         }
546
547         *_piVal = (int)Max(pdblReal[0], 0);
548     }
549     else if(iType == sci_ints)
550     {
551         int iPrec            = 0;
552
553         sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
554         if(sciErr.iErr)
555         {
556             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
557             return sciErr;
558         }
559
560         if(iRows != 1 || iCols != 1)
561         {
562             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
563             return sciErr;
564         }
565
566         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
567         if(sciErr.iErr)
568         {
569             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
570             return sciErr;
571         }
572
573         switch(iPrec)
574         {
575         case SCI_INT8 :
576         {
577             char* pcData        = NULL;
578             sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
579             if(sciErr.iErr)
580             {
581                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
582                 return sciErr;
583             }
584             *_piVal = pcData[0];
585         }
586         break;
587         case SCI_UINT8 :
588         {
589             unsigned char* pucData        = NULL;
590             sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
591             if(sciErr.iErr)
592             {
593                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
594                 return sciErr;
595             }
596             *_piVal = pucData[0];
597         }
598         break;
599         case SCI_INT16 :
600         {
601             short* psData        = NULL;
602             sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
603             if(sciErr.iErr)
604             {
605                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
606                 return sciErr;
607             }
608             *_piVal = psData[0];
609         }
610         break;
611         case SCI_UINT16 :
612         {
613             unsigned short* pusData        = NULL;
614             sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
615             if(sciErr.iErr)
616             {
617                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
618                 return sciErr;
619             }
620             *_piVal = pusData[0];
621         }
622         break;
623         case SCI_INT32 :
624         {
625             int* piData        = NULL;
626             sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
627             if(sciErr.iErr)
628             {
629                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
630                 return sciErr;
631             }
632             *_piVal = piData[0];
633         }
634         break;
635         case SCI_UINT32 :
636         {
637             unsigned int* puiData        = NULL;
638             sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
639             if(sciErr.iErr)
640             {
641                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
642                 return sciErr;
643             }
644             *_piVal = puiData[0];
645         }
646         break;
647         }
648     }
649     else
650     {
651         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or a integer scalar expected.\n"), "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
652         return sciErr;
653     }
654     return sciErr;
655 }
656 /*--------------------------------------------------------------------------*/
657 SciErr getDimFromNamedVar(void* _pvCtx, const char* _pstName, int* _piVal)
658 {
659     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
660     int* piAddr        = NULL;
661
662     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
663     if(sciErr.iErr)
664     {
665         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar", _pstName);
666         return sciErr;
667     }
668
669     sciErr = getDimFromVar(_pvCtx, piAddr, _piVal);
670     if(sciErr.iErr)
671     {
672         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar", _pstName);
673         return sciErr;
674     }
675
676     return sciErr;
677 }
678 /*--------------------------------------------------------------------------*/
679 int getRhsFromAddress(void* _pvCtx, int* _piAddress)
680 {
681     //int i = 0;
682     //   types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
683     //   types::typed_list in = *pStr->m_pIn;
684
685     //for(i = 0 ; i < Rhs ; i++)
686     //{
687     //    if(_piAddress == (int*)in[i])
688     //    {
689     //        return i + 1;
690     //    }
691     //}
692     return 0;
693 }
694
695 /*short cut functions*/
696
697 /*--------------------------------------------------------------------------*/
698 int isRowVector(void* _pvCtx, int* _piAddress)
699 {
700     SciErr sciErr;
701     int iRows = 0;
702     int iCols = 0;
703
704     if(_piAddress == NULL)
705     {
706         return 0;
707     }
708
709     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
710     {
711         return 0;
712     }
713
714     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
715     if(sciErr.iErr)
716     {
717         addErrorMessage(&sciErr, API_ERROR_IS_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isRowVector");
718         printError(&sciErr, 0);
719         return sciErr.iErr;
720     }
721
722     if(iRows == 1 && iCols > 1)
723     {
724         return 1;
725     }
726
727     return 0;
728 }
729 /*--------------------------------------------------------------------------*/
730 int isNamedRowVector(void* _pvCtx, const char* _pstName)
731 {
732     SciErr sciErr;
733     int iRows = 0;
734     int iCols = 0;
735
736     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
737     {
738         return 0;
739     }
740
741     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
742     if(sciErr.iErr)
743     {
744         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isNamedRowVector");
745         printError(&sciErr, 0);
746         return sciErr.iErr;
747     }
748
749     if(iRows == 1 && iCols > 1)
750     {
751         return 1;
752     }
753
754     return 0;
755 }
756 /*--------------------------------------------------------------------------*/
757 int isColumnVector(void* _pvCtx, int* _piAddress)
758 {
759     SciErr sciErr;
760     int iRows = 0;
761     int iCols = 0;
762
763     if(_piAddress == NULL)
764     {
765         return 0;
766     }
767
768     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
769     {
770         return 0;
771     }
772
773     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
774     if(sciErr.iErr)
775     {
776         addErrorMessage(&sciErr, API_ERROR_IS_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isColumnVector");
777         printError(&sciErr, 0);
778         return 0;
779     }
780
781     if(iCols == 1 && iRows > 1)
782     {
783         return 1;
784     }
785
786     return 0;
787 }
788 /*--------------------------------------------------------------------------*/
789 int isNamedColumnVector(void* _pvCtx, const char* _pstName)
790 {
791     SciErr sciErr;
792     int iRows = 0;
793     int iCols = 0;
794
795     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
796     {
797         return 0;
798     }
799
800     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
801     if(sciErr.iErr)
802     {
803         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isNamedColumnVector");
804         printError(&sciErr, 0);
805         return 0;
806     }
807
808     if(iCols == 1 && iRows > 1)
809     {
810         return 1;
811     }
812
813     return 0;
814 }
815 /*--------------------------------------------------------------------------*/
816 int isVector(void* _pvCtx, int* _piAddress)
817 {
818     return isRowVector(_pvCtx, _piAddress) || isColumnVector(_pvCtx, _piAddress);
819 }
820 /*--------------------------------------------------------------------------*/
821 int isNamedVector(void* _pvCtx, const char* _pstName)
822 {
823     return isNamedRowVector(_pvCtx, _pstName) || isNamedColumnVector(_pvCtx, _pstName);
824 }
825 /*--------------------------------------------------------------------------*/
826 int isScalar(void* _pvCtx, int* _piAddress)
827 {
828     SciErr sciErr;
829     int iRows = 0;
830     int iCols = 0;
831
832     if(_piAddress == NULL)
833     {
834         return 0;
835     }
836
837     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
838     {
839         return 0;
840     }
841
842     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
843     if(sciErr.iErr)
844     {
845         addErrorMessage(&sciErr, API_ERROR_IS_SCALAR, _("%s: Unable to get argument dimension"), "isScalar");
846         printError(&sciErr, 0);
847         return 0;
848     }
849
850     if(iCols == 1 && iRows == 1)
851     {
852         return 1;
853     }
854
855     return 0;
856 }
857 /*--------------------------------------------------------------------------*/
858 int isNamedScalar(void* _pvCtx, const char* _pstName)
859 {
860     SciErr sciErr;
861     int iRows = 0;
862     int iCols = 0;
863
864     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
865     {
866         return 0;
867     }
868
869     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
870     if(sciErr.iErr)
871     {
872         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SCALAR, _("%s: Unable to get argument dimension"), "isNamedScalar");
873         printError(&sciErr, 0);
874         return 0;
875     }
876
877     if(iCols == 1 && iRows == 1)
878     {
879         return 1;
880     }
881
882     return 0;
883 }
884 /*--------------------------------------------------------------------------*/
885 int isSquareMatrix(void* _pvCtx, int* _piAddress)
886 {
887     SciErr sciErr;
888     int iRows = 0;
889     int iCols = 0;
890
891     if(_piAddress == NULL)
892     {
893         return 0;
894     }
895
896     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
897     {
898         return 0;
899     }
900
901     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
902     if(sciErr.iErr)
903     {
904         addErrorMessage(&sciErr, API_ERROR_IS_SQUARE, _("%s: Unable to get argument dimension"), "isSquareMatrix");
905         printError(&sciErr, 0);
906         return 0;
907     }
908
909     if(iRows > 1 && iCols == iRows)
910     {
911         return 1;
912     }
913
914     return 0;
915 }
916 /*--------------------------------------------------------------------------*/
917 int isNamedSquareMatrix(void* _pvCtx, const char* _pstName)
918 {
919     SciErr sciErr;
920     int iRows = 0;
921     int iCols = 0;
922
923     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
924     {
925         return 0;
926     }
927
928     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
929     if(sciErr.iErr)
930     {
931         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SQUARE, _("%s: Unable to get argument dimension"), "isNamedSquareMatrix");
932         printError(&sciErr, 0);
933         return 0;
934     }
935
936     if(iRows > 1 && iCols == iRows)
937     {
938         return 1;
939     }
940
941     return 0;
942 }
943 /*--------------------------------------------------------------------------*/
944 int checkVarDimension(void* _pvCtx, int* _piAddress, int _iRows, int _iCols)
945 {
946     SciErr sciErr;
947     int iRows = 0;
948     int iCols = 0;
949
950     if(_piAddress == NULL)
951     {
952         return 0;
953     }
954
955     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
956     {
957         return 0;
958     }
959
960     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
961     if(sciErr.iErr)
962     {
963         addErrorMessage(&sciErr, API_ERROR_CHECK_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkVarDimension");
964         printError(&sciErr, 0);
965         return 0;
966     }
967
968     if((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
969     {
970         return 1;
971     }
972
973     return 0;
974 }
975 /*--------------------------------------------------------------------------*/
976 int checkNamedVarDimension(void* _pvCtx, const char* _pstName, int _iRows, int _iCols)
977 {
978     SciErr sciErr;
979     int iRows = 0;
980     int iCols = 0;
981
982     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
983     {
984         return 0;
985     }
986
987     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
988     if(sciErr.iErr)
989     {
990         addErrorMessage(&sciErr, API_ERROR_CHECK_NAMED_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkNamedVarDimension");
991         printError(&sciErr, 0);
992         return 0;
993     }
994
995     if((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
996     {
997         return 1;
998     }
999
1000     return 0;
1001 }
1002 /*--------------------------------------------------------------------------*/
1003 int checkVarType(void* _pvCtx, int* _piAddress, int _iType)
1004 {
1005     SciErr sciErr;
1006     int iType = 0;
1007     if(_piAddress == NULL)
1008     {
1009         return 0;
1010     }
1011
1012     sciErr = getVarType(_pvCtx, _piAddress, &iType);
1013     if(sciErr.iErr)
1014     {
1015         return 0;
1016     }
1017
1018     if(iType == _iType)
1019     {
1020         return 1;
1021     }
1022
1023     return 0;
1024 }
1025 /*--------------------------------------------------------------------------*/
1026 int checkNamedVarType(void* _pvCtx, const char* _pstName, int _iType)
1027 {
1028     SciErr sciErr;
1029     int iType = 0;
1030
1031     sciErr = getNamedVarType(_pvCtx, _pstName, &iType);
1032     if(sciErr.iErr)
1033     {
1034         return 0;
1035     }
1036
1037     if(iType == _iType)
1038     {
1039         return 1;
1040     }
1041
1042     return 0;
1043 }
1044 /*--------------------------------------------------------------------------*/
1045 int isEmptyMatrix(void* _pvCtx, int* _piAddress)
1046 {
1047     if(checkVarType(_pvCtx, _piAddress, sci_matrix))
1048     {
1049         return checkVarDimension(_pvCtx, _piAddress, 0, 0);
1050     }
1051     return 0;
1052 }
1053 /*--------------------------------------------------------------------------*/
1054 int isNamedEmptyMatrix(void* _pvCtx, const char* _pstName)
1055 {
1056     if(checkNamedVarType(_pvCtx, _pstName, sci_matrix))
1057     {
1058         return checkNamedVarDimension(_pvCtx, _pstName, 0, 0);
1059     }
1060     return 0;
1061 }
1062 /*--------------------------------------------------------------------------*/
1063 int createEmptyMatrix(void* _pvCtx, int _iVar)
1064 {
1065     SciErr sciErr;
1066     double dblReal = 0;
1067
1068     sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
1069     if(sciErr.iErr)
1070     {
1071         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1072         printError(&sciErr, 0);
1073         return sciErr.iErr;
1074     }
1075
1076     return 0;
1077 }
1078 /*--------------------------------------------------------------------------*/
1079 int createNamedEmptyMatrix(void* _pvCtx, const char *_pstName)
1080 {
1081     SciErr sciErr;
1082     double dblOne = 0;
1083
1084     sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblOne);
1085     if(sciErr.iErr)
1086     {
1087         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
1088         printError(&sciErr, 0);
1089         return sciErr.iErr;
1090     }
1091
1092     return 0;
1093 }
1094 /*--------------------------------------------------------------------------*/
1095 int isNamedVarExist(void* _pvCtx, const char* _pstName)
1096 {
1097     SciErr sciErr;
1098     int* piAddr = NULL;
1099
1100     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
1101     if(sciErr.iErr || piAddr == NULL)
1102     {
1103         return 0;
1104     }
1105
1106     return 1;
1107 }
1108 /*--------------------------------------------------------------------------*/