JIMS: plug extraction
[scilab.git] / scilab / modules / external_objects_java / src / cpp / ScilabObjectsCPP.cpp
1 /*
2  * JIMS ( http://forge.scilab.org/index.php/p/JIMS/ ) - This file is a part of JIMS
3  * Copyright (C) 2010 - 2011 - Calixte DENIZET <calixte@contrib.scilab.org>
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 /* ------------------------------------------------------------------------- */
13 #include <string.h>
14 #ifdef _MSC_VER
15 #include "strdup_windows.h"
16 #endif
17 #include "OptionsHelper.hxx"
18 #include "ScilabObjects.hxx"
19 #include "ScilabClassLoader.hxx"
20 #include "ScilabJavaClass.hxx"
21 //#include "ScilabJavaObjectHelper.hxx"
22 #include "ScilabJavaArray.hxx"
23 #include "ScilabJavaCompiler.hxx"
24 #include "GiwsException.hxx"
25 #include "NoMoreScilabMemoryException.hxx"
26 //#include "wrap.hpp"
27 #include "wrapwithcast.hpp"
28 //#include "unwrap.hpp"
29 #include "WrapAsDirectBufferTemplate.hpp"
30 /* ------------------------------------------------------------------------- */
31 using namespace org_scilab_modules_external_objects_java;
32 /* ------------------------------------------------------------------------- */
33 /*
34  * Syntax: wrapForType(type, Type)
35  * type: the Scilab data type
36  * Type: used for the function name
37  */
38 wrapForType(double, Double)
39 wrapForType(int, Int)
40 wrapForType(byte, Byte)
41 wrapForType(short, Short)
42 wrapForType(unsigned short, Char)
43
44 #ifdef __SCILAB_INT64__
45 wrapForType(long long, Long)
46 #endif
47 /* ------------------------------------------------------------------------- */
48 /*
49  * Syntax: wrapWithCastForType(type, castType, Type)
50  * type: the Scilab data type
51  * castType: datas are copied and casted (into castType)
52  * Type: used for the function name
53  */
54 wrapWithCastForType(unsigned int, long long, UInt)
55 wrapWithCastForType(unsigned char, short, UByte)
56 wrapWithCastForType(unsigned short, int, UShort)
57 wrapWithCastForType(int, bool, Boolean)
58 wrapWithCastForType(double, float, Float)
59 /* ------------------------------------------------------------------------- */
60 /*
61  * Syntax: unwrapForType(type,ScilabType,JNIType,Type)
62  * type: used for the function name (unwrap##type(...))
63  * ScilabType: the type in Scilab
64  * JNIType: the type in JNI
65  * Type: used for the functions wrapper
66  */
67 unwrapForType(double, double, jdouble, Double)
68 unwrapForType(int, int, jint, Int)
69 unwrapForType(boolean, int, jboolean, Boolean)
70 unwrapForType(byte, char, jbyte, Byte)
71 unwrapForType(short, short, jshort, Short)
72 unwrapForType(char, unsigned short, jchar, Char)
73 unwrapForType(long, long, jlong, Long)
74 unwrapForType(float, double, jfloat, Float)
75 /* ------------------------------------------------------------------------- */
76
77 wrapIntoDirectBuffer(Double, double)
78 wrapIntoDirectBuffer(Int, int)
79 wrapIntoDirectBuffer(Char, char)
80 wrapIntoDirectBuffer(Short, short)
81 wrapIntoDirectBuffer(Long, long)
82 wrapIntoDirectBuffer(Byte, byte)
83 wrapIntoDirectBuffer(Float, float)
84 /* ------------------------------------------------------------------------- */
85 void unwrapstring(int id, int pos, char **errmsg)
86 {
87     JavaVM *vm = getScilabJavaVM();
88     if (vm)
89     {
90         try
91         {
92             ScilabJavaObjectHelper::unwrapString(vm, id, pos);
93         }
94         catch (GiwsException::JniException e)
95         {
96             *errmsg = strdup(e.getJavaDescription().c_str());
97         }
98         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
99         {
100             *errmsg = strdup(e.what());
101         }
102     }
103 }
104 /* ------------------------------------------------------------------------- */
105 void unwraprowstring(int id, int pos, char **errmsg)
106 {
107     JavaVM *vm = getScilabJavaVM();
108     if (vm)
109     {
110         try
111         {
112             ScilabJavaObjectHelper::unwrapRowString(vm, id, pos);
113         }
114         catch (GiwsException::JniException e)
115         {
116             *errmsg = strdup(e.getJavaDescription().c_str());
117         }
118         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
119         {
120             *errmsg = strdup(e.what());
121         }
122     }
123 }
124 /* ------------------------------------------------------------------------- */
125 void unwrapmatstring(int id, int pos, char **errmsg)
126 {
127     JavaVM *vm = getScilabJavaVM();
128     if (vm)
129     {
130         try
131         {
132             ScilabJavaObjectHelper::unwrapMatString(vm, id, pos);
133         }
134         catch (GiwsException::JniException e)
135         {
136             *errmsg = strdup(e.getJavaDescription().c_str());
137         }
138         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
139         {
140             *errmsg = strdup(e.what());
141         }
142     }
143 }
144 /* ------------------------------------------------------------------------- */
145 void initscilabjavaobject(char **errmsg)
146 {
147     JavaVM *vm = getScilabJavaVM ();
148     if (vm)
149     {
150         try
151         {
152             ScilabJavaObject::initScilabJavaObject(vm);
153         }
154         catch (GiwsException::JniException e)
155         {
156             *errmsg = strdup(e.getJavaDescription().c_str());
157         }
158         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
159         {
160             *errmsg = strdup(e.what());
161         }
162     }
163 }
164 /* ------------------------------------------------------------------------- */
165 void garbagecollect(char **errmsg)
166 {
167     JavaVM *vm = getScilabJavaVM ();
168     if (vm)
169     {
170         try
171         {
172             ScilabJavaObject::garbageCollect(vm);
173         }
174         catch (GiwsException::JniException e)
175         {
176             *errmsg = strdup(e.getJavaDescription().c_str());
177         }
178     }
179 }
180 /* ------------------------------------------------------------------------- */
181 int createjavaarray(char *className, int* dims, int len, char **errmsg)
182 {
183     JavaVM *vm = getScilabJavaVM ();
184     if (vm)
185     {
186         try
187         {
188             return ScilabJavaArray::newInstance(vm, className, dims, len);
189         }
190         catch (GiwsException::JniException e)
191         {
192             *errmsg = strdup(e.getJavaDescription().c_str());
193             return -1;
194         }
195     }
196
197     return -1;
198 }
199 /* ------------------------------------------------------------------------- */
200 int loadjavaclass(char *className, char allowReload, char **errmsg)
201 {
202     JavaVM *vm = getScilabJavaVM ();
203     if (vm)
204     {
205         try
206         {
207             return ScilabClassLoader::loadJavaClass(vm, className, getAllowReload() == 0 ? false : true);
208         }
209         catch (GiwsException::JniException e)
210         {
211             *errmsg = strdup(e.getJavaDescription().c_str());
212             return -1;
213         }
214     }
215
216     return -1;
217 }
218 /* ------------------------------------------------------------------------- */
219 char* getrepresentation(int id, char **errmsg)
220 {
221     JavaVM *vm = getScilabJavaVM ();
222     if (vm)
223     {
224         try
225         {
226             char *rep = ScilabJavaObject::getRepresentation(vm, id);
227             char *returnedRep = NULL;
228             if (rep)
229             {
230                 returnedRep = strdup(rep);
231             }
232             return returnedRep;
233         }
234         catch (GiwsException::JniException e)
235         {
236             *errmsg = strdup(e.getJavaDescription().c_str());
237             return NULL;
238         }
239     }
240
241     return NULL;
242 }
243 /* ------------------------------------------------------------------------- */
244 int isvalidjavaobject(int id)
245 {
246     JavaVM *vm = getScilabJavaVM ();
247     if (vm)
248     {
249         bool b = ScilabJavaObject::isValidJavaObject(vm, id);
250         return b ? 1 : 0;
251     }
252
253     return 0;
254 }
255 /* ------------------------------------------------------------------------- */
256 int newinstance(int id, int *args, int argsSize, char **errmsg)
257 {
258     JavaVM *vm = getScilabJavaVM ();
259     if (vm)
260     {
261         try
262         {
263             return ScilabJavaClass::newInstance(vm, id, args, argsSize);
264         }
265         catch (GiwsException::JniException e)
266         {
267             *errmsg = strdup(e.getJavaDescription().c_str());
268             return -1;
269         }
270     }
271
272     return -1;
273 }
274 /* ------------------------------------------------------------------------- */
275 int invoke(int id, char *methodName, int *args, int argsSize, char **errmsg)
276 {
277     JavaVM *vm = getScilabJavaVM ();
278     if (vm)
279     {
280         try
281         {
282             return ScilabJavaObject::invoke(vm, id, methodName, args, argsSize);
283         }
284         catch (GiwsException::JniException e)
285         {
286             *errmsg = strdup(e.getJavaDescription().c_str());
287             return -1;
288         }
289     }
290
291     return -1;
292 }
293 /* ------------------------------------------------------------------------- */
294 void setfield(int id, char *fieldName, int idarg, char **errmsg)
295 {
296     JavaVM *vm = getScilabJavaVM ();
297     if (vm)
298     {
299         try
300         {
301             return ScilabJavaObject::setField(vm, id, fieldName, idarg);
302         }
303         catch (GiwsException::JniException e)
304         {
305             *errmsg = strdup(e.getJavaDescription().c_str());
306             return;
307         }
308     }
309
310     return;
311 }
312 /* ------------------------------------------------------------------------- */
313 int getfield(int id, char *fieldName, char **errmsg)
314 {
315     JavaVM *vm = getScilabJavaVM ();
316     if (vm)
317     {
318         try
319         {
320             return ScilabJavaObject::getField(vm, id, fieldName);
321         }
322         catch (GiwsException::JniException e)
323         {
324             *errmsg = strdup(e.getJavaDescription().c_str());
325             return -1;
326         }
327     }
328
329     return -1;
330 }
331 /* ------------------------------------------------------------------------- */
332 int getfieldtype(int id, char *fieldName, char **errmsg)
333 {
334     JavaVM *vm = getScilabJavaVM ();
335     if (vm)
336     {
337         try
338         {
339             return ScilabJavaObject::getFieldType(vm, id, fieldName);
340         }
341         catch (GiwsException::JniException e)
342         {
343             *errmsg = strdup(e.getJavaDescription().c_str());
344             return -1;
345         }
346     }
347
348     return -1;
349 }
350 /* ------------------------------------------------------------------------- */
351 int getarrayelement(int id, int *index, int length, char **errmsg)
352 {
353     JavaVM *vm = getScilabJavaVM ();
354     if (vm)
355     {
356         try
357         {
358             return ScilabJavaObject::getArrayElement(vm, id, index, length);
359         }
360         catch (GiwsException::JniException e)
361         {
362             *errmsg = strdup(e.getJavaDescription().c_str());
363             return -1;
364         }
365     }
366
367     return -1;
368 }
369 /* ------------------------------------------------------------------------- */
370 void setarrayelement(int id, int *index, int length, int idArg, char **errmsg)
371 {
372     JavaVM *vm = getScilabJavaVM ();
373     if (vm)
374     {
375         try
376         {
377             ScilabJavaObject::setArrayElement(vm, id, index, length, idArg);
378         }
379         catch (GiwsException::JniException e)
380         {
381             *errmsg = strdup(e.getJavaDescription().c_str());
382         }
383     }
384 }
385 /* ------------------------------------------------------------------------- */
386 int javacast(int id, char *objName, char **errmsg)
387 {
388     JavaVM *vm = getScilabJavaVM ();
389     if (vm)
390     {
391         try
392         {
393             return ScilabJavaObject::javaCast(vm, id, objName);
394         }
395         catch (GiwsException::JniException e)
396         {
397             *errmsg = strdup(e.getJavaDescription().c_str());
398             return -1;
399         }
400     }
401
402     return -1;
403 }
404 /* ------------------------------------------------------------------------- */
405 int javacastwithid(int id, int classId, char **errmsg)
406 {
407     JavaVM *vm = getScilabJavaVM ();
408     if (vm)
409     {
410         try
411         {
412             return ScilabJavaObject::javaCast(vm, id, classId);
413         }
414         catch (GiwsException::JniException e)
415         {
416             *errmsg = strdup(e.getJavaDescription().c_str());
417             return -1;
418         }
419     }
420
421     return -1;
422 }
423 /* ------------------------------------------------------------------------- */
424 void removescilabjavaobject(int id)
425 {
426     JavaVM *vm = getScilabJavaVM ();
427     if (vm)
428     {
429         ScilabJavaObject::removeScilabJavaObject(vm, id);
430     }
431 }
432 /* ------------------------------------------------------------------------- */
433 void getaccessiblemethods(int id, int pos, char **errmsg)
434 {
435     JavaVM *vm = getScilabJavaVM ();
436     if (vm)
437     {
438         try
439         {
440             ScilabJavaObjectHelper::getMethodResult(vm, "getAccessibleMethods", id, pos);
441         }
442         catch (GiwsException::JniException e)
443         {
444             *errmsg = strdup(e.getJavaDescription().c_str());
445         }
446         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
447         {
448             *errmsg = strdup(e.what());
449         }
450     }
451 }
452 /* ------------------------------------------------------------------------- */
453 void getaccessiblefields(int id, int pos, char **errmsg)
454 {
455     JavaVM *vm = getScilabJavaVM ();
456     if (vm)
457     {
458         try
459         {
460             ScilabJavaObjectHelper::getMethodResult(vm, "getAccessibleFields", id, pos);
461         }
462         catch (GiwsException::JniException e)
463         {
464             *errmsg = strdup(e.getJavaDescription().c_str());
465         }
466         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
467         {
468             *errmsg = strdup(e.what());
469         }
470     }
471 }
472 /* ------------------------------------------------------------------------- */
473 char* getclassname(int id, char **errmsg)
474 {
475     JavaVM *vm = getScilabJavaVM ();
476     if (vm)
477     {
478         try
479         {
480             return strdup(ScilabJavaObject::getClassName(vm, id));
481         }
482         catch (GiwsException::JniException e)
483         {
484             *errmsg = strdup(e.getJavaDescription().c_str());
485         }
486         catch (org_scilab_modules_external_objects_java::NoMoreScilabMemoryException e)
487         {
488             *errmsg = strdup(e.what());
489         }
490     }
491     return NULL;
492 }
493 /* ------------------------------------------------------------------------- */
494 int wrapSingleString(char *x)
495 {
496     JavaVM *vm = getScilabJavaVM();
497     if (vm)
498     {
499         return ScilabJavaObject::wrapString(vm, x);
500     }
501
502     return -1;
503 }
504 /* ------------------------------------------------------------------------- */
505 int wrapRowString(char **x, int len)
506 {
507     JavaVM *vm = getScilabJavaVM();
508     if (vm)
509     {
510         return ScilabJavaObject::wrapString(vm, x, len);
511     }
512
513     return -1;
514 }
515 /* ------------------------------------------------------------------------- */
516 int wrapMatString(char **x, int r, int c)
517 {
518     JavaVM *vm = getScilabJavaVM();
519     if (vm)
520     {
521         if (getMethodOfConv())
522         {
523             char ***xx = new char**[r];
524             int i, j, k;
525             for (i = 0; i < r; i++)
526             {
527                 xx[i] = new char*[c];
528                 for (j = 0; j < c; j++)
529                 {
530                     int len = strlen(x[j * r + i]) + 1;
531                     xx[i][j] = new char[len];
532                     memcpy(xx[i][j], x[j * r + i], len);
533                 }
534             }
535             k = ScilabJavaObject::wrapString(vm, xx, r, c);
536             for (i = 0; i < r; i++)
537             {
538                 for (j = 0; j < c; j++)
539                 {
540                     delete [] xx[i][j];
541                 }
542                 delete [] xx[i];
543             }
544             delete [] xx;
545             return k;
546         }
547         else
548         {
549             char ***xx = new char**[c];
550             int i;
551             xx[0] = x;
552             for (i = 1; i < c; xx[i] = xx[i++ - 1] + r)
553             {
554                 ;
555             }
556             i = ScilabJavaObject::wrapString(vm, xx, c, r);
557             delete [] xx;
558             return i;
559         }
560     }
561     return -1;
562 }
563 /* ------------------------------------------------------------------------- */
564 int isunwrappable(int id, char **errmsg)
565 {
566     JavaVM *vm = getScilabJavaVM ();
567     if (vm)
568     {
569         try
570         {
571             return ScilabJavaObject::isUnwrappable(vm, id);
572         }
573         catch (GiwsException::JniException e)
574         {
575             *errmsg = strdup(e.getJavaDescription().c_str());
576         }
577     }
578
579     return -1;
580 }
581 /* ------------------------------------------------------------------------- */
582 int compilecode(char *className, char **code, int size, char **errmsg)
583 {
584     JavaVM *vm = getScilabJavaVM ();
585     if (vm)
586     {
587         try
588         {
589             return ScilabJavaCompiler::compileCode(vm, className, code, size);
590         }
591         catch (GiwsException::JniException e)
592         {
593             *errmsg = strdup(e.getJavaDescription().c_str());
594         }
595     }
596
597     return -1;
598 }
599 /* ------------------------------------------------------------------------- */
600 void releasedirectbuffer(void **ref, int* id, int len, char **errmsg)
601 {
602     JavaVM *vm = getScilabJavaVM ();
603     if (vm)
604     {
605         try
606         {
607             ScilabJavaObjectHelper::releaseDirectBuffer(vm, ref, id, len);
608         }
609         catch (GiwsException::JniException e)
610         {
611             *errmsg = strdup(e.getJavaDescription().c_str());
612         }
613     }
614 }
615 /* ------------------------------------------------------------------------- */
616 void enabletrace(char *filename, char **errmsg)
617 {
618     JavaVM *vm = getScilabJavaVM ();
619     if (vm)
620     {
621         try
622         {
623             ScilabJavaObject::enableTrace(vm, filename);
624         }
625         catch (GiwsException::JniException e)
626         {
627             *errmsg = strdup(e.getJavaDescription().c_str());
628         }
629     }
630 }
631 /* ------------------------------------------------------------------------- */
632 void disabletrace()
633 {
634     JavaVM *vm = getScilabJavaVM ();
635     if (vm)
636     {
637         ScilabJavaObject::disableTrace(vm);
638     }
639 }
640 /* ------------------------------------------------------------------------- */