1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
4  * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16 
17 #include "ScilabToJava.hxx"
18 #ifdef _MSC_VER
19 #pragma warning(disable: 4800)
20 #endif
21 
22 namespace org_modules_types
23 {
24 
25 int ScilabToJava::refreshId = -1;
26 
sendAllListenedVariables()27 void ScilabToJava::sendAllListenedVariables()
28 {
29     if (refreshId == -1)
30     {
31         refreshId = ScilabVariablesRefresh::getScilabVariablesRefreshId(getScilabJavaVM());
32     }
33 
34     char ** vars = ScilabVariables::getAllListenedVariables(getScilabJavaVM());
35     while (*vars)
36     {
37         sendVariable(std::string(*vars), true, refreshId);
38         delete[] *vars;
39         vars++;
40     }
41     delete[] vars;
42 }
43 
sendVariableAsReference(const std::string & name,int handlerId)44 bool ScilabToJava::sendVariableAsReference(const std::string & name, int handlerId)
45 {
46     int * addr = 0;
47     SciErr err;
48 
49     if (!isNamedVarExist(0, name.c_str()))
50     {
51         return false;
52     }
53 
54     err = getVarAddressFromName(0, name.c_str(), &addr);
55     if (err.iErr)
56     {
57         printError(&err, 0);
58         return false;
59     }
60 
61     std::vector<int> indexes;
62     return sendVariable(name, indexes, addr, false, true, handlerId, 0);
63 }
64 
sendVariable(const std::string & name,bool swaped,int handlerId)65 bool ScilabToJava::sendVariable(const std::string & name, bool swaped, int handlerId)
66 {
67     int * addr = 0;
68     SciErr err;
69 
70     if (!isNamedVarExist(0, name.c_str()))
71     {
72         return false;
73     }
74 
75     err = getVarAddressFromName(0, name.c_str(), &addr);
76     if (err.iErr)
77     {
78         printError(&err, 0);
79         return false;
80     }
81 
82     std::vector<int> indexes;
83     return sendVariable(name, indexes, addr, swaped, false, handlerId, 0);
84 }
85 
sendVariable(const std::string & name,int * addr,bool swaped,int handlerId,void * pvApiCtx)86 bool ScilabToJava::sendVariable(const std::string & name, int * addr, bool swaped, int handlerId, void * pvApiCtx)
87 {
88     std::vector<int> indexes;
89     return sendVariable(name, indexes, addr, swaped, false, handlerId, pvApiCtx);
90 }
91 
sendVariable(const std::string & name,std::vector<int> & indexes,int * addr,bool swaped,bool byref,int handlerId,void * pvApiCtx)92 bool ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx)
93 {
94     SciErr err;
95 
96     int type = 0;
97     int row = 0;
98     int col = 0;
99     int prec = 0;
100 
101     // Double
102     double * real = 0;
103     double * img = 0;
104 
105     // Integers
106     char * integers8 = 0;
107     unsigned char * uintegers8 = 0;
108     short * integers16 = 0;
109     unsigned short * uintegers16 = 0;
110     int * integers32 = 0;
111     unsigned int * uintegers32 = 0;
112 
113     // Boolean
114     int * booleans = 0;
115 
116 #ifdef __SCILAB_INT64__
117     long long * integers64 = 0;
118     unsigned long long * uintegers64 = 0;
119 #endif
120 
121     // Strings
122     char ** strings = 0;
123 
124     // Sparse
125     int nbItem;
126     int * nbItemRow = 0;
127     int * colPos = 0;
128 
129     // Polynomial
130     double ** re = 0;
131     double ** im = 0;
132     int rc;
133     int * nbCoeffs = 0;
134     char varName[5];
135     int varNameLen = 0;
136 
137     // Lists
138     char listtype = 0;
139     int nbItems = 0;
140 
141     err = getVarType(pvApiCtx, addr, &type);
142     if (err.iErr)
143     {
144         printError(&err, 0);
145         return false;
146     }
147 
148     switch (type)
149     {
150         case sci_matrix :
151             if (isVarComplex(pvApiCtx, addr))
152             {
153                 err = getComplexMatrixOfDouble(pvApiCtx, addr, &row, &col, &real, &img);
154                 if (err.iErr)
155                 {
156                     printError(&err, 0);
157                     return false;
158                 }
159 
160                 sendVariable<double>(name, indexes, row, col, real, img, swaped, byref, handlerId);
161             }
162             else
163             {
164                 err = getMatrixOfDouble(pvApiCtx, addr, &row, &col, &real);
165                 if (err.iErr)
166                 {
167                     printError(&err, 0);
168                     return false;
169                 }
170 
171                 sendVariable<double>(name, indexes, row, col, real, swaped, byref, handlerId);
172             }
173             break;
174         case sci_ints :
175             err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec);
176             if (err.iErr)
177             {
178                 printError(&err, 0);
179                 return false;
180             }
181 
182             switch (prec)
183             {
184                 case SCI_INT8 :
185                     err = getMatrixOfInteger8(pvApiCtx, addr, &row, &col, &integers8);
186                     if (err.iErr)
187                     {
188                         printError(&err, 0);
189                         return false;
190                     }
191 
192                     sendVariable<byte>(name, indexes, row, col, (byte *)integers8, swaped, byref, handlerId);
193                     break;
194                 case SCI_UINT8 :
195                     err = getMatrixOfUnsignedInteger8(pvApiCtx, addr, &row, &col, &uintegers8);
196                     if (err.iErr)
197                     {
198                         printError(&err, 0);
199                         return false;
200                     }
201 
202                     sendUnsignedVariable<byte>(name, indexes, row, col, (byte *)uintegers8, swaped, byref, handlerId);
203                     break;
204                 case SCI_INT16 :
205                     err = getMatrixOfInteger16(pvApiCtx, addr, &row, &col, &integers16);
206                     if (err.iErr)
207                     {
208                         printError(&err, 0);
209                         return false;
210                     }
211 
212                     sendVariable<short>(name, indexes, row, col, integers16, swaped, byref, handlerId);
213                     break;
214                 case SCI_UINT16 :
215                     err = getMatrixOfUnsignedInteger16(pvApiCtx, addr, &row, &col, &uintegers16);
216                     if (err.iErr)
217                     {
218                         printError(&err, 0);
219                         return false;
220                     }
221 
222                     sendUnsignedVariable<short>(name, indexes, row, col, (short *)uintegers16, swaped, byref, handlerId);
223                     break;
224                 case SCI_INT32 :
225                     err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &integers32);
226                     if (err.iErr)
227                     {
228                         printError(&err, 0);
229                         return false;
230                     }
231 
232                     sendVariable<int>(name, indexes, row, col, integers32, swaped, byref, handlerId);
233                     break;
234                 case SCI_UINT32 :
235                     err = getMatrixOfUnsignedInteger32(pvApiCtx, addr, &row, &col, &uintegers32);
236                     if (err.iErr)
237                     {
238                         printError(&err, 0);
239                         return false;
240                     }
241 
242                     sendUnsignedVariable<int>(name, indexes, row, col, (int *)uintegers32, swaped, byref, handlerId);
243                     break;
244 
245 #ifdef __SCILAB_INT64__
246                 case SCI_INT64 :
247                     err = getMatrixOfInteger64(pvApiCtx, addr, &row, &col, &integers64);
248                     if (err.iErr)
249                     {
250                         printError(&err, 0);
251                         return false;
252                     }
253 
254                     sendVariable<long long>(name, indexes, row, col, integers64, swaped, byref, handlerId);
255                     break;
256                 case SCI_UINT64 :
257                     err = getMatrixOfUnsignedInteger64(pvApiCtx, addr, &row, &col, &uintegers64);
258                     if (err.iErr)
259                     {
260                         printError(&err, 0);
261                         return false;
262                     }
263 
264                     sendUnsignedVariable<long long>(name, indexes, row, col, (long long *)uintegers64, swaped, byref, handlerId);
265                     break;
266 #endif
267                 default :
268                     return false;
269             }
270             break;
271         case sci_strings :
272             if (getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &strings))
273             {
274                 return false;
275             }
276 
277             sendStringVariable(name, indexes, row, col, strings, swaped, false, handlerId);
278             freeAllocatedMatrixOfString(row, col, strings);
279             break;
280         case sci_boolean :
281             err = getMatrixOfBoolean(pvApiCtx, addr, &row, &col, &booleans);
282             if (err.iErr)
283             {
284                 printError(&err, 0);
285                 return false;
286             }
287 
288             sendConvertedBooleanVariable(name, indexes, row, col, booleans, swaped, byref, handlerId);
289             break;
290         case sci_sparse :
291             if (isVarComplex(pvApiCtx, addr))
292             {
293                 err = getComplexSparseMatrix(pvApiCtx, addr, &row, &col, &nbItem, &nbItemRow, &colPos, &real, &img);
294                 if (err.iErr)
295                 {
296                     printError(&err, 0);
297                     return 0;
298                 }
299 
300                 sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, img, false, handlerId);
301             }
302             else
303             {
304                 err = getSparseMatrix(pvApiCtx, addr, &row, &col, &nbItem, &nbItemRow, &colPos, &real);
305                 if (err.iErr)
306                 {
307                     printError(&err, 0);
308                     return 0;
309                 }
310 
311                 sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, false, handlerId);
312             }
313             break;
314         case sci_boolean_sparse :
315             err = getBooleanSparseMatrix(pvApiCtx, addr, &row, &col, &nbItem, &nbItemRow, &colPos);
316             if (err.iErr)
317             {
318                 printError(&err, 0);
319                 return 0;
320             }
321 
322             sendBooleanSparseVariable(name, indexes, nbItem, nbItemRow, colPos, row, col, false, handlerId);
323             delete[] integers8;
324             break;
325         case sci_poly :
326             err = getPolyVariableName(pvApiCtx, addr, varName, &varNameLen);
327             if (err.iErr)
328             {
329                 printError(&err, 0);
330                 return false;
331             }
332 
333             if (isVarComplex(pvApiCtx, addr))
334             {
335                 getComplexMatrixOfPoly(pvApiCtx, addr, &row, &col, 0, 0, 0);
336                 rc = row * col;
337                 nbCoeffs = new int[rc];
338 
339                 getComplexMatrixOfPoly(pvApiCtx, addr, &row, &col, nbCoeffs, 0, 0);
340                 re = new double*[rc];
341                 for (int i = 0; i < rc; i++)
342                 {
343                     re[i] = new double[nbCoeffs[i]];
344                 }
345 
346                 im = new double*[rc];
347                 for (int i = 0; i < rc; i++)
348                 {
349                     im[i] = new double[nbCoeffs[i]];
350                 }
351                 err = getComplexMatrixOfPoly(pvApiCtx, addr, &row, &col, nbCoeffs, re, im);
352                 if (err.iErr)
353                 {
354                     for (int i = 0; i < rc; i++)
355                     {
356                         delete[] im[i];
357                         delete[] re[i];
358                     }
359                     delete[] im;
360                     delete[] re;
361                     delete[] nbCoeffs;
362                     printError(&err, 0);
363                     return false;
364                 }
365 
366                 sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, im, swaped, false, handlerId);
367                 for (int i = 0; i < rc; i++)
368                 {
369                     delete[] im[i];
370                 }
371                 delete[] im;
372             }
373             else
374             {
375                 getMatrixOfPoly(pvApiCtx, addr, &row, &col, 0, 0);
376                 rc = row * col;
377                 nbCoeffs = new int[rc];
378 
379                 getMatrixOfPoly(pvApiCtx, addr, &row, &col, nbCoeffs, 0);
380                 re = new double*[rc];
381                 for (int i = 0; i < rc; i++)
382                 {
383                     re[i] = new double[nbCoeffs[i]];
384                 }
385 
386                 err = getMatrixOfPoly(pvApiCtx, addr, &row, &col, nbCoeffs, re);
387                 if (err.iErr)
388                 {
389                     for (int i = 0; i < rc; i++)
390                     {
391                         delete[] re[i];
392                     }
393                     delete[] re;
394                     delete[] nbCoeffs;
395                     printError(&err, 0);
396                     return false;
397                 }
398 
399                 sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, swaped, false, handlerId);
400             }
401             for (int i = 0; i < rc; i++)
402             {
403                 delete[] re[i];
404             }
405             delete[] re;
406             delete[] nbCoeffs;
407 
408             break;
409         case sci_list :
410             listtype = 'l';
411             break;
412         case sci_mlist :
413             listtype = 'm';
414             break;
415         case sci_tlist :
416             listtype = 't';
417             break;
418         default :
419             return false;
420     }
421 
422     if (listtype)
423     {
424         err = getListItemNumber(pvApiCtx, addr, &nbItems);
425         if (err.iErr)
426         {
427             printError(&err, 0);
428             return false;
429         }
430 
431         sendVariable(name, nbItems, indexes, listtype, false, handlerId);
432         bool b = sendItems(name, nbItems, indexes, addr, swaped, byref, handlerId, pvApiCtx);
433         closeList(indexes, handlerId);
434         return b;
435     }
436 
437     return true;
438 }
439 
sendItems(const std::string & name,const int nbItems,std::vector<int> & indexes,int * addr,bool swaped,bool byref,int handlerId,void * pvApiCtx)440 inline bool ScilabToJava::sendItems(const std::string & name, const int nbItems, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx)
441 {
442     int * itemAddr = 0;
443     SciErr err;
444 
445     for (int i = 1; i <= nbItems; i++)
446     {
447         err = getListItemAddress(pvApiCtx, addr, i, &itemAddr);
448         if (err.iErr)
449         {
450             printError(&err, 0);
451             return false;
452         }
453 
454         indexes.push_back(i);
455 
456         if (!sendVariable(name, indexes, itemAddr, swaped, byref, handlerId, pvApiCtx))
457         {
458             return false;
459         }
460 
461         indexes.pop_back();
462     }
463 
464     return true;
465 }
466 
getIndexesPointer(std::vector<int> & indexes)467 inline int * ScilabToJava::getIndexesPointer(std::vector<int> & indexes)
468 {
469     if (indexes.size() == 0)
470     {
471         return 0;
472     }
473 
474     return &(indexes[0]);
475 }
476 
477 // Lists
478 // byref is useless
sendVariable(const std::string & name,const int nbItems,std::vector<int> & indexes,char type,bool byref,int handlerId)479 inline void ScilabToJava::sendVariable(const std::string & name, const int nbItems, std::vector<int> & indexes, char type, bool byref, int handlerId)
480 {
481     ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), nbItems, getIndexesPointer(indexes), (int)indexes.size(), type, handlerId);
482 }
483 
closeList(std::vector<int> & indexes,int handlerId)484 inline void ScilabToJava::closeList(std::vector<int> & indexes, int handlerId)
485 {
486     ScilabVariables::closeList(getScilabJavaVM(), getIndexesPointer(indexes), (int)indexes.size(), handlerId);
487 }
488 
489 // Sparse
490 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,int nbItem,int * nbItemRow,int * colPos,int row,int col,T * data,bool byref,int handlerId)491 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * data, bool byref, int handlerId)
492 {
493     if (byref)
494     {
495         ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, data, nbItem, handlerId);
496     }
497     else
498     {
499         int * colPos_ = new int[nbItem];
500         for (int i = 0; i < nbItem; i++)
501         {
502             colPos_[i] = colPos[i] - 1;
503         }
504         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, data, nbItem, handlerId);
505         delete[] colPos_;
506     }
507 }
508 
509 // Double, ...
510 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,int row,int col,T * data,bool swaped,bool byRef,int handlerId)511 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byRef, int handlerId)
512 {
513     if (byRef)
514     {
515         ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
516     }
517     else
518     {
519         T ** addr = getMatrix<T>(row, col, data, swaped);
520         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
521         deleteMatrix<T>(addr, swaped);
522     }
523 }
524 
525 // String
sendStringVariable(const std::string & name,std::vector<int> & indexes,int row,int col,char ** data,bool swaped,bool byRef,int handlerId)526 inline void ScilabToJava::sendStringVariable(const std::string & name, std::vector<int> & indexes, int row, int col, char ** data, bool swaped, bool byRef, int handlerId)
527 {
528     char *** addr = getMatrix<char *>(row, col, data, swaped);
529     ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
530     deleteMatrix<char *>(addr, swaped);
531 }
532 
533 // Boolean sparse
sendBooleanSparseVariable(const std::string & name,std::vector<int> & indexes,int nbItem,int * nbItemRow,int * colPos,int row,int col,bool byref,int handlerId)534 inline void ScilabToJava::sendBooleanSparseVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, bool byref, int handlerId)
535 {
536     if (byref)
537     {
538         ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, handlerId);
539     }
540     else
541     {
542         int * colPos_ = new int[nbItem];
543         for (int i = 0; i < nbItem; i++)
544         {
545             colPos_[i] = colPos[i] - 1;
546         }
547         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, handlerId);
548         delete[] colPos_;
549     }
550 }
551 
552 // uint* matrix with a bigger storage
553 // TODO : change the Java wrapping
554 template<typename T, typename U>
sendUnsignedVariableWithCast(const std::string & name,std::vector<int> & indexes,int row,int col,U * data,bool swaped,int handlerId)555 inline void ScilabToJava::sendUnsignedVariableWithCast(const std::string & name, std::vector<int> & indexes, int row, int col, U * data, bool swaped, int handlerId)
556 {
557     T ** addr = getConvertedMatrix<T, U>(row, col, data, swaped);
558     ScilabVariables::sendUnsignedData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
559     deleteMatrix<T>(addr, swaped);
560 }
561 
562 // uint*
563 template<typename T>
sendUnsignedVariable(const std::string & name,std::vector<int> & indexes,int row,int col,T * data,bool swaped,bool byref,int handlerId)564 inline void ScilabToJava::sendUnsignedVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byref, int handlerId)
565 {
566     if (byref)
567     {
568         ScilabVariables::sendUnsignedDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
569     }
570     else
571     {
572         T ** addr = getMatrix<T>(row, col, data, swaped);
573         ScilabVariables::sendUnsignedData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
574         deleteMatrix<T>(addr, swaped);
575     }
576 }
577 
578 // Boolean
sendConvertedBooleanVariable(const std::string & name,std::vector<int> & indexes,int row,int col,int * data,bool swaped,bool byref,int handlerId)579 inline void ScilabToJava::sendConvertedBooleanVariable(const std::string & name, std::vector<int> & indexes, int row, int col, int * data, bool swaped, bool byref, int handlerId)
580 {
581     if (byref)
582     {
583         ScilabVariables::sendBooleanDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
584     }
585     else
586     {
587         bool ** addr = getConvertedMatrix<bool, int>(row, col, data, swaped);
588         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
589         deleteMatrix<bool>(addr, swaped);
590     }
591 }
592 
593 // Complex sparse
594 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,int nbItem,int * nbItemRow,int * colPos,int row,int col,T * real,T * img,bool byref,int handlerId)595 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * real, T * img, bool byref, int handlerId)
596 {
597     if (byref)
598     {
599         ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, real, nbItem, img, nbItem, handlerId);
600     }
601     else
602     {
603         int * colPos_ = new int[nbItem];
604         for (int i = 0; i < nbItem; i++)
605         {
606             colPos_[i] = colPos[i] - 1;
607         }
608         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, real, nbItem, img, nbItem, handlerId);
609         delete[] colPos_;
610     }
611 }
612 
613 // Complex
614 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,int row,int col,T * real,T * img,bool swaped,bool byref,int handlerId)615 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * real, T * img, bool swaped, bool byref, int handlerId)
616 {
617     if (byref)
618     {
619         ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), real, row * col, img, row * col, row, col, handlerId);
620     }
621     else
622     {
623         T ** re = getMatrix<T>(row, col, real, swaped);
624         T ** im = getMatrix<T>(row, col, img, swaped);
625         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), re, row, col, im, row, col, swaped, handlerId);
626         deleteMatrix<T>(re, swaped);
627         deleteMatrix<T>(im, swaped);
628     }
629 }
630 
631 // Polynomial
632 // byref is useless
633 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,const char * varName,int row,int col,int * nbcoeff,T ** data,bool swaped,bool byref,int handlerId)634 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** data, bool swaped, bool byref, int handlerId)
635 {
636     T *** addr = getMatrix<T*>(row, col, data, swaped);
637     int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
638     ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, addr, row, col, nbc, swaped, handlerId);
639     deleteMatrix<T*>(addr, swaped);
640     deleteMatrix<int>(nbc, swaped);
641 }
642 
643 // Complex polynomial
644 // byref is useless
645 template<typename T>
sendVariable(const std::string & name,std::vector<int> & indexes,const char * varName,int row,int col,int * nbcoeff,T ** real,T ** img,bool swaped,bool byref,int handlerId)646 inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** real, T ** img, bool swaped, bool byref, int handlerId)
647 {
648     T *** re = getMatrix<T*>(row, col, real, swaped);
649     T *** im = getMatrix<T*>(row, col, img, swaped);
650     int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
651     ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, re, im, row, col, nbc, swaped, handlerId);
652     deleteMatrix<T*>(re, swaped);
653     deleteMatrix<T*>(im, swaped);
654     deleteMatrix<int>(nbc, swaped);
655 }
656 
657 template<typename T>
getMatrix(int row,int col,T * data,bool swaped)658 inline T ** ScilabToJava::getMatrix(int row, int col, T * data, bool swaped)
659 {
660     T ** addr = 0;
661 
662     if (row && col)
663     {
664         if (swaped)
665         {
666             T * d = new T[row * col];
667             for (int i = 0; i < row; i++)
668             {
669                 for (int j = 0; j < col; j++)
670                 {
671                     d[i * col + j] = data[j * row + i];
672                 }
673             }
674             addr = convertMatrix<T>(row, col, d);
675         }
676         else
677         {
678             addr = convertMatrix<T>(col, row, data);
679         }
680     }
681 
682     return addr;
683 }
684 
685 template<typename T, typename U>
getConvertedMatrix(int row,int col,U * data,bool swaped)686 inline T ** ScilabToJava::getConvertedMatrix(int row, int col, U * data, bool swaped)
687 {
688     T ** addr = 0;
689 
690     if (row && col)
691     {
692         int rc = row * col;
693         T * d = new T[rc];
694         if (swaped)
695         {
696             for (int i = 0; i < row; i++)
697             {
698                 for (int j = 0; j < col; j++)
699                 {
700                     d[i * col + j] = static_cast<T>(data[j * row + i]);
701                 }
702             }
703             addr = convertMatrix<T>(row, col, d);
704         }
705         else
706         {
707             for (int i = 0; i < rc; i++)
708             {
709                 d[i] = static_cast<T>(data[i]);
710             }
711             addr = convertMatrix<T>(col, row, d);
712         }
713     }
714 
715     return addr;
716 }
717 
718 template<typename T>
convertMatrix(int row,int col,T * data)719 inline T ** ScilabToJava::convertMatrix(int row, int col, T * data)
720 {
721     T ** addr = 0;
722 
723     if (row && col)
724     {
725         addr = new T*[row];
726         *addr = data;
727         for (int i = 1; i < row; i++)
728         {
729             addr[i] = addr[i - 1] + col;
730         }
731     }
732 
733     return addr;
734 }
735 
736 template<typename T>
deleteMatrix(T ** data,bool swaped)737 inline void ScilabToJava::deleteMatrix(T ** data, bool swaped)
738 {
739     if (data)
740     {
741         if (swaped && *data)
742         {
743             delete[] *data;
744         }
745         delete[] data;
746     }
747 }
748 }
749 
getScilabVariable(const char * variableName,int swapRowCol,int handlerId)750 void getScilabVariable(const char * variableName, int swapRowCol, int handlerId)
751 {
752     org_modules_types::ScilabToJava::sendVariable(std::string(variableName), swapRowCol != 0, handlerId);
753 }
754 
getScilabVariableAsReference(const char * variableName,int handlerId)755 void getScilabVariableAsReference(const char * variableName, int handlerId)
756 {
757     org_modules_types::ScilabToJava::sendVariableAsReference(std::string(variableName), handlerId);
758 }
759