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