abbfea3ca7e3b18bff2229e8dc86f89d4c0995fc
[scilab.git] / scilab / modules / external_objects_java / src / cpp / ScilabJavaEnvironmentWrapper.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
4  * Copyright (C) 2013 - Scilab Enterprises - Sylvestre Ledru
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 #ifdef _MSC_VER
15 #include "windows.h"
16 #endif
17
18 #include "ScilabJavaEnvironmentWrapper.hxx"
19
20 extern "C" {
21 #include "getScilabJavaVM.h"
22 }
23
24 namespace org_scilab_modules_external_objects_java
25 {
26
27 VariableType ScilabJavaEnvironmentWrapper::isunwrappable(int id) const
28 {
29     JavaVM * vm = getScilabJavaVM();
30     int type = ScilabJavaObject::isUnwrappable(vm, id);
31
32     return (VariableType)type;
33 }
34
35 int ScilabJavaEnvironmentWrapper::wrap(double * x, const bool isRef) const
36 {
37     JavaVM * vm = getScilabJavaVM();
38     if (isRef)
39     {
40         return wrapAsDirectBuffer(vm, x, 1);
41     }
42
43     return wrap(vm, x);
44 }
45
46 int ScilabJavaEnvironmentWrapper::wrap(double * x, int xSize, const bool isRef) const
47 {
48     JavaVM * vm = getScilabJavaVM();
49     if (isRef)
50     {
51         return wrapAsDirectBuffer(vm, x, xSize);
52     }
53
54     return wrap(vm, x, xSize);
55 }
56
57 int ScilabJavaEnvironmentWrapper::wrap(double * x, int xSize, int xSizeCol, const bool isRef) const
58 {
59     JavaVM * vm = getScilabJavaVM();
60     if (isRef)
61     {
62         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
63     }
64
65     return wrap(vm, x, xSize, xSizeCol);
66 }
67
68 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, const bool isRef) const
69 {
70     //if (helper.getWrapSingleWithNumpy())
71     //{
72     //    return wrapData(re, im, 1, isRef);
73     //}
74     //else
75     //{
76     //    return wrapData(re, im, isRef);
77     //}
78     return 0;
79 }
80
81 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, int xSize, const bool isRef) const
82 {
83     //    return wrapData(re, im, xSize, isRef);
84     return 0;
85 }
86
87 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, int xSize, int xSizeCol, const bool isRef) const
88 {
89     //    return wrapData(re, im, xSize, xSizeCol, isRef);
90     return 0;
91 }
92
93 int ScilabJavaEnvironmentWrapper::wrap(char * x, const bool isRef) const
94 {
95     JavaVM * vm = getScilabJavaVM();
96     if (isRef)
97     {
98         return wrapAsDirectBuffer(vm, x, 1);
99     }
100
101     return wrap(vm, (byte *)x);
102 }
103
104 int ScilabJavaEnvironmentWrapper::wrap(char * x, int xSize, const bool isRef) const
105 {
106     JavaVM * vm = getScilabJavaVM();
107     if (isRef)
108     {
109         return wrapAsDirectBuffer(vm, x, xSize);
110     }
111
112     return wrap(vm, (byte *)x, xSize);
113 }
114
115 int ScilabJavaEnvironmentWrapper::wrap(char * x, int xSize, int xSizeCol, const bool isRef) const
116 {
117     JavaVM * vm = getScilabJavaVM();
118     if (isRef)
119     {
120         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
121     }
122
123     return wrap(vm, (byte *)x, xSize, xSizeCol);
124 }
125
126 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, const bool isRef) const
127 {
128     JavaVM * vm = getScilabJavaVM();
129     if (isRef)
130     {
131         return wrapAsDirectBuffer(vm, (char *)x, 1);
132     }
133
134     return wrap(vm, (byte *)x);
135 }
136
137 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, int xSize, const bool isRef) const
138 {
139     JavaVM * vm = getScilabJavaVM();
140     if (isRef)
141     {
142         return wrapAsDirectBuffer(vm, (char *)x, xSize);
143     }
144
145     return wrap(vm, (byte *)x, xSize);
146 }
147
148 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, int xSize, int xSizeCol, const bool isRef) const
149 {
150     JavaVM * vm = getScilabJavaVM();
151     if (isRef)
152     {
153         return wrapAsDirectBuffer(vm, (char *)x, xSize * xSizeCol);
154     }
155
156     return wrap(vm, (byte *)x, xSize, xSizeCol);
157 }
158
159 int ScilabJavaEnvironmentWrapper::wrap(short * x, const bool isRef) const
160 {
161     JavaVM * vm = getScilabJavaVM();
162     if (isRef)
163     {
164         return wrapAsDirectBuffer(vm, x, 1);
165     }
166
167     return wrap(vm, x);
168 }
169
170 int ScilabJavaEnvironmentWrapper::wrap(short * x, int xSize, const bool isRef) const
171 {
172     JavaVM * vm = getScilabJavaVM();
173     if (isRef)
174     {
175         return wrapAsDirectBuffer(vm, x, xSize);
176     }
177
178     return wrap(vm, x, xSize);
179 }
180
181 int ScilabJavaEnvironmentWrapper::wrap(short * x, int xSize, int xSizeCol, const bool isRef) const
182 {
183     JavaVM * vm = getScilabJavaVM();
184     if (isRef)
185     {
186         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
187     }
188
189     return wrap(vm, x, xSize, xSizeCol);
190 }
191
192 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, const bool isRef) const
193 {
194     JavaVM * vm = getScilabJavaVM();
195     if (isRef)
196     {
197         return wrapAsDirectBuffer(vm, (short *)x, 1);
198     }
199
200     return wrap(vm, (short *)x);
201 }
202
203 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, int xSize, const bool isRef) const
204 {
205     JavaVM * vm = getScilabJavaVM();
206     if (isRef)
207     {
208         return wrapAsDirectBuffer(vm, (short *)x, xSize);
209     }
210
211     return wrap(vm, (short *)x, xSize);
212 }
213
214 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, int xSize, int xSizeCol, const bool isRef) const
215 {
216     JavaVM * vm = getScilabJavaVM();
217     if (isRef)
218     {
219         return wrapAsDirectBuffer(vm, (short *)x, xSize * xSizeCol);
220     }
221
222     return wrap(vm, (short *)x, xSize, xSizeCol);
223 }
224
225 int ScilabJavaEnvironmentWrapper::wrap(int * x, const bool isRef) const
226 {
227     JavaVM * vm = getScilabJavaVM();
228     if (isRef)
229     {
230         return wrapAsDirectBuffer(vm, x, 1);
231     }
232
233     return wrap(vm, x);
234 }
235
236 int ScilabJavaEnvironmentWrapper::wrap(int * x, int xSize, const bool isRef) const
237 {
238     JavaVM * vm = getScilabJavaVM();
239     if (isRef)
240     {
241         return wrapAsDirectBuffer(vm, x, xSize);
242     }
243
244     return wrap(vm, x, xSize);
245 }
246
247 int ScilabJavaEnvironmentWrapper::wrap(int * x, int xSize, int xSizeCol, const bool isRef) const
248 {
249     JavaVM * vm = getScilabJavaVM();
250     if (isRef)
251     {
252         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
253     }
254
255     return wrap(vm, x, xSize, xSizeCol);
256 }
257
258 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, const bool isRef) const
259 {
260     JavaVM * vm = getScilabJavaVM();
261     if (isRef)
262     {
263         return wrapAsDirectBuffer(vm, (int *)x, 1);
264     }
265
266     return wrap(vm, (int *)x);
267 }
268
269 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, int xSize, const bool isRef) const
270 {
271     JavaVM * vm = getScilabJavaVM();
272     if (isRef)
273     {
274         return wrapAsDirectBuffer(vm, (int *)x, xSize);
275     }
276
277     return wrap(vm, (int *)x, xSize);
278 }
279
280 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, int xSize, int xSizeCol, const bool isRef) const
281 {
282     JavaVM * vm = getScilabJavaVM();
283     if (isRef)
284     {
285         return wrapAsDirectBuffer(vm, (int *)x, xSize * xSizeCol);
286     }
287
288     return wrap(vm, (int *)x, xSize, xSizeCol);
289 }
290
291 #ifdef __SCILAB_INT64__
292
293 int ScilabJavaEnvironmentWrapper::wrap(long long * x, const bool isRef) const
294 {
295     JavaVM * vm = getScilabJavaVM();
296     if (isRef)
297     {
298         return wrapAsDirectBuffer(vm, x, 1);
299     }
300
301     return wrap(vm, x);
302 }
303
304 int ScilabJavaEnvironmentWrapper::wrap(long long * x, int xSize, const bool isRef) const
305 {
306     JavaVM * vm = getScilabJavaVM();
307     if (isRef)
308     {
309         return wrapAsDirectBuffer(vm, x, xSize);
310     }
311
312     return wrap(vm, x, xSize);
313 }
314
315 int ScilabJavaEnvironmentWrapper::wrap(long long * x, int xSize, int xSizeCol, const bool isRef) const
316 {
317     JavaVM * vm = getScilabJavaVM();
318     if (isRef)
319     {
320         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
321     }
322
323     return wrap(vm, x, xSize, xSizeCol);
324 }
325
326 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, const bool isRef) const
327 {
328     JavaVM * vm = getScilabJavaVM();
329     if (isRef)
330     {
331         return wrapAsDirectBuffer(vm, (long long *)x, 1);
332     }
333
334     return wrap(vm, (long long *)x);
335 }
336
337 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, int xSize, const bool isRef) const
338 {
339     JavaVM * vm = getScilabJavaVM();
340     if (isRef)
341     {
342         return wrapAsDirectBuffer(vm, (long long *)x, xSize);
343     }
344
345     return wrap(vm, (long long *)x, xSize);
346 }
347
348 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, int xSize, int xSizeCol, const bool isRef) const
349 {
350     JavaVM * vm = getScilabJavaVM();
351     if (isRef)
352     {
353         return wrapAsDirectBuffer(vm, (long long *)x, xSize * xSizeCol);
354     }
355
356     return wrap(vm, (long long *)x, xSize, xSizeCol);
357 }
358
359 #endif
360
361 int ScilabJavaEnvironmentWrapper::wrap(char ** x, const bool isRef) const
362 {
363     JavaVM * vm = getScilabJavaVM();
364     return wrap(vm, (char const**)x);
365 }
366
367 int ScilabJavaEnvironmentWrapper::wrap(char ** x, int xSize, const bool isRef) const
368 {
369     JavaVM * vm = getScilabJavaVM();
370     return wrap(vm, (char const**)x, xSize);
371 }
372
373 int ScilabJavaEnvironmentWrapper::wrap(char ** x, int xSize, int xSizeCol, const bool isRef) const
374 {
375     JavaVM * vm = getScilabJavaVM();
376     return wrap(vm, (char const**)x, xSize, xSizeCol);
377 }
378
379 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, const bool isRef) const
380 {
381     JavaVM * vm = getScilabJavaVM();
382     if (isRef)
383     {
384         return wrapAsDirectBuffer(vm, x, 1);
385     }
386
387     return wrap<int, bool>(vm, x);
388 }
389
390 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, int xSize, const bool isRef) const
391 {
392     JavaVM * vm = getScilabJavaVM();
393     if (isRef)
394     {
395         return wrapAsDirectBuffer(vm, x, xSize);
396     }
397
398     return wrap<int, bool>(vm, x, xSize);
399 }
400
401 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, int xSize, int xSizeCol, const bool isRef) const
402 {
403     JavaVM * vm = getScilabJavaVM();
404     if (isRef)
405     {
406         return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
407     }
408
409     return wrap<int, bool>(vm, x, xSize, xSizeCol);
410 }
411
412 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, const bool isRef) const
413 {
414     JavaVM * vm = getScilabJavaVM();
415     return wrap<double, float>(vm, x);
416 }
417
418 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, int xSize, const bool isRef) const
419 {
420     JavaVM * vm = getScilabJavaVM();
421     return wrap<double, float>(vm, x, xSize);
422 }
423
424 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, int xSize, int xSizeCol, const bool isRef) const
425 {
426     JavaVM * vm = getScilabJavaVM();
427     return wrap<double, float>(vm, x, xSize, xSizeCol);
428 }
429
430 void ScilabJavaEnvironmentWrapper::unwrapdouble(int id, const ScilabDoubleStackAllocator & allocator) const
431 {
432     JavaVM * vm = getScilabJavaVM();
433     unwrapSingle<jdouble, double>(vm, id, allocator);
434 }
435
436 void ScilabJavaEnvironmentWrapper::unwraprowdouble(int id, const ScilabDoubleStackAllocator & allocator) const
437 {
438     JavaVM * vm = getScilabJavaVM();
439     unwrapRow<jdouble, double>(vm, id, allocator);
440 }
441
442 void ScilabJavaEnvironmentWrapper::unwrapmatdouble(int id, const ScilabDoubleStackAllocator & allocator) const
443 {
444     JavaVM * vm = getScilabJavaVM();
445     unwrapMat<jdouble, double>(vm, id, allocator);
446 }
447
448 void ScilabJavaEnvironmentWrapper::unwrapchar(int id, const ScilabCharStackAllocator & allocator) const
449 {
450     JavaVM * vm = getScilabJavaVM();
451     unwrapSingle<jbyte, char>(vm, id, allocator);
452 }
453
454 void ScilabJavaEnvironmentWrapper::unwraprowchar(int id, const ScilabCharStackAllocator & allocator) const
455 {
456     JavaVM * vm = getScilabJavaVM();
457     unwrapRow<jbyte, char>(vm, id, allocator);
458 }
459
460 void ScilabJavaEnvironmentWrapper::unwrapmatchar(int id, const ScilabCharStackAllocator & allocator) const
461 {
462     JavaVM * vm = getScilabJavaVM();
463     unwrapMat<jbyte, char>(vm, id, allocator);
464 }
465
466 void ScilabJavaEnvironmentWrapper::unwrapuchar(int id, const ScilabUCharStackAllocator & allocator) const
467 {
468     // Not called
469 }
470
471 void ScilabJavaEnvironmentWrapper::unwraprowuchar(int id, const ScilabUCharStackAllocator & allocator) const
472 {
473     // Not called
474 }
475
476 void ScilabJavaEnvironmentWrapper::unwrapmatuchar(int id, const ScilabUCharStackAllocator & allocator) const
477 {
478     // Not called
479 }
480
481 void ScilabJavaEnvironmentWrapper::unwrapshort(int id, const ScilabShortStackAllocator & allocator) const
482 {
483     JavaVM * vm = getScilabJavaVM();
484     unwrapSingle<jshort, short>(vm, id, allocator);
485 }
486
487 void ScilabJavaEnvironmentWrapper::unwraprowshort(int id, const ScilabShortStackAllocator & allocator) const
488 {
489     JavaVM * vm = getScilabJavaVM();
490     unwrapRow<jshort, short>(vm, id, allocator);
491 }
492
493 void ScilabJavaEnvironmentWrapper::unwrapmatshort(int id, const ScilabShortStackAllocator & allocator) const
494 {
495     JavaVM * vm = getScilabJavaVM();
496     unwrapMat<jshort, short>(vm, id, allocator);
497 }
498
499 void ScilabJavaEnvironmentWrapper::unwrapushort(int id, const ScilabUShortStackAllocator & allocator) const
500 {
501     // Not called
502 }
503
504 void ScilabJavaEnvironmentWrapper::unwraprowushort(int id, const ScilabUShortStackAllocator & allocator) const
505 {
506     // Not called
507 }
508
509 void ScilabJavaEnvironmentWrapper::unwrapmatushort(int id, const ScilabUShortStackAllocator & allocator) const
510 {
511     // Not called
512 }
513
514 void ScilabJavaEnvironmentWrapper::unwrapint(int id, const ScilabIntStackAllocator & allocator) const
515 {
516     JavaVM * vm = getScilabJavaVM();
517     unwrapSingle<jint, int>(vm, id, allocator);
518 }
519
520 void ScilabJavaEnvironmentWrapper::unwraprowint(int id, const ScilabIntStackAllocator & allocator) const
521 {
522     JavaVM * vm = getScilabJavaVM();
523     unwrapRow<jint, int>(vm, id, allocator);
524 }
525
526 void ScilabJavaEnvironmentWrapper::unwrapmatint(int id, const ScilabIntStackAllocator & allocator) const
527 {
528     JavaVM * vm = getScilabJavaVM();
529     unwrapMat<jint, int>(vm, id, allocator);
530 }
531
532 void ScilabJavaEnvironmentWrapper::unwrapuint(int id, const ScilabUIntStackAllocator & allocator) const
533 {
534     // Not called
535 }
536
537 void ScilabJavaEnvironmentWrapper::unwraprowuint(int id, const ScilabUIntStackAllocator & allocator) const
538 {
539     // Not called
540 }
541
542 void ScilabJavaEnvironmentWrapper::unwrapmatuint(int id, const ScilabUIntStackAllocator & allocator) const
543 {
544     // Not called
545 }
546
547 void ScilabJavaEnvironmentWrapper::unwraplong(int id, const ScilabLongStackAllocator & allocator) const
548 {
549     JavaVM * vm = getScilabJavaVM();
550     unwrapSingle<jlong, int, long long>(vm, id, allocator, true);
551 }
552
553 void ScilabJavaEnvironmentWrapper::unwraprowlong(int id, const ScilabLongStackAllocator & allocator) const
554 {
555     JavaVM * vm = getScilabJavaVM();
556     unwrapRow<jlong, int, long long>(vm, id, allocator, true);
557 }
558
559 void ScilabJavaEnvironmentWrapper::unwrapmatlong(int id, const ScilabLongStackAllocator & allocator) const
560 {
561     JavaVM * vm = getScilabJavaVM();
562     unwrapMat<jlong, int, long long>(vm, id, allocator);
563 }
564
565 void ScilabJavaEnvironmentWrapper::unwrapulong(int id, const ScilabULongStackAllocator & allocator) const
566 {
567     // Not called
568 }
569
570 void ScilabJavaEnvironmentWrapper::unwraprowulong(int id, const ScilabULongStackAllocator & allocator) const
571 {
572     // Not called
573 }
574
575 void ScilabJavaEnvironmentWrapper::unwrapmatulong(int id, const ScilabULongStackAllocator & allocator) const
576 {
577     // Not called
578 }
579
580 void ScilabJavaEnvironmentWrapper::unwrapboolean(int id, const ScilabBooleanStackAllocator & allocator) const
581 {
582     JavaVM * vm = getScilabJavaVM();
583     unwrapSingle<jboolean, int, bool>(vm, id, allocator, true);
584 }
585
586 void ScilabJavaEnvironmentWrapper::unwraprowboolean(int id, const ScilabBooleanStackAllocator & allocator) const
587 {
588     JavaVM * vm = getScilabJavaVM();
589     unwrapRow<jboolean, int, bool>(vm, id, allocator, true);
590 }
591
592 void ScilabJavaEnvironmentWrapper::unwrapmatboolean(int id, const ScilabBooleanStackAllocator & allocator) const
593 {
594     JavaVM * vm = getScilabJavaVM();
595     unwrapMat<jboolean, int, bool>(vm, id, allocator);
596 }
597
598 void ScilabJavaEnvironmentWrapper::unwrapstring(int id, const ScilabStringStackAllocator & allocator) const
599 {
600     JNIEnv * curEnv = NULL;
601     JavaVM * vm = getScilabJavaVM();
602     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
603
604     jstring res = static_cast<jstring>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapStringID_ , id));
605     char * addr = const_cast<char *>(curEnv->GetStringUTFChars(res, 0));
606
607     allocator.allocate(1, 1, &addr);
608
609     curEnv->ReleaseStringUTFChars(res, addr);
610     curEnv->DeleteLocalRef(res);
611     if (curEnv->ExceptionCheck())
612     {
613         throw GiwsException::JniCallMethodException(curEnv);
614     }
615 }
616
617 void ScilabJavaEnvironmentWrapper::unwraprowstring(int id, const ScilabStringStackAllocator & allocator) const
618 {
619     JNIEnv * curEnv = NULL;
620     JavaVM * vm = getScilabJavaVM();
621     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
622
623     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapRowStringID_ , id));
624     if (curEnv->ExceptionCheck())
625     {
626         throw GiwsException::JniCallMethodException(curEnv);
627     }
628
629     jint lenRow = curEnv->GetArrayLength(res);
630     jboolean isCopy = JNI_FALSE;
631     char ** addr = new char*[lenRow];
632     jstring * resString = new jstring[lenRow];
633
634     for (jsize i = 0; i < lenRow; i++)
635     {
636         resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
637         addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
638     }
639
640     allocator.allocate(1, lenRow, addr);
641
642     for (jsize i = 0; i < lenRow; i++)
643     {
644         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
645         curEnv->DeleteLocalRef(resString[i]);
646     }
647     delete[] addr;
648     delete[] resString;
649
650     curEnv->DeleteLocalRef(res);
651     if (curEnv->ExceptionCheck())
652     {
653         throw GiwsException::JniCallMethodException(curEnv);
654     }
655 }
656
657 void ScilabJavaEnvironmentWrapper::unwrapmatstring(int id, const ScilabStringStackAllocator & allocator) const
658 {
659     JNIEnv * curEnv = NULL;
660     JavaVM * vm = getScilabJavaVM();
661     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
662
663     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapMatStringID_, id));
664     if (curEnv->ExceptionCheck())
665     {
666         throw GiwsException::JniCallMethodException(curEnv);
667     }
668     jint lenRow = curEnv->GetArrayLength(res);
669     jboolean isCopy = JNI_FALSE;
670
671     jobjectArray oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, 0));
672     jint lenCol = curEnv->GetArrayLength(oneDim);
673     char ** addr = new char*[lenRow * lenCol];
674     jstring * resString = new jstring[lenRow * lenCol];
675
676     for (int i = 0; i < lenRow; i++)
677     {
678         oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
679         if (helper.getMethodOfConv())
680         {
681             for (int j = 0; j < lenCol; j++)
682             {
683                 resString[j * lenRow + i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
684                 addr[j * lenRow + i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[j * lenRow + i], &isCopy));
685             }
686         }
687         else
688         {
689             for (int j = 0; j < lenCol; j++)
690             {
691                 resString[i * lenCol + j] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
692                 addr[i * lenCol + j] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i * lenCol + j], &isCopy));
693             }
694         }
695         curEnv->DeleteLocalRef(oneDim);
696     }
697
698     if (helper.getMethodOfConv())
699     {
700         allocator.allocate(lenRow, lenCol, addr);
701     }
702     else
703     {
704         allocator.allocate(lenCol, lenRow, addr);
705     }
706
707     for (int i = 0; i < lenRow * lenCol; i++)
708     {
709         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
710         curEnv->DeleteLocalRef(resString[i]);
711     }
712     delete[] addr;
713     delete[] resString;
714
715     curEnv->DeleteLocalRef(res);
716     if (curEnv->ExceptionCheck())
717     {
718         throw GiwsException::JniCallMethodException(curEnv);
719     }
720 }
721
722 void ScilabJavaEnvironmentWrapper::unwrapcomplex(int id, const ScilabComplexStackAllocator & allocator) const
723 {
724     // never called
725 }
726
727 void ScilabJavaEnvironmentWrapper::unwraprowcomplex(int id, const ScilabComplexStackAllocator & allocator) const
728 {
729     // never called
730 }
731
732 void ScilabJavaEnvironmentWrapper::unwrapmatcomplex(int id, const ScilabComplexStackAllocator & allocator) const
733 {
734     // never called
735 }
736
737 void ScilabJavaEnvironmentWrapper::unwrapfloat(int id, const ScilabFloatStackAllocator & allocator) const
738 {
739     JavaVM * vm = getScilabJavaVM();
740     unwrapSingle<jfloat, double, float>(vm, id, allocator, true);
741 }
742
743 void ScilabJavaEnvironmentWrapper::unwraprowfloat(int id, const ScilabFloatStackAllocator & allocator) const
744 {
745     JavaVM * vm = getScilabJavaVM();
746     unwrapRow<jfloat, double, float>(vm, id, allocator, true);
747 }
748
749 void ScilabJavaEnvironmentWrapper::unwrapmatfloat(int id, const ScilabFloatStackAllocator & allocator) const
750 {
751     JavaVM * vm = getScilabJavaVM();
752     unwrapMat<jfloat, double, float>(vm, id, allocator);
753 }
754 }