bffc262c136e3d482995ddbea4160bc021248178
[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 "arrayof.hxx"
19 #include "function.hxx"
20
21 extern "C"
22 {
23 #include <string.h>
24 #include <stdlib.h>
25 #include "machine.h"
26 #include "core_math.h"
27 #include "call_scilab.h"
28 #include "api_scilab.h"
29 #include "api_common.h"
30 #include "api_internal_common.h"
31 #include "localization.h"
32 #include "MALLOC.h"
33 #include "api_oldstack.h"
34 }
35
36 /*Global structure for scilab 5.x*/
37 extern "C"
38 {
39     StrCtx* pvApiCtx = NULL;
40 }
41
42 using namespace types;
43 /*--------------------------------------------------------------------------*/
44 /* Defined in SCI/modules/core/src/fortran/cvname.f */
45 extern "C" {
46     extern int C2F(cvnamel)(int *id,char *str,int *jobptr,int *str_len);
47 /* *jobptr==0: Get Scilab codes from C-string */
48 /* *jobptr==1: Get C-string from Scilab codes */
49
50     extern int C2F(stackp)(int *,int *);
51 };
52 /*--------------------------------------------------------------------------*/
53 #define idstk(x,y) (C2F(vstk).idstk+(x-1)+(y-1)*nsiz)
54 #define CvNameL(id,str,jobptr,str_len) C2F(cvnamel)(id,str,jobptr,str_len);
55 /*--------------------------------------------------------------------------*/
56
57 SciErr getVarDimension(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols)
58 {
59     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
60     if(_piAddress != NULL && isVarMatrixType(_pvCtx, _piAddress))
61     {
62         *_piRows        = ((types::InternalType*)_piAddress)->getAsGenericType()->getRows();
63         *_piCols        = ((types::InternalType*)_piAddress)->getAsGenericType()->getCols();
64     }
65     else
66     {
67         *_piRows        = 0;
68         *_piCols        = 0;
69         if(_piAddress == NULL)
70         {
71             addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarDimension");
72         }
73         else
74         {
75             addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument excepted"), "getVarDimension");
76         }
77     }
78     return sciErr;
79 }
80 /*--------------------------------------------------------------------------*/
81 SciErr getNamedVarDimension(void* _pvCtx, const char *_pstName, int* _piRows, int* _piCols)
82 {
83     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
84     int* piAddr                = NULL;
85     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
86     if(sciErr.iErr)
87     {
88         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
89         return sciErr;
90     }
91
92     sciErr = getVarDimension(_pvCtx, piAddr, _piRows, _piCols);
93     if(sciErr.iErr)
94     {
95         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
96         return sciErr;
97     }
98
99     return sciErr;
100 }
101 /*--------------------------------------------------------------------------*/
102 SciErr getVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
103 {
104     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
105
106     if(_pvCtx == NULL)
107     {
108         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarAddressFromPosition");
109         return sciErr;
110     }
111
112     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
113     types::typed_list in = *pStr->m_pIn;
114     int*    piRetCount = pStr->m_piRetCount;
115     wchar_t* pstName = pStr->m_pstName;
116
117     int iAddr            = 0;
118
119     int iValType    = 0;
120     /* we accept a call to getVarAddressFromPosition after a create... call */
121     if(_iVar > in.size())
122     {
123         //manage case where _iVar > in.size(), then look in out to get recent create variable.
124         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), pstName, "getVarAddressFromPosition");
125         return sciErr;
126     }
127
128     *_piAddress        = (int*)in[_iVar - 1];
129     return sciErr;
130 }
131 /*--------------------------------------------------------------------------*/
132 SciErr getVarNameFromPosition(void* _pvCtx, int _iVar, char* _pstName)
133 {
134     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
135     //int iNameLen                = 0;
136     //int iJob1                        = 1;
137     //CvNameL(&vstk_.idstk[(_iVar - 1) * 6], _pstName, &iJob1, &iNameLen);
138     //if(iNameLen == 0)
139     //{
140     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get name of argument #%d"), "getVarNameFromPosition", _iVar);
141     //    return sciErr;
142     //}
143
144     //_pstName[iNameLen]    = '\0';
145     return sciErr;
146 }
147 /*--------------------------------------------------------------------------*/
148 int getNewVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
149 {
150     //int iAddr            = iadr(*Lstk(_iVar));
151     //*_piAddress        = istk(iAddr);
152     return 0;
153 }
154 /*--------------------------------------------------------------------------*/
155 SciErr getVarAddressFromName(void* _pvCtx, const char* _pstName, int** _piAddress)
156 {
157     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
158     //int iVarID[nsiz];
159     //int* piAddr                = NULL;
160
161     ////get variable id from name
162     //C2F(str2name)(_pstName, iVarID, (int)strlen(_pstName));
163
164     ////define scope of search
165     //Fin = -1;
166     //Err = 0;
167     ////search variable
168     //C2F(stackg)(iVarID);
169
170     ////No idea :(
171     //if ( *Infstk(Fin) == 2)
172     //    Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
173
174     //if (Err > 0 || Fin == 0)
175     //{
176     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get address of variable \"%s\""), "getVarAddressFromName", _pstName);
177     //    return sciErr;
178     //}
179
180
181     ////get variable address
182     //getNewVarAddressFromPosition(_pvCtx, Fin, &piAddr);
183
184     //*_piAddress = piAddr;
185
186     return sciErr;
187 }
188
189 /*--------------------------------------------------------------------------*/
190 SciErr getVarType(void* _pvCtx, int* _piAddress, int* _piType)
191 {
192     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
193
194     if(_piAddress == NULL)
195     {
196         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
197         return sciErr;
198     }
199
200     switch(((types::InternalType*)_piAddress)->getType())
201     {
202     case GenericType::RealDouble :
203         *_piType = sci_matrix;
204         break;
205     case types::GenericType::RealPoly :
206         *_piType = sci_poly;
207         break;
208     case types::GenericType::RealBool :
209         *_piType = sci_boolean;
210         break;
211         //case GenericType::RealSparse :
212         //    *_piType = sci_sparse;
213         //    break;
214         //case GenericType::RealBoolSparse :
215         //    *_piType = sci_boolean_sparse;
216         //    break;
217         //case GenericType::RealMatlabSparse :
218         //    *_piType = sci_matlab_sparse;
219         //    break;
220     case GenericType::RealInt8 :
221     case GenericType::RealUInt8 :
222     case GenericType::RealInt16 :
223     case GenericType::RealUInt16 :
224     case GenericType::RealInt32 :
225     case GenericType::RealUInt32 :
226     case GenericType::RealInt64 :
227     case GenericType::RealUInt64 :
228         *_piType = sci_ints;
229         break;
230         //case GenericType::RealHandle :
231         //    *_piType = sci_handles;
232         //    break;
233     case GenericType::RealString :
234         *_piType = sci_strings;
235         break;
236     case GenericType::RealMacroFile :
237         *_piType = sci_u_function;
238         break;
239     case GenericType::RealMacro :
240         *_piType = sci_c_function;
241         break;
242     case GenericType::RealList :
243         *_piType = sci_list;
244         break;
245     case GenericType::RealCell :
246         *_piType = sci_mlist;
247         break;
248     case GenericType::RealTList :
249         *_piType = sci_tlist;
250         break;
251     case GenericType::RealMList :
252         *_piType = sci_mlist;
253         break;
254     case GenericType::RealStruct :
255         // Scilab < 6 compatibility... Struct have type 17;
256         *_piType = sci_mlist;
257         break;
258     case GenericType::RealUserType :
259         *_piType = sci_pointer;
260         break;
261     case GenericType::RealImplicitList :
262         *_piType = sci_implicit_poly;
263         break;
264     case GenericType::RealFunction :
265         *_piType = sci_intrinsic_function;
266         break;
267     default :
268         *_piType = 0;
269     }
270
271
272     return sciErr;
273 }
274 /*--------------------------------------------------------------------------*/
275 // _pvCtx will not be used by getVarAddressFromName neither getVarType
276 // it can then be NULL.
277 SciErr getNamedVarType(void* _pvCtx, const char* _pstName, int* _piType)
278 {
279     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
280     int* piAddr                = NULL;
281
282     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
283     if(sciErr.iErr)
284     {
285         addErrorMessage(&sciErr, API_ERROR_NAMED_UNDEFINED_VAR, _("%s: Unable to get variable \"%s\""), "getNamedVarType", _pstName);
286         return sciErr;
287     }
288
289     sciErr = getVarType(_pvCtx, piAddr, _piType);
290     if(sciErr.iErr)
291     {
292         addErrorMessage(&sciErr, API_ERROR_NAMED_TYPE, _("%s: Unable to get type of variable \"%s\""), "getNamedVarType", _pstName);
293         return sciErr;
294     }
295     return sciErr;
296 }
297 /*--------------------------------------------------------------------------*/
298 int isVarComplex(void* _pvCtx, int* _piAddress)
299 {
300     SciErr sciErr;
301     int iType            = 0;
302     int iComplex    = 0;
303
304     if(_piAddress == NULL)
305     {
306         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
307         return 0;
308     }
309
310 /*
311   getVarType(_pvCtx, _piAddress, &iType);
312   switch(iType)
313   {
314   case sci_matrix :
315   iComplex = ((types::InternalType*)(_piAddress))->getAsDouble()->isComplex();
316   break;
317   case sci_poly :
318   iComplex = ((types::InternalType*)_piAddress)->getAs<types::Polynom>()->isComplex();
319   case sci_sparse :
320   //iComplex = ((InternalType*)_piAddress)->getAsSparse()->isComplex();
321   break;
322   }
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 /*--------------------------------------------------------------------------*/