719c0723f77fa34feaf9ef77958f50a4927bdc6f
[scilab.git] / scilab / modules / javasci / src / jni / call_scilab_wrap.c
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.4
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12
13 /* -----------------------------------------------------------------------------
14  *  This section contains generic SWIG labels for method/variable
15  *  declarations/attributes, and other compiler dependent labels.
16  * ----------------------------------------------------------------------------- */
17
18 /* template workaround for compilers that cannot correctly implement the C++ standard */
19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21 #  define SWIGTEMPLATEDISAMBIGUATOR template
22 # elif defined(__HP_aCC)
23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25 #  define SWIGTEMPLATEDISAMBIGUATOR template
26 # else
27 #  define SWIGTEMPLATEDISAMBIGUATOR
28 # endif
29 #endif
30
31 /* inline attribute */
32 #ifndef SWIGINLINE
33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34 #   define SWIGINLINE inline
35 # else
36 #   define SWIGINLINE
37 # endif
38 #endif
39
40 /* attribute recognised by some compilers to avoid 'unused' warnings */
41 #ifndef SWIGUNUSED
42 # if defined(__GNUC__)
43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44 #     define SWIGUNUSED __attribute__ ((__unused__))
45 #   else
46 #     define SWIGUNUSED
47 #   endif
48 # elif defined(__ICC)
49 #   define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 #   define SWIGUNUSED
52 # endif
53 #endif
54
55 #ifndef SWIG_MSC_UNSUPPRESS_4505
56 # if defined(_MSC_VER)
57 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
58 # endif
59 #endif
60
61 #ifndef SWIGUNUSEDPARM
62 # ifdef __cplusplus
63 #   define SWIGUNUSEDPARM(p)
64 # else
65 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
66 # endif
67 #endif
68
69 /* internal SWIG method */
70 #ifndef SWIGINTERN
71 # define SWIGINTERN static SWIGUNUSED
72 #endif
73
74 /* internal inline SWIG method */
75 #ifndef SWIGINTERNINLINE
76 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77 #endif
78
79 /* exporting methods */
80 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81 #  ifndef GCC_HASCLASSVISIBILITY
82 #    define GCC_HASCLASSVISIBILITY
83 #  endif
84 #endif
85
86 #ifndef SWIGEXPORT
87 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 #   if defined(STATIC_LINKED)
89 #     define SWIGEXPORT
90 #   else
91 #     define SWIGEXPORT __declspec(dllexport)
92 #   endif
93 # else
94 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 #     define SWIGEXPORT __attribute__ ((visibility("default")))
96 #   else
97 #     define SWIGEXPORT
98 #   endif
99 # endif
100 #endif
101
102 /* calling conventions for Windows */
103 #ifndef SWIGSTDCALL
104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 #   define SWIGSTDCALL __stdcall
106 # else
107 #   define SWIGSTDCALL
108 # endif
109 #endif
110
111 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 # define _CRT_SECURE_NO_DEPRECATE
114 #endif
115
116 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 # define _SCL_SECURE_NO_DEPRECATE
119 #endif
120
121
122
123 /* Fix for jlong on some versions of gcc on Windows */
124 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
125 typedef long long __int64;
126 #endif
127
128 /* Fix for jlong on 64-bit x86 Solaris */
129 #if defined(__x86_64)
130 # ifdef _LP64
131 #   undef _LP64
132 # endif
133 #endif
134
135 #include <jni.h>
136 #include <stdlib.h>
137 #include <string.h>
138
139
140 /* Support for throwing Java exceptions */
141 typedef enum
142 {
143     SWIG_JavaOutOfMemoryError = 1,
144     SWIG_JavaIOException,
145     SWIG_JavaRuntimeException,
146     SWIG_JavaIndexOutOfBoundsException,
147     SWIG_JavaArithmeticException,
148     SWIG_JavaIllegalArgumentException,
149     SWIG_JavaNullPointerException,
150     SWIG_JavaDirectorPureVirtual,
151     SWIG_JavaUnknownError
152 } SWIG_JavaExceptionCodes;
153
154 typedef struct
155 {
156     SWIG_JavaExceptionCodes code;
157     const char *java_exception;
158 } SWIG_JavaExceptions_t;
159
160
161 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg)
162 {
163     jclass excep;
164     static const SWIG_JavaExceptions_t java_exceptions[] =
165     {
166         { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
167         { SWIG_JavaIOException, "java/io/IOException" },
168         { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
169         { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
170         { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
171         { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
172         { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
173         { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
174         { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
175         { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
176     };
177     const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
178
179     while (except_ptr->code != code && except_ptr->code)
180         except_ptr++;
181
182     (*jenv)->ExceptionClear(jenv);
183     excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
184     if (excep)
185         (*jenv)->ThrowNew(jenv, excep, msg);
186 }
187
188
189 /* Contract support */
190
191 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
192
193
194 #include "BOOL.h"
195 #define ENABLE_HELPERS
196 #include "javasci2_helper.h"
197 #include "MALLOC.h"
198 #include "../../../call_scilab/includes/call_scilab.h"
199 #include "../../../call_scilab/includes/fromjava.h"
200 #include "../../../api_scilab/includes/api_scilab.h"
201 #include "../../../output_stream/includes/lasterror.h"
202 #include "../../../modules/graphics/includes/WindowList.h"
203 #include "../../../core/includes/sci_types.h"
204
205
206 #ifdef __cplusplus
207 extern "C" {
208 #endif
209
210     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_Call_1ScilabOpen(JNIEnv *jenv, jclass jcls, jstring jarg1, jboolean jarg2, jstring jarg3, jint jarg4)
211     {
212         jint jresult = 0 ;
213         char *arg1 = (char *) 0 ;
214         BOOL arg2 ;
215         char *arg3 = (char *) 0 ;
216         int arg4 ;
217         int result;
218
219         (void)jenv;
220         (void)jcls;
221         arg1 = 0;
222         if (jarg1)
223         {
224             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
225             if (!arg1) return 0;
226         }
227         {
228             if (jarg2 == JNI_TRUE) arg2 = TRUE;
229             else arg2 = FALSE;
230         }
231         arg3 = 0;
232         if (jarg3)
233         {
234             arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
235             if (!arg3) return 0;
236         }
237         arg4 = (int)jarg4;
238         result = (int)Call_ScilabOpen(arg1, arg2, arg3, arg4);
239         jresult = (jint)result;
240         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
241         if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
242         return jresult;
243     }
244
245
246     SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_TerminateScilab(JNIEnv *jenv, jclass jcls, jstring jarg1)
247     {
248         jboolean jresult = 0 ;
249         char *arg1 = (char *) 0 ;
250         BOOL result;
251
252         (void)jenv;
253         (void)jcls;
254         arg1 = 0;
255         if (jarg1)
256         {
257             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
258             if (!arg1) return 0;
259         }
260         result = TerminateScilab(arg1);
261         {
262             if (result) jresult = JNI_TRUE   ;
263             else  jresult = JNI_FALSE   ;
264         }
265         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
266         return jresult;
267     }
268
269
270     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJob(JNIEnv *jenv, jclass jcls, jstring jarg1)
271     {
272         jint jresult = 0 ;
273         char *arg1 = (char *) 0 ;
274         int result;
275
276         (void)jenv;
277         (void)jcls;
278         arg1 = 0;
279         if (jarg1)
280         {
281             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
282             if (!arg1) return 0;
283         }
284         result = (int)SendScilabJob(arg1);
285         jresult = (jint)result;
286         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
287         return jresult;
288     }
289
290
291     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJobs(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg2)
292     {
293         jint jresult = 0 ;
294         char **arg1 = (char **) 0 ;
295         int arg2 ;
296         jint size1 ;
297         int result;
298
299         (void)jenv;
300         (void)jcls;
301         {
302             int i = 0;
303             size1 = (*jenv)->GetArrayLength(jenv, jarg1);
304             arg1 = (char **) MALLOC((size1 + 1) * sizeof(char *));
305             /* make a copy of each string */
306             for (i = 0; i < size1; i++)
307             {
308                 jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);
309                 const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
310                 arg1[i] = MALLOC((strlen(c_string) + 1) * sizeof(const char *));
311                 strcpy(arg1[i], c_string);
312                 (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
313                 (*jenv)->DeleteLocalRef(jenv, j_string);
314             }
315             arg1[i] = 0;
316         }
317         arg2 = (int)jarg2;
318         result = (int)SendScilabJobs(arg1, arg2);
319         jresult = (jint)result;
320         {
321             int i;
322             for (i = 0; i < size1 - 1; i++)
323             {
324                 FREE(arg1[i]);
325                 arg1[i] = NULL;
326             }
327             FREE(arg1);
328             arg1 = NULL;
329         }
330         return jresult;
331     }
332
333
334     SWIGEXPORT void JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SetFromJavaToON(JNIEnv *jenv, jclass jcls)
335     {
336         (void)jenv;
337         (void)jcls;
338         SetFromJavaToON();
339     }
340
341
342     SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isGraphicOpened(JNIEnv *jenv, jclass jcls)
343     {
344         jboolean jresult = 0 ;
345         BOOL result;
346
347         (void)jenv;
348         (void)jcls;
349         result = sciHasFigures();
350         {
351             if (result) jresult = JNI_TRUE   ;
352             else  jresult = JNI_FALSE   ;
353         }
354         return jresult;
355     }
356
357
358     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_GetLastErrorCode(JNIEnv *jenv, jclass jcls)
359     {
360         jint jresult = 0 ;
361         int result;
362
363         (void)jenv;
364         (void)jcls;
365         result = (int)getLastErrorValue();
366         jresult = (jint)result;
367         return jresult;
368     }
369
370
371     SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isExistingVariable(JNIEnv *jenv, jclass jcls, jstring jarg1)
372     {
373         jboolean jresult = 0 ;
374         char *arg1 = (char *) 0 ;
375         BOOL result;
376
377         (void)jenv;
378         (void)jcls;
379         arg1 = 0;
380         if (jarg1)
381         {
382             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
383             if (!arg1) return 0;
384         }
385         result = isExistingVariable(arg1);
386         {
387             if (result) jresult = JNI_TRUE   ;
388             else  jresult = JNI_FALSE   ;
389         }
390         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
391         return jresult;
392     }
393
394
395     SWIGEXPORT jstring JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getLastErrorMessage(JNIEnv *jenv, jclass jcls)
396     {
397         jstring jresult = 0 ;
398         char *result = 0 ;
399
400         (void)jenv;
401         (void)jcls;
402         result = (char *)getLastErrorMessageSingle();
403         {
404             if (result != NULL)
405             {
406                 jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
407                 FREE(result);
408                 result = NULL;
409             }
410         }
411         return jresult;
412     }
413
414
415     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getVariableType(JNIEnv *jenv, jclass jcls, jstring jarg1)
416     {
417         jint jresult = 0 ;
418         char *arg1 = (char *) 0 ;
419         sci_types result;
420
421         (void)jenv;
422         (void)jcls;
423         arg1 = 0;
424         if (jarg1)
425         {
426             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
427             if (!arg1) return 0;
428         }
429         result = (sci_types)getVariableType(arg1);
430         jresult = (jint)result;
431         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
432         return jresult;
433     }
434
435
436     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getIntegerPrecision(JNIEnv *jenv, jclass jcls, jstring jarg1)
437     {
438         jint jresult = 0 ;
439         char *arg1 = (char *) 0 ;
440         sci_int_types result;
441
442         (void)jenv;
443         (void)jcls;
444         arg1 = 0;
445         if (jarg1)
446         {
447             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
448             if (!arg1) return 0;
449         }
450         result = (sci_int_types)getIntegerPrecision(arg1);
451         jresult = (jint)result;
452         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
453         return jresult;
454     }
455
456
457     SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isComplex(JNIEnv *jenv, jclass jcls, jstring jarg1)
458     {
459         jboolean jresult = 0 ;
460         char *arg1 = (char *) 0 ;
461         BOOL result;
462
463         (void)jenv;
464         (void)jcls;
465         arg1 = 0;
466         if (jarg1)
467         {
468             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
469             if (!arg1) return 0;
470         }
471         result = isComplexVar(arg1);
472         {
473             if (result) jresult = JNI_TRUE   ;
474             else  jresult = JNI_FALSE   ;
475         }
476         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
477         return jresult;
478     }
479
480
481     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putString(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
482     {
483         jint jresult = 0 ;
484         char *arg1 = (char *) 0 ;
485         char **arg2 = (char **) 0 ;
486         int arg3 ;
487         int arg4 ;
488         int result;
489
490         (void)jenv;
491         (void)jcls;
492         arg1 = 0;
493         if (jarg1)
494         {
495             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
496             if (!arg1) return 0;
497         }
498         {
499             int i = 0, j = 0;
500             // Convert the String[][] => char *
501             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
502             arg4 = 0;
503             arg2 = NULL;
504
505             for (; i < arg3; i++)
506             {
507                 jobjectArray oneDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
508                 if (arg4 == 0)
509                 {
510                     /* First time we are here, init + create the array where we store the data */
511                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
512                     arg2 = (char**)malloc(sizeof(char*) * arg3 * arg4);
513                 }
514                 for (j = 0; j < arg4; j++)
515                 {
516                     jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, oneDim, j);
517                     jboolean isCopy = JNI_FALSE;
518                     char *str = (char *)(*jenv)->GetStringUTFChars(jenv, j_string, &isCopy);
519                     arg2[j * arg3 + i] = (char*)MALLOC(sizeof(char) * (strlen(str) + 1));
520                     strcpy(arg2[j * arg3 + i], str);
521                     if (isCopy)
522                     {
523                         (*jenv)->ReleaseStringUTFChars(jenv, j_string, (const char *)str);
524                     }
525                     (*jenv)->DeleteLocalRef(jenv, j_string);
526                 }
527                 (*jenv)->DeleteLocalRef(jenv, oneDim);
528             }
529         }
530         result = (int)putString(arg1, arg2, arg3, arg4);
531         jresult = (jint)result;
532         {
533             // Specific target because it was freeing the wrong argument
534             int i = 0;
535             for (; i < arg3 * arg4; i++)
536             {
537                 FREE(arg2[i]);
538             }
539             FREE(arg2);
540         }
541         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
542         return jresult;
543     }
544
545
546     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDoubleComplex(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jobjectArray jarg5)
547     {
548         jint jresult = 0 ;
549         char *arg1 = (char *) 0 ;
550         double *arg2 ;
551         int arg3 ;
552         int arg4 ;
553         double *arg5 ;
554         int arg6 ;
555         int arg7 ;
556         int result;
557
558         (void)jenv;
559         (void)jcls;
560         arg1 = 0;
561         if (jarg1)
562         {
563             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
564             if (!arg1) return 0;
565         }
566         {
567             // Convert the double[][] => double *
568             int i = 0, j = 0;
569             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
570             arg4 = 0;
571             arg2 = NULL;
572
573
574             for (; i < arg3; i++)
575             {
576                 jboolean isCopy = JNI_FALSE;
577                 jdouble* element = NULL;
578                 jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
579                 if (arg4 == 0)
580                 {
581                     /* First time we are here, init + create the array where we store the data */
582                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
583                     arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
584                 }
585                 isCopy = JNI_FALSE;
586                 element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
587
588                 for (j = 0; j < arg4; j++)
589                 {
590                     arg2[j * arg3 + i] = element[j];
591                 }
592                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
593                 (*jenv)->DeleteLocalRef(jenv, oneDim);
594             }
595         }
596         {
597             // Convert the double[][] => double *
598             int i = 0, j = 0;
599             arg6 = (*jenv)->GetArrayLength(jenv, jarg5);
600             arg7 = 0;
601             arg5 = NULL;
602
603
604             for (; i < arg6; i++)
605             {
606                 jboolean isCopy = JNI_FALSE;
607                 jdouble* element = NULL;
608                 jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg5, i);
609                 if (arg7 == 0)
610                 {
611                     /* First time we are here, init + create the array where we store the data */
612                     arg7 = (*jenv)->GetArrayLength(jenv, oneDim);
613                     arg5 = (double*)malloc(sizeof(double) * arg6 * arg7);
614                 }
615                 isCopy = JNI_FALSE;
616                 element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
617
618                 for (j = 0; j < arg7; j++)
619                 {
620                     arg5[j * arg6 + i] = element[j];
621                 }
622                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
623                 (*jenv)->DeleteLocalRef(jenv, oneDim);
624             }
625         }
626         result = (int)putDoubleComplex(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
627         jresult = (jint)result;
628         {
629             // Specific target because it was freeing the wrong argument
630             free(arg2);
631         }
632         {
633             // Specific target because it was freeing the wrong argument
634             free(arg5);
635         }
636         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
637         return jresult;
638     }
639
640
641     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDouble(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
642     {
643         jint jresult = 0 ;
644         char *arg1 = (char *) 0 ;
645         double *arg2 ;
646         int arg3 ;
647         int arg4 ;
648         int result;
649
650         (void)jenv;
651         (void)jcls;
652         arg1 = 0;
653         if (jarg1)
654         {
655             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
656             if (!arg1) return 0;
657         }
658         {
659             // Convert the double[][] => double *
660             int i = 0, j = 0;
661             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
662             arg4 = 0;
663             arg2 = NULL;
664
665
666             for (; i < arg3; i++)
667             {
668                 jboolean isCopy = JNI_FALSE;
669                 jdouble* element = NULL;
670                 jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
671                 if (arg4 == 0)
672                 {
673                     /* First time we are here, init + create the array where we store the data */
674                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
675                     arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
676                 }
677                 isCopy = JNI_FALSE;
678                 element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
679
680                 for (j = 0; j < arg4; j++)
681                 {
682                     arg2[j * arg3 + i] = element[j];
683                 }
684                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
685                 (*jenv)->DeleteLocalRef(jenv, oneDim);
686             }
687         }
688         result = (int)putDouble(arg1, arg2, arg3, arg4);
689         jresult = (jint)result;
690         {
691             // Specific target because it was freeing the wrong argument
692             free(arg2);
693         }
694         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
695         return jresult;
696     }
697
698
699     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putBoolean(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
700     {
701         jint jresult = 0 ;
702         char *arg1 = (char *) 0 ;
703         BOOL *arg2 ;
704         int arg3 ;
705         int arg4 ;
706         int result;
707
708         (void)jenv;
709         (void)jcls;
710         arg1 = 0;
711         if (jarg1)
712         {
713             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
714             if (!arg1) return 0;
715         }
716         {
717             // Convert the BOOL[][] => BOOL *
718             int i = 0, j = 0;
719             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
720             arg4 = 0;
721             arg2 = NULL;
722
723
724             for (; i < arg3; i++)
725             {
726                 jboolean isCopy = JNI_FALSE;
727                 jboolean* element = NULL;
728                 jbooleanArray oneDim = (jbooleanArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
729                 if (arg4 == 0)
730                 {
731                     /* First time we are here, init + create the array where we store the data */
732                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
733                     arg2 = (BOOL*)malloc(sizeof(BOOL) * arg3 * arg4);
734                 }
735                 isCopy = JNI_FALSE;
736                 element = (jboolean*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
737
738                 for (j = 0; j < arg4; j++)
739                 {
740                     arg2[j * arg3 + i] = element[j];
741                 }
742                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
743                 (*jenv)->DeleteLocalRef(jenv, oneDim);
744             }
745         }
746         result = (int)putBoolean(arg1, arg2, arg3, arg4);
747         jresult = (jint)result;
748         {
749             // Specific target because it was freeing the wrong argument
750             free(arg2);
751         }
752         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
753         return jresult;
754     }
755
756
757     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
758     {
759         jint jresult = 0 ;
760         char *arg1 = (char *) 0 ;
761         byte *arg2 ;
762         int arg3 ;
763         int arg4 ;
764         int result;
765
766         (void)jenv;
767         (void)jcls;
768         arg1 = 0;
769         if (jarg1)
770         {
771             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
772             if (!arg1) return 0;
773         }
774         {
775             // Convert the byte[][] => byte *
776             int i = 0, j = 0;
777             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
778             arg4 = 0;
779             arg2 = NULL;
780
781
782             for (; i < arg3; i++)
783             {
784                 jboolean isCopy = JNI_FALSE;
785                 jbyte* element = NULL;
786                 jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
787                 if (arg4 == 0)
788                 {
789                     /* First time we are here, init + create the array where we store the data */
790                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
791                     arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
792                 }
793                 isCopy = JNI_FALSE;
794                 element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
795
796                 for (j = 0; j < arg4; j++)
797                 {
798                     arg2[j * arg3 + i] = element[j];
799                 }
800                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
801                 (*jenv)->DeleteLocalRef(jenv, oneDim);
802             }
803         }
804         result = (int)putByte(arg1, arg2, arg3, arg4);
805         jresult = (jint)result;
806         {
807             // Specific target because it was freeing the wrong argument
808             free(arg2);
809         }
810         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
811         return jresult;
812     }
813
814
815     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
816     {
817         jint jresult = 0 ;
818         char *arg1 = (char *) 0 ;
819         byte *arg2 ;
820         int arg3 ;
821         int arg4 ;
822         int result;
823
824         (void)jenv;
825         (void)jcls;
826         arg1 = 0;
827         if (jarg1)
828         {
829             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
830             if (!arg1) return 0;
831         }
832         {
833             // Convert the byte[][] => byte *
834             int i = 0, j = 0;
835             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
836             arg4 = 0;
837             arg2 = NULL;
838
839
840             for (; i < arg3; i++)
841             {
842                 jboolean isCopy = JNI_FALSE;
843                 jbyte* element = NULL;
844                 jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
845                 if (arg4 == 0)
846                 {
847                     /* First time we are here, init + create the array where we store the data */
848                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
849                     arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
850                 }
851                 isCopy = JNI_FALSE;
852                 element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
853
854                 for (j = 0; j < arg4; j++)
855                 {
856                     arg2[j * arg3 + i] = element[j];
857                 }
858                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
859                 (*jenv)->DeleteLocalRef(jenv, oneDim);
860             }
861         }
862         result = (int)putUnsignedByte(arg1, arg2, arg3, arg4);
863         jresult = (jint)result;
864         {
865             // Specific target because it was freeing the wrong argument
866             free(arg2);
867         }
868         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
869         return jresult;
870     }
871
872
873     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
874     {
875         jint jresult = 0 ;
876         char *arg1 = (char *) 0 ;
877         short *arg2 ;
878         int arg3 ;
879         int arg4 ;
880         int result;
881
882         (void)jenv;
883         (void)jcls;
884         arg1 = 0;
885         if (jarg1)
886         {
887             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
888             if (!arg1) return 0;
889         }
890         {
891             // Convert the short[][] => short *
892             int i = 0, j = 0;
893             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
894             arg4 = 0;
895             arg2 = NULL;
896
897
898             for (; i < arg3; i++)
899             {
900                 jboolean isCopy = JNI_FALSE;
901                 jshort* element = NULL;
902                 jshortArray oneDim = (jshortArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
903                 if (arg4 == 0)
904                 {
905                     /* First time we are here, init + create the array where we store the data */
906                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
907                     arg2 = (short*)malloc(sizeof(short) * arg3 * arg4);
908                 }
909                 isCopy = JNI_FALSE;
910                 element = (jshort*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
911
912                 for (j = 0; j < arg4; j++)
913                 {
914                     arg2[j * arg3 + i] = element[j];
915                 }
916                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
917                 (*jenv)->DeleteLocalRef(jenv, oneDim);
918             }
919         }
920         result = (int)putShort(arg1, arg2, arg3, arg4);
921         jresult = (jint)result;
922         {
923             // Specific target because it was freeing the wrong argument
924             free(arg2);
925         }
926         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
927         return jresult;
928     }
929
930
931     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
932     {
933         jint jresult = 0 ;
934         char *arg1 = (char *) 0 ;
935         unsigned short *arg2 ;
936         int arg3 ;
937         int arg4 ;
938         int result;
939
940         (void)jenv;
941         (void)jcls;
942         arg1 = 0;
943         if (jarg1)
944         {
945             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
946             if (!arg1) return 0;
947         }
948         {
949             // Convert the unsigned short[][] => unsigned short *
950             int i = 0, j = 0;
951             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
952             arg4 = 0;
953             arg2 = NULL;
954
955
956             for (; i < arg3; i++)
957             {
958                 jboolean isCopy = JNI_FALSE;
959                 jchar* element = NULL;
960                 jcharArray oneDim = (jcharArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
961                 if (arg4 == 0)
962                 {
963                     /* First time we are here, init + create the array where we store the data */
964                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
965                     arg2 = (unsigned short*)malloc(sizeof(unsigned short) * arg3 * arg4);
966                 }
967                 isCopy = JNI_FALSE;
968                 element = (jchar*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
969
970                 for (j = 0; j < arg4; j++)
971                 {
972                     arg2[j * arg3 + i] = element[j];
973                 }
974                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
975                 (*jenv)->DeleteLocalRef(jenv, oneDim);
976             }
977         }
978         result = (int)putUnsignedShort(arg1, arg2, arg3, arg4);
979         jresult = (jint)result;
980         {
981             // Specific target because it was freeing the wrong argument
982             free(arg2);
983         }
984         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
985         return jresult;
986     }
987
988
989     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
990     {
991         jint jresult = 0 ;
992         char *arg1 = (char *) 0 ;
993         int *arg2 ;
994         int arg3 ;
995         int arg4 ;
996         int result;
997
998         (void)jenv;
999         (void)jcls;
1000         arg1 = 0;
1001         if (jarg1)
1002         {
1003             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1004             if (!arg1) return 0;
1005         }
1006         {
1007             // Convert the int[][] => int *
1008             int i = 0, j = 0;
1009             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
1010             arg4 = 0;
1011             arg2 = NULL;
1012
1013
1014             for (; i < arg3; i++)
1015             {
1016                 jboolean isCopy = JNI_FALSE;
1017                 jint* element = NULL;
1018                 jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
1019                 if (arg4 == 0)
1020                 {
1021                     /* First time we are here, init + create the array where we store the data */
1022                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
1023                     arg2 = (int*)malloc(sizeof(int) * arg3 * arg4);
1024                 }
1025                 isCopy = JNI_FALSE;
1026                 element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
1027
1028                 for (j = 0; j < arg4; j++)
1029                 {
1030                     arg2[j * arg3 + i] = element[j];
1031                 }
1032                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
1033                 (*jenv)->DeleteLocalRef(jenv, oneDim);
1034             }
1035         }
1036         result = (int)putInt(arg1, arg2, arg3, arg4);
1037         jresult = (jint)result;
1038         {
1039             // Specific target because it was freeing the wrong argument
1040             free(arg2);
1041         }
1042         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1043         return jresult;
1044     }
1045
1046
1047     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
1048     {
1049         jint jresult = 0 ;
1050         char *arg1 = (char *) 0 ;
1051         unsigned int *arg2 ;
1052         int arg3 ;
1053         int arg4 ;
1054         int result;
1055
1056         (void)jenv;
1057         (void)jcls;
1058         arg1 = 0;
1059         if (jarg1)
1060         {
1061             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1062             if (!arg1) return 0;
1063         }
1064         {
1065             // Convert the unsigned int[][] => unsigned int *
1066             int i = 0, j = 0;
1067             arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
1068             arg4 = 0;
1069             arg2 = NULL;
1070
1071
1072             for (; i < arg3; i++)
1073             {
1074                 jboolean isCopy = JNI_FALSE;
1075                 jint* element = NULL;
1076                 jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
1077                 if (arg4 == 0)
1078                 {
1079                     /* First time we are here, init + create the array where we store the data */
1080                     arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
1081                     arg2 = (unsigned int*)malloc(sizeof(unsigned int) * arg3 * arg4);
1082                 }
1083                 isCopy = JNI_FALSE;
1084                 element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
1085
1086                 for (j = 0; j < arg4; j++)
1087                 {
1088                     arg2[j * arg3 + i] = element[j];
1089                 }
1090                 (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
1091                 (*jenv)->DeleteLocalRef(jenv, oneDim);
1092             }
1093         }
1094         result = (int)putUnsignedInt(arg1, arg2, arg3, arg4);
1095         jresult = (jint)result;
1096         {
1097             // Specific target because it was freeing the wrong argument
1098             free(arg2);
1099         }
1100         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1101         return jresult;
1102     }
1103
1104
1105     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putSparse(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jobjectArray jarg4, jobjectArray jarg6, jobjectArray jarg8)
1106     {
1107         jint jresult = 0 ;
1108         char *arg1 = (char *) 0 ;
1109         int arg2 ;
1110         int arg3 ;
1111         int *arg4 = (int *) 0 ;
1112         int arg5 ;
1113         int *arg6 = (int *) 0 ;
1114         int arg7 ;
1115         double *arg8 = (double *) 0 ;
1116         int arg9 ;
1117         int result;
1118
1119         (void)jenv;
1120         (void)jcls;
1121         arg1 = 0;
1122         if (jarg1)
1123         {
1124             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1125             if (!arg1) return 0;
1126         }
1127         arg2 = (int)jarg2;
1128         arg3 = (int)jarg3;
1129         {
1130             jboolean isCopy = JNI_FALSE;
1131             jint* element = NULL;
1132             // Convert the int[][] => int *
1133             arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
1134             arg4 = (int*)MALLOC(sizeof(int) * arg5);
1135
1136             isCopy = JNI_FALSE;
1137             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
1138             memcpy(arg4, element, sizeof(int) * arg5);
1139             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
1140         }
1141         {
1142             jboolean isCopy = JNI_FALSE;
1143             jint* element = NULL;
1144             // Convert the int[][] => int *
1145             arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
1146             arg6 = (int*)MALLOC(sizeof(int) * arg7);
1147
1148             isCopy = JNI_FALSE;
1149             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
1150             memcpy(arg6, element, sizeof(int) * arg7);
1151             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
1152         }
1153         {
1154             jboolean isCopy = JNI_FALSE;
1155             jdouble* element = NULL;
1156             // Convert the double[][] => double *
1157             arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
1158             arg8 = (double*)MALLOC(sizeof(double) * arg9);
1159
1160             isCopy = JNI_FALSE;
1161             element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
1162             memcpy(arg8, element, sizeof(double) * arg9);
1163             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0);
1164         }
1165         result = (int)putSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1166         jresult = (jint)result;
1167         {
1168             // Specific target because it was freeing the wrong argument
1169             FREE(arg4);
1170         }
1171         {
1172             // Specific target because it was freeing the wrong argument
1173             FREE(arg6);
1174         }
1175         {
1176             // Specific target because it was freeing the wrong argument
1177             FREE(arg8);
1178         }
1179         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1180         return jresult;
1181     }
1182
1183
1184     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putComplexSparse(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jobjectArray jarg4, jobjectArray jarg6, jobjectArray jarg8, jobjectArray jarg10)
1185     {
1186         jint jresult = 0 ;
1187         char *arg1 = (char *) 0 ;
1188         int arg2 ;
1189         int arg3 ;
1190         int *arg4 = (int *) 0 ;
1191         int arg5 ;
1192         int *arg6 = (int *) 0 ;
1193         int arg7 ;
1194         double *arg8 = (double *) 0 ;
1195         int arg9 ;
1196         double *arg10 = (double *) 0 ;
1197         int arg11 ;
1198         int result;
1199
1200         (void)jenv;
1201         (void)jcls;
1202         arg1 = 0;
1203         if (jarg1)
1204         {
1205             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1206             if (!arg1) return 0;
1207         }
1208         arg2 = (int)jarg2;
1209         arg3 = (int)jarg3;
1210         {
1211             jboolean isCopy = JNI_FALSE;
1212             jint* element = NULL;
1213             // Convert the int[][] => int *
1214             arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
1215             arg4 = (int*)MALLOC(sizeof(int) * arg5);
1216
1217             isCopy = JNI_FALSE;
1218             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
1219             memcpy(arg4, element, sizeof(int) * arg5);
1220             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
1221         }
1222         {
1223             jboolean isCopy = JNI_FALSE;
1224             jint* element = NULL;
1225             // Convert the int[][] => int *
1226             arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
1227             arg6 = (int*)MALLOC(sizeof(int) * arg7);
1228
1229             isCopy = JNI_FALSE;
1230             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
1231             memcpy(arg6, element, sizeof(int) * arg7);
1232             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
1233         }
1234         {
1235             jboolean isCopy = JNI_FALSE;
1236             jdouble* element = NULL;
1237             // Convert the double[][] => double *
1238             arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
1239             arg8 = (double*)MALLOC(sizeof(double) * arg9);
1240
1241             isCopy = JNI_FALSE;
1242             element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
1243             memcpy(arg8, element, sizeof(double) * arg9);
1244             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0);
1245         }
1246         {
1247             jboolean isCopy = JNI_FALSE;
1248             jdouble* element = NULL;
1249             // Convert the double[][] => double *
1250             arg11 = (*jenv)->GetArrayLength(jenv, jarg10);
1251             arg10 = (double*)MALLOC(sizeof(double) * arg11);
1252
1253             isCopy = JNI_FALSE;
1254             element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg10, &isCopy);
1255             memcpy(arg10, element, sizeof(double) * arg11);
1256             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg10, element, 0);
1257         }
1258         result = (int)putComplexSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1259         jresult = (jint)result;
1260         {
1261             // Specific target because it was freeing the wrong argument
1262             FREE(arg4);
1263         }
1264         {
1265             // Specific target because it was freeing the wrong argument
1266             FREE(arg6);
1267         }
1268         {
1269             // Specific target because it was freeing the wrong argument
1270             FREE(arg8);
1271         }
1272         {
1273             // Specific target because it was freeing the wrong argument
1274             FREE(arg10);
1275         }
1276         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1277         return jresult;
1278     }
1279
1280
1281     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putBooleanSparse(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jobjectArray jarg4, jobjectArray jarg6)
1282     {
1283         jint jresult = 0 ;
1284         char *arg1 = (char *) 0 ;
1285         int arg2 ;
1286         int arg3 ;
1287         int *arg4 = (int *) 0 ;
1288         int arg5 ;
1289         int *arg6 = (int *) 0 ;
1290         int arg7 ;
1291         int result;
1292
1293         (void)jenv;
1294         (void)jcls;
1295         arg1 = 0;
1296         if (jarg1)
1297         {
1298             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1299             if (!arg1) return 0;
1300         }
1301         arg2 = (int)jarg2;
1302         arg3 = (int)jarg3;
1303         {
1304             jboolean isCopy = JNI_FALSE;
1305             jint* element = NULL;
1306             // Convert the int[][] => int *
1307             arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
1308             arg4 = (int*)MALLOC(sizeof(int) * arg5);
1309
1310             isCopy = JNI_FALSE;
1311             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
1312             memcpy(arg4, element, sizeof(int) * arg5);
1313             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
1314         }
1315         {
1316             jboolean isCopy = JNI_FALSE;
1317             jint* element = NULL;
1318             // Convert the int[][] => int *
1319             arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
1320             arg6 = (int*)MALLOC(sizeof(int) * arg7);
1321
1322             isCopy = JNI_FALSE;
1323             element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
1324             memcpy(arg6, element, sizeof(int) * arg7);
1325             (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
1326         }
1327         result = (int)putBooleanSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1328         jresult = (jint)result;
1329         {
1330             // Specific target because it was freeing the wrong argument
1331             FREE(arg4);
1332         }
1333         {
1334             // Specific target because it was freeing the wrong argument
1335             FREE(arg6);
1336         }
1337         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1338         return jresult;
1339     }
1340
1341
1342     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3)
1343     {
1344         jint jresult = 0 ;
1345         char *arg1 = (char *) 0 ;
1346         char *arg2 = (char *) 0 ;
1347         double **arg3 = (double **) 0 ;
1348         int arg4 ;
1349         int arg5 ;
1350         int *arg6 = (int *) 0 ;
1351         int result;
1352
1353         (void)jenv;
1354         (void)jcls;
1355         arg1 = 0;
1356         if (jarg1)
1357         {
1358             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1359             if (!arg1) return 0;
1360         }
1361         arg2 = 0;
1362         if (jarg2)
1363         {
1364             arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
1365             if (!arg2) return 0;
1366         }
1367         {
1368             // Convert the double[][] => double *
1369             int i = 0, j = 0, k = 0;
1370             arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
1371             arg5 = 0;
1372             arg3 = NULL;
1373
1374             for (; i < arg4; i++)
1375             {
1376                 jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
1377                 if (arg5 == 0)
1378                 {
1379                     /* First time we are here, init + create the array where we store the data */
1380                     arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
1381                     arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
1382                     arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
1383                 }
1384                 for (j = 0; j < arg5; j++)
1385                 {
1386                     jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
1387                     jboolean isCopy = JNI_FALSE;
1388                     jdouble* element = NULL;
1389                     arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
1390                     arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
1391                     isCopy = JNI_FALSE;
1392                     element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
1393                     memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
1394                     (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
1395                     (*jenv)->DeleteLocalRef(jenv, oneDim);
1396                 }
1397                 (*jenv)->DeleteLocalRef(jenv, dblDim);
1398             }
1399         }
1400         result = (int)putPolynomial(arg1, arg2, arg3, arg4, arg5, arg6);
1401         jresult = (jint)result;
1402         {
1403             // Specific target because it was freeing the wrong argument
1404             int i = 0;
1405             for (; i < arg4 * arg5; i++)
1406             {
1407                 FREE(arg3[i]);
1408             }
1409             FREE(arg3);
1410             FREE(arg6);
1411         }
1412         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1413         if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
1414         return jresult;
1415     }
1416
1417
1418     SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putComplexPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3, jobjectArray jarg7)
1419     {
1420         jint jresult = 0 ;
1421         char *arg1 = (char *) 0 ;
1422         char *arg2 = (char *) 0 ;
1423         double **arg3 = (double **) 0 ;
1424         int arg4 ;
1425         int arg5 ;
1426         int *arg6 = (int *) 0 ;
1427         double **arg7 = (double **) 0 ;
1428         int arg8 ;
1429         int arg9 ;
1430         int *arg10 = (int *) 0 ;
1431         int result;
1432
1433         (void)jenv;
1434         (void)jcls;
1435         arg1 = 0;
1436         if (jarg1)
1437         {
1438             arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
1439             if (!arg1) return 0;
1440         }
1441         arg2 = 0;
1442         if (jarg2)
1443         {
1444             arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
1445             if (!arg2) return 0;
1446         }
1447         {
1448             // Convert the double[][] => double *
1449             int i = 0, j = 0, k = 0;
1450             arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
1451             arg5 = 0;
1452             arg3 = NULL;
1453
1454             for (; i < arg4; i++)
1455             {
1456                 jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
1457                 if (arg5 == 0)
1458                 {
1459                     /* First time we are here, init + create the array where we store the data */
1460                     arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
1461                     arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
1462                     arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
1463                 }
1464                 for (j = 0; j < arg5; j++)
1465                 {
1466                     jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
1467                     jboolean isCopy = JNI_FALSE;
1468                     jdouble* element = NULL;
1469                     arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
1470                     arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
1471                     isCopy = JNI_FALSE;
1472                     element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
1473                     memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
1474                     (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
1475                     (*jenv)->DeleteLocalRef(jenv, oneDim);
1476                 }
1477                 (*jenv)->DeleteLocalRef(jenv, dblDim);
1478             }
1479         }
1480         {
1481             // Convert the double[][] => double *
1482             int i = 0, j = 0, k = 0;
1483             arg8 = (*jenv)->GetArrayLength(jenv, jarg7);
1484             arg9 = 0;
1485             arg7 = NULL;
1486
1487             for (; i < arg8; i++)
1488             {
1489                 jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg7, i);
1490                 if (arg9 == 0)
1491                 {
1492                     /* First time we are here, init + create the array where we store the data */
1493                     arg9 = (*jenv)->GetArrayLength(jenv, dblDim);
1494                     arg7 = (double**)malloc(sizeof(double*) * arg8 * arg9);
1495                     arg10 = (int*)malloc(sizeof(int) * arg8 * arg9);
1496                 }
1497                 for (j = 0; j < arg9; j++)
1498                 {
1499                     jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
1500                     jboolean isCopy = JNI_FALSE;
1501                     jdouble* element = NULL;
1502                     arg10[j * arg8 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
1503                     arg7[j * arg8 + i] = (double*)MALLOC(sizeof(jdouble) * arg10[j * arg8 + i]);
1504                     isCopy = JNI_FALSE;
1505                     element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
1506                     memcpy(arg7[j * arg8 + i], element, sizeof(jdouble) * arg10[j * arg8 + i]);
1507                     (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
1508                     (*jenv)->DeleteLocalRef(jenv, oneDim);
1509                 }
1510                 (*jenv)->DeleteLocalRef(jenv, dblDim);
1511             }
1512         }
1513         result = (int)putComplexPolynomial(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1514         jresult = (jint)result;
1515         {
1516             // Specific target because it was freeing the wrong argument
1517             int i = 0;
1518             for (; i < arg4 * arg5; i++)
1519             {
1520                 FREE(arg3[i]);
1521             }
1522             FREE(arg3);
1523             FREE(arg6);
1524         }
1525         {
1526             // Specific target because it was freeing the wrong argument
1527             int i = 0;
1528             for (; i < arg8 * arg9; i++)
1529             {
1530                 FREE(arg7[i]);
1531             }
1532             FREE(arg7);
1533             FREE(arg10);
1534         }
1535         if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
1536         if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
1537         return jresult;
1538     }
1539
1540
1541 #ifdef __cplusplus
1542 }
1543 #endif
1544