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