JIMS: forgot jchar unwrappers
[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     JavaVM * vm = getScilabJavaVM();
502     unwrapSingle<jchar, unsigned short>(vm, id, allocator);
503 }
504
505 void ScilabJavaEnvironmentWrapper::unwraprowushort(int id, const ScilabUShortStackAllocator & allocator) const
506 {
507     JavaVM * vm = getScilabJavaVM();
508     unwrapRow<jchar, unsigned short>(vm, id, allocator);
509 }
510
511 void ScilabJavaEnvironmentWrapper::unwrapmatushort(int id, const ScilabUShortStackAllocator & allocator) const
512 {
513     JavaVM * vm = getScilabJavaVM();
514     unwrapMat<jchar, unsigned short>(vm, id, allocator);
515 }
516
517 void ScilabJavaEnvironmentWrapper::unwrapint(int id, const ScilabIntStackAllocator & allocator) const
518 {
519     JavaVM * vm = getScilabJavaVM();
520     unwrapSingle<jint, int>(vm, id, allocator);
521 }
522
523 void ScilabJavaEnvironmentWrapper::unwraprowint(int id, const ScilabIntStackAllocator & allocator) const
524 {
525     JavaVM * vm = getScilabJavaVM();
526     unwrapRow<jint, int>(vm, id, allocator);
527 }
528
529 void ScilabJavaEnvironmentWrapper::unwrapmatint(int id, const ScilabIntStackAllocator & allocator) const
530 {
531     JavaVM * vm = getScilabJavaVM();
532     unwrapMat<jint, int>(vm, id, allocator);
533 }
534
535 void ScilabJavaEnvironmentWrapper::unwrapuint(int id, const ScilabUIntStackAllocator & allocator) const
536 {
537     // Not called
538 }
539
540 void ScilabJavaEnvironmentWrapper::unwraprowuint(int id, const ScilabUIntStackAllocator & allocator) const
541 {
542     // Not called
543 }
544
545 void ScilabJavaEnvironmentWrapper::unwrapmatuint(int id, const ScilabUIntStackAllocator & allocator) const
546 {
547     // Not called
548 }
549
550 void ScilabJavaEnvironmentWrapper::unwraplong(int id, const ScilabLongStackAllocator & allocator) const
551 {
552     JavaVM * vm = getScilabJavaVM();
553     unwrapSingle<jlong, int, long long>(vm, id, allocator, true);
554 }
555
556 void ScilabJavaEnvironmentWrapper::unwraprowlong(int id, const ScilabLongStackAllocator & allocator) const
557 {
558     JavaVM * vm = getScilabJavaVM();
559     unwrapRow<jlong, int, long long>(vm, id, allocator, true);
560 }
561
562 void ScilabJavaEnvironmentWrapper::unwrapmatlong(int id, const ScilabLongStackAllocator & allocator) const
563 {
564     JavaVM * vm = getScilabJavaVM();
565     unwrapMat<jlong, int, long long>(vm, id, allocator);
566 }
567
568 void ScilabJavaEnvironmentWrapper::unwrapulong(int id, const ScilabULongStackAllocator & allocator) const
569 {
570     // Not called
571 }
572
573 void ScilabJavaEnvironmentWrapper::unwraprowulong(int id, const ScilabULongStackAllocator & allocator) const
574 {
575     // Not called
576 }
577
578 void ScilabJavaEnvironmentWrapper::unwrapmatulong(int id, const ScilabULongStackAllocator & allocator) const
579 {
580     // Not called
581 }
582
583 void ScilabJavaEnvironmentWrapper::unwrapboolean(int id, const ScilabBooleanStackAllocator & allocator) const
584 {
585     JavaVM * vm = getScilabJavaVM();
586     unwrapSingle<jboolean, int, bool>(vm, id, allocator, true);
587 }
588
589 void ScilabJavaEnvironmentWrapper::unwraprowboolean(int id, const ScilabBooleanStackAllocator & allocator) const
590 {
591     JavaVM * vm = getScilabJavaVM();
592     unwrapRow<jboolean, int, bool>(vm, id, allocator, true);
593 }
594
595 void ScilabJavaEnvironmentWrapper::unwrapmatboolean(int id, const ScilabBooleanStackAllocator & allocator) const
596 {
597     JavaVM * vm = getScilabJavaVM();
598     unwrapMat<jboolean, int, bool>(vm, id, allocator);
599 }
600
601 void ScilabJavaEnvironmentWrapper::unwrapstring(int id, const ScilabStringStackAllocator & allocator) const
602 {
603     JNIEnv * curEnv = NULL;
604     JavaVM * vm = getScilabJavaVM();
605     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
606
607     jstring res = static_cast<jstring>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapStringID_ , id));
608     char * addr = const_cast<char *>(curEnv->GetStringUTFChars(res, 0));
609
610     allocator.allocate(1, 1, &addr);
611
612     curEnv->ReleaseStringUTFChars(res, addr);
613     curEnv->DeleteLocalRef(res);
614     if (curEnv->ExceptionCheck())
615     {
616         throw GiwsException::JniCallMethodException(curEnv);
617     }
618 }
619
620 void ScilabJavaEnvironmentWrapper::unwraprowstring(int id, const ScilabStringStackAllocator & allocator) const
621 {
622     JNIEnv * curEnv = NULL;
623     JavaVM * vm = getScilabJavaVM();
624     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
625
626     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapRowStringID_ , id));
627     if (curEnv->ExceptionCheck())
628     {
629         throw GiwsException::JniCallMethodException(curEnv);
630     }
631
632     jint lenRow = curEnv->GetArrayLength(res);
633     jboolean isCopy = JNI_FALSE;
634     char ** addr = new char*[lenRow];
635     jstring * resString = new jstring[lenRow];
636
637     for (jsize i = 0; i < lenRow; i++)
638     {
639         resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
640         addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
641     }
642
643     allocator.allocate(1, lenRow, addr);
644
645     for (jsize i = 0; i < lenRow; i++)
646     {
647         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
648         curEnv->DeleteLocalRef(resString[i]);
649     }
650     delete[] addr;
651     delete[] resString;
652
653     curEnv->DeleteLocalRef(res);
654     if (curEnv->ExceptionCheck())
655     {
656         throw GiwsException::JniCallMethodException(curEnv);
657     }
658 }
659
660 void ScilabJavaEnvironmentWrapper::unwrapmatstring(int id, const ScilabStringStackAllocator & allocator) const
661 {
662     JNIEnv * curEnv = NULL;
663     JavaVM * vm = getScilabJavaVM();
664     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
665
666     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapMatStringID_, id));
667     if (curEnv->ExceptionCheck())
668     {
669         throw GiwsException::JniCallMethodException(curEnv);
670     }
671     jint lenRow = curEnv->GetArrayLength(res);
672     jboolean isCopy = JNI_FALSE;
673
674     jobjectArray oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, 0));
675     jint lenCol = curEnv->GetArrayLength(oneDim);
676     char ** addr = new char*[lenRow * lenCol];
677     jstring * resString = new jstring[lenRow * lenCol];
678
679     for (int i = 0; i < lenRow; i++)
680     {
681         oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
682         if (helper.getMethodOfConv())
683         {
684             for (int j = 0; j < lenCol; j++)
685             {
686                 resString[j * lenRow + i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
687                 addr[j * lenRow + i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[j * lenRow + i], &isCopy));
688             }
689         }
690         else
691         {
692             for (int j = 0; j < lenCol; j++)
693             {
694                 resString[i * lenCol + j] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
695                 addr[i * lenCol + j] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i * lenCol + j], &isCopy));
696             }
697         }
698         curEnv->DeleteLocalRef(oneDim);
699     }
700
701     if (helper.getMethodOfConv())
702     {
703         allocator.allocate(lenRow, lenCol, addr);
704     }
705     else
706     {
707         allocator.allocate(lenCol, lenRow, addr);
708     }
709
710     for (int i = 0; i < lenRow * lenCol; i++)
711     {
712         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
713         curEnv->DeleteLocalRef(resString[i]);
714     }
715     delete[] addr;
716     delete[] resString;
717
718     curEnv->DeleteLocalRef(res);
719     if (curEnv->ExceptionCheck())
720     {
721         throw GiwsException::JniCallMethodException(curEnv);
722     }
723 }
724
725 void ScilabJavaEnvironmentWrapper::unwrapcomplex(int id, const ScilabComplexStackAllocator & allocator) const
726 {
727     // never called
728 }
729
730 void ScilabJavaEnvironmentWrapper::unwraprowcomplex(int id, const ScilabComplexStackAllocator & allocator) const
731 {
732     // never called
733 }
734
735 void ScilabJavaEnvironmentWrapper::unwrapmatcomplex(int id, const ScilabComplexStackAllocator & allocator) const
736 {
737     // never called
738 }
739
740 void ScilabJavaEnvironmentWrapper::unwrapfloat(int id, const ScilabFloatStackAllocator & allocator) const
741 {
742     JavaVM * vm = getScilabJavaVM();
743     unwrapSingle<jfloat, double, float>(vm, id, allocator, true);
744 }
745
746 void ScilabJavaEnvironmentWrapper::unwraprowfloat(int id, const ScilabFloatStackAllocator & allocator) const
747 {
748     JavaVM * vm = getScilabJavaVM();
749     unwrapRow<jfloat, double, float>(vm, id, allocator, true);
750 }
751
752 void ScilabJavaEnvironmentWrapper::unwrapmatfloat(int id, const ScilabFloatStackAllocator & allocator) const
753 {
754     JavaVM * vm = getScilabJavaVM();
755     unwrapMat<jfloat, double, float>(vm, id, allocator);
756 }
757 }