Indent hooks: ignore generated files 72/6672/2
Clément DAVID [Mon, 12 Mar 2012 08:31:54 +0000 (09:31 +0100)]
Change-Id: I013617bfe1220101b6249d026409f43b25b02c87

git_hooks/pre-commit
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Call_Scilab.java
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Call_ScilabJNI.java
scilab/modules/javasci/src/jni/call_scilab_wrap.c
scilab/modules/types/src/jni/ScilabVariables.hxx
scilab/modules/ui_data/src/jni/EditVar.hxx

index 3c0bdb1..5853cb1 100755 (executable)
@@ -65,6 +65,7 @@ then
        echo "  git config --add astyle.ignored 'scilab/modules/*/src/jni/*.hxx' "
        echo "  git config --add astyle.ignored 'scilab/modules/*/src/jni/*.cpp' "
        echo "  git config --add astyle.ignored 'scilab/modules/*/src/jni/*.c' "
+    echo "  git config --add astyle.ignored 'scilab/modules/javasci/src/java/org/scilab/modules/javasci/Call_Scilab*.java' "
        echo
        
        ASTYLE_IGNORED=""
index 13735fd..df0ff0d 100644 (file)
@@ -12,126 +12,126 @@ package org.scilab.modules.javasci;
 import org.scilab.modules.types.ScilabTypeEnum;
 import org.scilab.modules.types.ScilabIntegerTypeEnum;
 
-/**
-  * Connector for Javasci v2.
-  * This class should <b>not</b> be used directly
-  * @see org.scilab.modules.javasci.Scilab
-  * @author DIGITEO - Sylvestre LEDRU
-  */
+ /**
+   * Connector for Javasci v2.
+   * This class should <b>not</b> be used directly
+   * @see org.scilab.modules.javasci.Scilab
+   * @author DIGITEO - Sylvestre LEDRU
+   */
 public class Call_Scilab {
 
-    /**
-      * Constructor
-      */
-    protected Call_Scilab() {
-        throw new UnsupportedOperationException();
-    }
-    public static int Call_ScilabOpen(String SCIpath, boolean advancedMode, String ScilabStartup, int Stacksize) {
-        return Call_ScilabJNI.Call_ScilabOpen(SCIpath, advancedMode, ScilabStartup, Stacksize);
-    }
+ /**
+   * Constructor
+   */
+ protected Call_Scilab() {
+    throw new UnsupportedOperationException();
+ }
+  public static int Call_ScilabOpen(String SCIpath, boolean advancedMode, String ScilabStartup, int Stacksize) {
+    return Call_ScilabJNI.Call_ScilabOpen(SCIpath, advancedMode, ScilabStartup, Stacksize);
+  }
 
-    public static boolean TerminateScilab(String ScilabQuit) {
-        return Call_ScilabJNI.TerminateScilab(ScilabQuit);
-    }
-
-    public static int SendScilabJob(String job) {
-        return Call_ScilabJNI.SendScilabJob(job);
-    }
-
-    public static int SendScilabJobs(String[] jobs, int numberjobs) {
-        return Call_ScilabJNI.SendScilabJobs(jobs, numberjobs);
-    }
-
-    public static void SetFromJavaToON() {
-        Call_ScilabJNI.SetFromJavaToON();
-    }
-
-    public static boolean isGraphicOpened() {
-        return Call_ScilabJNI.isGraphicOpened();
-    }
-
-    public static int GetLastErrorCode() {
-        return Call_ScilabJNI.GetLastErrorCode();
-    }
-
-    public static boolean isExistingVariable(String varname) {
-        return Call_ScilabJNI.isExistingVariable(varname);
-    }
-
-    public static String getLastErrorMessage() {
-        return Call_ScilabJNI.getLastErrorMessage();
-    }
-
-    public static ScilabTypeEnum getVariableType(String varname) {
-        return ScilabTypeEnum.swigToEnum(Call_ScilabJNI.getVariableType(varname));
-    }
-
-    public static ScilabIntegerTypeEnum getIntegerPrecision(String varname) {
-        return ScilabIntegerTypeEnum.swigToEnum(Call_ScilabJNI.getIntegerPrecision(varname));
-    }
-
-    public static boolean isComplex(String varname) {
-        return Call_ScilabJNI.isComplex(varname);
-    }
-
-    public static int putString(String variableName, String[][] variable) {
-        return Call_ScilabJNI.putString(variableName, variable);
-    }
-
-    public static int putDoubleComplex(String variableName, double[][] variable, double[][] imag) {
-        return Call_ScilabJNI.putDoubleComplex(variableName, variable, imag);
-    }
-
-    public static int putDouble(String variableName, double[][] variable) {
-        return Call_ScilabJNI.putDouble(variableName, variable);
-    }
-
-    public static int putBoolean(String variableName, boolean[][] variable) {
-        return Call_ScilabJNI.putBoolean(variableName, variable);
-    }
-
-    public static int putByte(String variableName, byte[][] variable) {
-        return Call_ScilabJNI.putByte(variableName, variable);
-    }
-
-    public static int putUnsignedByte(String variableName, byte[][] variable) {
-        return Call_ScilabJNI.putUnsignedByte(variableName, variable);
-    }
-
-    public static int putShort(String variableName, short[][] variable) {
-        return Call_ScilabJNI.putShort(variableName, variable);
-    }
-
-    public static int putUnsignedShort(String variableName, short[][] variable) {
-        return Call_ScilabJNI.putUnsignedShort(variableName, variable);
-    }
-
-    public static int putInt(String variableName, int[][] variable) {
-        return Call_ScilabJNI.putInt(variableName, variable);
-    }
-
-    public static int putUnsignedInt(String variableName, int[][] variable) {
-        return Call_ScilabJNI.putUnsignedInt(variableName, variable);
-    }
-
-    public static int putSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos, double[] data) {
-        return Call_ScilabJNI.putSparse(variableName, nbRow, nbCol, nbRowItem, colPos, data);
-    }
-
-    public static int putComplexSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos, double[] data, double[] imag) {
-        return Call_ScilabJNI.putComplexSparse(variableName, nbRow, nbCol, nbRowItem, colPos, data, imag);
-    }
-
-    public static int putBooleanSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos) {
-        return Call_ScilabJNI.putBooleanSparse(variableName, nbRow, nbCol, nbRowItem, colPos);
-    }
-
-    public static int putPolynomial(String variableName, String polyVarName, double[][][] data) {
-        return Call_ScilabJNI.putPolynomial(variableName, polyVarName, data);
-    }
+  public static boolean TerminateScilab(String ScilabQuit) {
+    return Call_ScilabJNI.TerminateScilab(ScilabQuit);
+  }
+
+  public static int SendScilabJob(String job) {
+    return Call_ScilabJNI.SendScilabJob(job);
+  }
+
+  public static int SendScilabJobs(String[] jobs, int numberjobs) {
+    return Call_ScilabJNI.SendScilabJobs(jobs, numberjobs);
+  }
+
+  public static void SetFromJavaToON() {
+    Call_ScilabJNI.SetFromJavaToON();
+  }
+
+  public static boolean isGraphicOpened() {
+    return Call_ScilabJNI.isGraphicOpened();
+  }
+
+  public static int GetLastErrorCode() {
+    return Call_ScilabJNI.GetLastErrorCode();
+  }
+
+  public static boolean isExistingVariable(String varname) {
+    return Call_ScilabJNI.isExistingVariable(varname);
+  }
+
+  public static String getLastErrorMessage() {
+    return Call_ScilabJNI.getLastErrorMessage();
+  }
+
+  public static ScilabTypeEnum getVariableType(String varname) {
+    return ScilabTypeEnum.swigToEnum(Call_ScilabJNI.getVariableType(varname));
+  }
+
+  public static ScilabIntegerTypeEnum getIntegerPrecision(String varname) {
+    return ScilabIntegerTypeEnum.swigToEnum(Call_ScilabJNI.getIntegerPrecision(varname));
+  }
+
+  public static boolean isComplex(String varname) {
+    return Call_ScilabJNI.isComplex(varname);
+  }
+
+  public static int putString(String variableName, String[][] variable) {
+    return Call_ScilabJNI.putString(variableName, variable);
+  }
+
+  public static int putDoubleComplex(String variableName, double[][] variable, double[][] imag) {
+    return Call_ScilabJNI.putDoubleComplex(variableName, variable, imag);
+  }
+
+  public static int putDouble(String variableName, double[][] variable) {
+    return Call_ScilabJNI.putDouble(variableName, variable);
+  }
+
+  public static int putBoolean(String variableName, boolean[][] variable) {
+    return Call_ScilabJNI.putBoolean(variableName, variable);
+  }
+
+  public static int putByte(String variableName, byte[][] variable) {
+    return Call_ScilabJNI.putByte(variableName, variable);
+  }
+
+  public static int putUnsignedByte(String variableName, byte[][] variable) {
+    return Call_ScilabJNI.putUnsignedByte(variableName, variable);
+  }
+
+  public static int putShort(String variableName, short[][] variable) {
+    return Call_ScilabJNI.putShort(variableName, variable);
+  }
+
+  public static int putUnsignedShort(String variableName, short[][] variable) {
+    return Call_ScilabJNI.putUnsignedShort(variableName, variable);
+  }
+
+  public static int putInt(String variableName, int[][] variable) {
+    return Call_ScilabJNI.putInt(variableName, variable);
+  }
+
+  public static int putUnsignedInt(String variableName, int[][] variable) {
+    return Call_ScilabJNI.putUnsignedInt(variableName, variable);
+  }
+
+  public static int putSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos, double[] data) {
+    return Call_ScilabJNI.putSparse(variableName, nbRow, nbCol, nbRowItem, colPos, data);
+  }
+
+  public static int putComplexSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos, double[] data, double[] imag) {
+    return Call_ScilabJNI.putComplexSparse(variableName, nbRow, nbCol, nbRowItem, colPos, data, imag);
+  }
+
+  public static int putBooleanSparse(String variableName, int nbRow, int nbCol, int[] nbRowItem, int[] colPos) {
+    return Call_ScilabJNI.putBooleanSparse(variableName, nbRow, nbCol, nbRowItem, colPos);
+  }
+
+  public static int putPolynomial(String variableName, String polyVarName, double[][][] data) {
+    return Call_ScilabJNI.putPolynomial(variableName, polyVarName, data);
+  }
 
-    public static int putComplexPolynomial(String variableName, String polyVarName, double[][][] data, double[][][] imag) {
-        return Call_ScilabJNI.putComplexPolynomial(variableName, polyVarName, data, imag);
-    }
+  public static int putComplexPolynomial(String variableName, String polyVarName, double[][][] data, double[][][] imag) {
+    return Call_ScilabJNI.putComplexPolynomial(variableName, polyVarName, data, imag);
+  }
 
 }
index 07a322c..09c10c7 100644 (file)
@@ -11,64 +11,64 @@ package org.scilab.modules.javasci;
 
 /* It is generated code. Disable checkstyle */
 //CHECKSTYLE:OFF
-/**
-  * Connector for Javasci v2.
-  * This class should <b>not</b> be used directly
-  * @see org.scilab.modules.javasci.Scilab
-  * @author DIGITEO - Sylvestre LEDRU
-  */
+ /**
+   * Connector for Javasci v2.
+   * This class should <b>not</b> be used directly
+   * @see org.scilab.modules.javasci.Scilab
+   * @author DIGITEO - Sylvestre LEDRU
+   */
 class Call_ScilabJNI {
 
-    /**
-      * Constructor
-      */
-    protected Call_ScilabJNI() {
-        throw new UnsupportedOperationException();
-    }
+  /**
+    * Constructor
+    */
+  protected Call_ScilabJNI() {
+    throw new UnsupportedOperationException();
+  }
 
-    static {
-        try {
-            if (System.getProperty("os.name").toLowerCase().contains("windows")) {
-                System.loadLibrary("javasci");
-            } else {
-                System.loadLibrary("javasci2");
-            }
-        } catch (SecurityException e) {
-            System.err.println("A security manager exists and does not allow the loading of the specified dynamic library :");
-            e.printStackTrace(System.err);
-        } catch (UnsatisfiedLinkError e)    {
-            System.err.println("The native library javasci does not exist or cannot be found.");
-            e.printStackTrace(System.err);
+  static {
+    try {
+    if (System.getProperty("os.name").toLowerCase().contains("windows")) {
+        System.loadLibrary("javasci");
+    } else {
+        System.loadLibrary("javasci2");
         }
+    } catch (SecurityException e) {
+        System.err.println("A security manager exists and does not allow the loading of the specified dynamic library :");
+        e.printStackTrace(System.err);
+    } catch (UnsatisfiedLinkError e)    {
+        System.err.println("The native library javasci does not exist or cannot be found.");
+        e.printStackTrace(System.err);
     }
+  }
 
-    public final static native int putList(String varNmae, Object list, char type);
+  public final static native int putList(String varNmae, Object list, char type);
 
-    public final static native int Call_ScilabOpen(String jarg1, boolean jarg2, String jarg3, int jarg4);
-    public final static native boolean TerminateScilab(String jarg1);
-    public final static native int SendScilabJob(String jarg1);
-    public final static native int SendScilabJobs(String[] jarg1, int jarg2);
-    public final static native void SetFromJavaToON();
-    public final static native boolean isGraphicOpened();
-    public final static native int GetLastErrorCode();
-    public final static native boolean isExistingVariable(String jarg1);
-    public final static native String getLastErrorMessage();
-    public final static native int getVariableType(String jarg1);
-    public final static native int getIntegerPrecision(String jarg1);
-    public final static native boolean isComplex(String jarg1);
-    public final static native int putString(String jarg1, String[][] jarg2);
-    public final static native int putDoubleComplex(String jarg1, double[][] jarg2, double[][] jarg5);
-    public final static native int putDouble(String jarg1, double[][] jarg2);
-    public final static native int putBoolean(String jarg1, boolean[][] jarg2);
-    public final static native int putByte(String jarg1, byte[][] jarg2);
-    public final static native int putUnsignedByte(String jarg1, byte[][] jarg2);
-    public final static native int putShort(String jarg1, short[][] jarg2);
-    public final static native int putUnsignedShort(String jarg1, short[][] jarg2);
-    public final static native int putInt(String jarg1, int[][] jarg2);
-    public final static native int putUnsignedInt(String jarg1, int[][] jarg2);
-    public final static native int putSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6, double[] jarg8);
-    public final static native int putComplexSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6, double[] jarg8, double[] jarg10);
-    public final static native int putBooleanSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6);
-    public final static native int putPolynomial(String jarg1, String jarg2, double[][][] jarg3);
-    public final static native int putComplexPolynomial(String jarg1, String jarg2, double[][][] jarg3, double[][][] jarg7);
+  public final static native int Call_ScilabOpen(String jarg1, boolean jarg2, String jarg3, int jarg4);
+  public final static native boolean TerminateScilab(String jarg1);
+  public final static native int SendScilabJob(String jarg1);
+  public final static native int SendScilabJobs(String[] jarg1, int jarg2);
+  public final static native void SetFromJavaToON();
+  public final static native boolean isGraphicOpened();
+  public final static native int GetLastErrorCode();
+  public final static native boolean isExistingVariable(String jarg1);
+  public final static native String getLastErrorMessage();
+  public final static native int getVariableType(String jarg1);
+  public final static native int getIntegerPrecision(String jarg1);
+  public final static native boolean isComplex(String jarg1);
+  public final static native int putString(String jarg1, String[][] jarg2);
+  public final static native int putDoubleComplex(String jarg1, double[][] jarg2, double[][] jarg5);
+  public final static native int putDouble(String jarg1, double[][] jarg2);
+  public final static native int putBoolean(String jarg1, boolean[][] jarg2);
+  public final static native int putByte(String jarg1, byte[][] jarg2);
+  public final static native int putUnsignedByte(String jarg1, byte[][] jarg2);
+  public final static native int putShort(String jarg1, short[][] jarg2);
+  public final static native int putUnsignedShort(String jarg1, short[][] jarg2);
+  public final static native int putInt(String jarg1, int[][] jarg2);
+  public final static native int putUnsignedInt(String jarg1, int[][] jarg2);
+  public final static native int putSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6, double[] jarg8);
+  public final static native int putComplexSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6, double[] jarg8, double[] jarg10);
+  public final static native int putBooleanSparse(String jarg1, int jarg2, int jarg3, int[] jarg4, int[] jarg6);
+  public final static native int putPolynomial(String jarg1, String jarg2, double[][][] jarg3);
+  public final static native int putComplexPolynomial(String jarg1, String jarg2, double[][][] jarg3, double[][][] jarg7);
 }
index 719c072..293c88a 100644 (file)
@@ -1,11 +1,11 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
  * Version 2.0.4
- *
- * This file is not intended to be easily readable and contains a number of
+ * 
+ * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
  * ----------------------------------------------------------------------------- */
 
 #define SWIGJAVA
 #ifndef SWIGUNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#     define SWIGUNUSED __attribute__ ((__unused__))
+#     define SWIGUNUSED __attribute__ ((__unused__)) 
 #   else
 #     define SWIGUNUSED
 #   endif
 # elif defined(__ICC)
-#   define SWIGUNUSED __attribute__ ((__unused__))
+#   define SWIGUNUSED __attribute__ ((__unused__)) 
 # else
-#   define SWIGUNUSED
+#   define SWIGUNUSED 
 # endif
 #endif
 
 #ifndef SWIG_MSC_UNSUPPRESS_4505
 # if defined(_MSC_VER)
 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif
+# endif 
 #endif
 
 #ifndef SWIGUNUSEDPARM
 # ifdef __cplusplus
 #   define SWIGUNUSEDPARM(p)
 # else
-#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 # endif
 #endif
 
 #   define SWIGSTDCALL __stdcall
 # else
 #   define SWIGSTDCALL
-# endif
+# endif 
 #endif
 
 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 
 /* Fix for jlong on some versions of gcc on Windows */
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-typedef long long __int64;
+  typedef long long __int64;
 #endif
 
 /* Fix for jlong on 64-bit x86 Solaris */
@@ -138,51 +138,47 @@ typedef long long __int64;
 
 
 /* Support for throwing Java exceptions */
-typedef enum
-{
-    SWIG_JavaOutOfMemoryError = 1,
-    SWIG_JavaIOException,
-    SWIG_JavaRuntimeException,
-    SWIG_JavaIndexOutOfBoundsException,
-    SWIG_JavaArithmeticException,
-    SWIG_JavaIllegalArgumentException,
-    SWIG_JavaNullPointerException,
-    SWIG_JavaDirectorPureVirtual,
-    SWIG_JavaUnknownError
+typedef enum {
+  SWIG_JavaOutOfMemoryError = 1, 
+  SWIG_JavaIOException, 
+  SWIG_JavaRuntimeException, 
+  SWIG_JavaIndexOutOfBoundsException,
+  SWIG_JavaArithmeticException,
+  SWIG_JavaIllegalArgumentException,
+  SWIG_JavaNullPointerException,
+  SWIG_JavaDirectorPureVirtual,
+  SWIG_JavaUnknownError
 } SWIG_JavaExceptionCodes;
 
-typedef struct
-{
-    SWIG_JavaExceptionCodes code;
-    const char *java_exception;
+typedef struct {
+  SWIG_JavaExceptionCodes code;
+  const char *java_exception;
 } SWIG_JavaExceptions_t;
 
 
-static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg)
-{
-    jclass excep;
-    static const SWIG_JavaExceptions_t java_exceptions[] =
-    {
-        { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
-        { SWIG_JavaIOException, "java/io/IOException" },
-        { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
-        { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
-        { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
-        { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
-        { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
-        { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
-        { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
-        { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
-    };
-    const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
-
-    while (except_ptr->code != code && except_ptr->code)
-        except_ptr++;
-
-    (*jenv)->ExceptionClear(jenv);
-    excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
-    if (excep)
-        (*jenv)->ThrowNew(jenv, excep, msg);
+static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
+  jclass excep;
+  static const SWIG_JavaExceptions_t java_exceptions[] = {
+    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
+    { SWIG_JavaIOException, "java/io/IOException" },
+    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
+    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
+    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
+    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
+    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
+    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
+    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
+    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
+  };
+  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
+
+  while (except_ptr->code != code && except_ptr->code)
+    except_ptr++;
+
+  (*jenv)->ExceptionClear(jenv);
+  excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
+  if (excep)
+    (*jenv)->ThrowNew(jenv, excep, msg);
 }
 
 
@@ -207,1335 +203,1275 @@ static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionC
 extern "C" {
 #endif
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_Call_1ScilabOpen(JNIEnv *jenv, jclass jcls, jstring jarg1, jboolean jarg2, jstring jarg3, jint jarg4)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        BOOL arg2 ;
-        char *arg3 = (char *) 0 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            if (jarg2 == JNI_TRUE) arg2 = TRUE;
-            else arg2 = FALSE;
-        }
-        arg3 = 0;
-        if (jarg3)
-        {
-            arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
-            if (!arg3) return 0;
-        }
-        arg4 = (int)jarg4;
-        result = (int)Call_ScilabOpen(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
-        return jresult;
-    }
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_Call_1ScilabOpen(JNIEnv *jenv, jclass jcls, jstring jarg1, jboolean jarg2, jstring jarg3, jint jarg4) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL arg2 ;
+  char *arg3 = (char *) 0 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    if (jarg2 == JNI_TRUE) arg2 = TRUE;
+    else arg2 = FALSE;
+  }
+  arg3 = 0;
+  if (jarg3) {
+    arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
+    if (!arg3) return 0;
+  }
+  arg4 = (int)jarg4; 
+  result = (int)Call_ScilabOpen(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
+  return jresult;
+}
 
 
-    SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_TerminateScilab(JNIEnv *jenv, jclass jcls, jstring jarg1)
-    {
-        jboolean jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        BOOL result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = TerminateScilab(arg1);
-        {
-            if (result) jresult = JNI_TRUE   ;
-            else  jresult = JNI_FALSE   ;
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_TerminateScilab(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jboolean jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = TerminateScilab(arg1);
+  {
+    if (result) jresult = JNI_TRUE   ;
+    else  jresult = JNI_FALSE   ;
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJob(JNIEnv *jenv, jclass jcls, jstring jarg1)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = (int)SendScilabJob(arg1);
-        jresult = (jint)result;
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJob(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = (int)SendScilabJob(arg1);
+  jresult = (jint)result; 
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJobs(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg2)
-    {
-        jint jresult = 0 ;
-        char **arg1 = (char **) 0 ;
-        int arg2 ;
-        jint size1 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        {
-            int i = 0;
-            size1 = (*jenv)->GetArrayLength(jenv, jarg1);
-            arg1 = (char **) MALLOC((size1 + 1) * sizeof(char *));
-            /* make a copy of each string */
-            for (i = 0; i < size1; i++)
-            {
-                jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);
-                const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
-                arg1[i] = MALLOC((strlen(c_string) + 1) * sizeof(const char *));
-                strcpy(arg1[i], c_string);
-                (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
-                (*jenv)->DeleteLocalRef(jenv, j_string);
-            }
-            arg1[i] = 0;
-        }
-        arg2 = (int)jarg2;
-        result = (int)SendScilabJobs(arg1, arg2);
-        jresult = (jint)result;
-        {
-            int i;
-            for (i = 0; i < size1 - 1; i++)
-            {
-                FREE(arg1[i]);
-                arg1[i] = NULL;
-            }
-            FREE(arg1);
-            arg1 = NULL;
-        }
-        return jresult;
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScilabJobs(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg2) {
+  jint jresult = 0 ;
+  char **arg1 = (char **) 0 ;
+  int arg2 ;
+  jint size1 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  {
+    int i = 0;
+    size1 = (*jenv)->GetArrayLength(jenv, jarg1);
+    arg1 = (char **) MALLOC((size1+1)*sizeof(char *));
+    /* make a copy of each string */
+    for (i = 0; i<size1; i++) {
+      jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);
+      const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
+      arg1[i] = MALLOC((strlen(c_string)+1)*sizeof(const char *));
+      strcpy(arg1[i], c_string);
+      (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
+      (*jenv)->DeleteLocalRef(jenv, j_string);
+    }
+    arg1[i] = 0;
+  }
+  arg2 = (int)jarg2; 
+  result = (int)SendScilabJobs(arg1,arg2);
+  jresult = (jint)result; 
+  {
+    int i;
+    for (i=0; i<size1-1; i++) {
+      FREE(arg1[i]);
+      arg1[i] = NULL;
     }
+    FREE(arg1);
+    arg1 = NULL;
+  }
+  return jresult;
+}
 
 
-    SWIGEXPORT void JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SetFromJavaToON(JNIEnv *jenv, jclass jcls)
-    {
-        (void)jenv;
-        (void)jcls;
-        SetFromJavaToON();
-    }
+SWIGEXPORT void JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SetFromJavaToON(JNIEnv *jenv, jclass jcls) {
+  (void)jenv;
+  (void)jcls;
+  SetFromJavaToON();
+}
 
 
-    SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isGraphicOpened(JNIEnv *jenv, jclass jcls)
-    {
-        jboolean jresult = 0 ;
-        BOOL result;
+SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isGraphicOpened(JNIEnv *jenv, jclass jcls) {
+  jboolean jresult = 0 ;
+  BOOL result;
+  
+  (void)jenv;
+  (void)jcls;
+  result = sciHasFigures();
+  {
+    if (result) jresult = JNI_TRUE   ;
+    else  jresult = JNI_FALSE   ;
+  }
+  return jresult;
+}
 
-        (void)jenv;
-        (void)jcls;
-        result = sciHasFigures();
-        {
-            if (result) jresult = JNI_TRUE   ;
-            else  jresult = JNI_FALSE   ;
-        }
-        return jresult;
-    }
 
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_GetLastErrorCode(JNIEnv *jenv, jclass jcls) {
+  jint jresult = 0 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  result = (int)getLastErrorValue();
+  jresult = (jint)result; 
+  return jresult;
+}
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_GetLastErrorCode(JNIEnv *jenv, jclass jcls)
-    {
-        jint jresult = 0 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        result = (int)getLastErrorValue();
-        jresult = (jint)result;
-        return jresult;
-    }
+
+SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isExistingVariable(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jboolean jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = isExistingVariable(arg1);
+  {
+    if (result) jresult = JNI_TRUE   ;
+    else  jresult = JNI_FALSE   ;
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isExistingVariable(JNIEnv *jenv, jclass jcls, jstring jarg1)
+SWIGEXPORT jstring JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getLastErrorMessage(JNIEnv *jenv, jclass jcls) {
+  jstring jresult = 0 ;
+  char *result = 0 ;
+  
+  (void)jenv;
+  (void)jcls;
+  result = (char *)getLastErrorMessageSingle();
+  {
+    if (result != NULL)
     {
-        jboolean jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        BOOL result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = isExistingVariable(arg1);
-        {
-            if (result) jresult = JNI_TRUE   ;
-            else  jresult = JNI_FALSE   ;
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+      jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
+      FREE(result);
+      result = NULL;
+    }       
+  }
+  return jresult;
+}
 
 
-    SWIGEXPORT jstring JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getLastErrorMessage(JNIEnv *jenv, jclass jcls)
-    {
-        jstring jresult = 0 ;
-        char *result = 0 ;
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getVariableType(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  sci_types result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = (sci_types)getVariableType(arg1);
+  jresult = (jint)result; 
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
-        (void)jenv;
-        (void)jcls;
-        result = (char *)getLastErrorMessageSingle();
-        {
-            if (result != NULL)
-            {
-                jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
-                FREE(result);
-                result = NULL;
-            }
-        }
-        return jresult;
-    }
+
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getIntegerPrecision(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  sci_int_types result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = (sci_int_types)getIntegerPrecision(arg1);
+  jresult = (jint)result; 
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getVariableType(JNIEnv *jenv, jclass jcls, jstring jarg1)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        sci_types result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = (sci_types)getVariableType(arg1);
-        jresult = (jint)result;
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isComplex(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jboolean jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = isComplexVar(arg1);
+  {
+    if (result) jresult = JNI_TRUE   ;
+    else  jresult = JNI_FALSE   ;
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getIntegerPrecision(JNIEnv *jenv, jclass jcls, jstring jarg1)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putString(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    int i=0, j=0;
+    // Convert the String[][] => char *
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        sci_int_types result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = (sci_int_types)getIntegerPrecision(arg1);
-        jresult = (jint)result;
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jobjectArray oneDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (char**)malloc(sizeof(char*) * arg3 * arg4);
+      }
+      for (j = 0; j < arg4; j++)
+      {
+        jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, oneDim, j);
+        jboolean isCopy = JNI_FALSE;
+        char *str = (char *)(*jenv)->GetStringUTFChars(jenv, j_string, &isCopy);
+        arg2[j * arg3 + i] = (char*)MALLOC(sizeof(char)*(strlen(str) + 1));
+        strcpy(arg2[j * arg3 + i], str);
+        if (isCopy)
+        {
+          (*jenv)->ReleaseStringUTFChars(jenv, j_string, (const char *)str);
+        }
+        (*jenv)->DeleteLocalRef(jenv, j_string);
+      }
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
-
-
-    SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isComplex(JNIEnv *jenv, jclass jcls, jstring jarg1)
+  }
+  result = (int)putString(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    int i = 0;
+    for (; i < arg3 * arg4; i++)
     {
-        jboolean jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        BOOL result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        result = isComplexVar(arg1);
-        {
-            if (result) jresult = JNI_TRUE   ;
-            else  jresult = JNI_FALSE   ;
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      FREE(arg2[i]);
     }
+    FREE(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putString(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDoubleComplex(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jobjectArray jarg5) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  double *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  double *arg5 ;
+  int arg6 ;
+  int arg7 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        char **arg2 = (char **) 0 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            int i = 0, j = 0;
-            // Convert the String[][] => char *
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-            for (; i < arg3; i++)
-            {
-                jobjectArray oneDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (char**)malloc(sizeof(char*) * arg3 * arg4);
-                }
-                for (j = 0; j < arg4; j++)
-                {
-                    jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, oneDim, j);
-                    jboolean isCopy = JNI_FALSE;
-                    char *str = (char *)(*jenv)->GetStringUTFChars(jenv, j_string, &isCopy);
-                    arg2[j * arg3 + i] = (char*)MALLOC(sizeof(char) * (strlen(str) + 1));
-                    strcpy(arg2[j * arg3 + i], str);
-                    if (isCopy)
-                    {
-                        (*jenv)->ReleaseStringUTFChars(jenv, j_string, (const char *)str);
-                    }
-                    (*jenv)->DeleteLocalRef(jenv, j_string);
-                }
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putString(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            int i = 0;
-            for (; i < arg3 * arg4; i++)
-            {
-                FREE(arg2[i]);
-            }
-            FREE(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jdouble* element = NULL;
+      jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
-
-
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDoubleComplex(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jobjectArray jarg5)
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0;
+    arg6 = (*jenv)->GetArrayLength(jenv, jarg5);
+    arg7 = 0;
+    arg5 = NULL;
+    
+    
+    for (; i < arg6; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        double *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        double *arg5 ;
-        int arg6 ;
-        int arg7 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jdouble* element = NULL;
-                jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0;
-            arg6 = (*jenv)->GetArrayLength(jenv, jarg5);
-            arg7 = 0;
-            arg5 = NULL;
-
-
-            for (; i < arg6; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jdouble* element = NULL;
-                jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg5, i);
-                if (arg7 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg7 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg5 = (double*)malloc(sizeof(double) * arg6 * arg7);
-                }
-                isCopy = JNI_FALSE;
-                element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg7; j++)
-                {
-                    arg5[j * arg6 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putDoubleComplex(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg5);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jdouble* element = NULL;
+      jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg5, i);
+      if (arg7 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg7 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg5 = (double*)malloc(sizeof(double) * arg6 * arg7);
+      }
+      isCopy = JNI_FALSE;
+      element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg7; j++)
+      {
+        arg5[j * arg6 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putDoubleComplex(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg5);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDouble(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDouble(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  double *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        double *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jdouble* element = NULL;
-                jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putDouble(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jdouble* element = NULL;
+      jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (double*)malloc(sizeof(double) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putDouble(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putBoolean(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putBoolean(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the BOOL[][] => BOOL *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        BOOL *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the BOOL[][] => BOOL *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jboolean* element = NULL;
-                jbooleanArray oneDim = (jbooleanArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (BOOL*)malloc(sizeof(BOOL) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jboolean*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putBoolean(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jboolean* element = NULL;
+      jbooleanArray oneDim = (jbooleanArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (BOOL*)malloc(sizeof(BOOL) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jboolean*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putBoolean(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  byte *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the byte[][] => byte *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        byte *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the byte[][] => byte *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jbyte* element = NULL;
-                jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putByte(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jbyte* element = NULL;
+      jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putByte(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedByte(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  byte *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the byte[][] => byte *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        byte *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the byte[][] => byte *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jbyte* element = NULL;
-                jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putUnsignedByte(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jbyte* element = NULL;
+      jbyteArray oneDim = (jbyteArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (byte*)malloc(sizeof(byte) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jbyte*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putUnsignedByte(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  short *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the short[][] => short *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        short *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the short[][] => short *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jshort* element = NULL;
-                jshortArray oneDim = (jshortArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (short*)malloc(sizeof(short) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jshort*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putShort(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jshort* element = NULL;
+      jshortArray oneDim = (jshortArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (short*)malloc(sizeof(short) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jshort*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putShort(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedShort(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  unsigned short *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the unsigned short[][] => unsigned short *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        unsigned short *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the unsigned short[][] => unsigned short *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jchar* element = NULL;
-                jcharArray oneDim = (jcharArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (unsigned short*)malloc(sizeof(unsigned short) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jchar*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putUnsignedShort(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jchar* element = NULL;
+      jcharArray oneDim = (jcharArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (unsigned short*)malloc(sizeof(unsigned short) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jchar*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putUnsignedShort(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the int[][] => int *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        int *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the int[][] => int *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jint* element = NULL;
-                jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (int*)malloc(sizeof(int) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putInt(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jint* element = NULL;
+      jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (int*)malloc(sizeof(int) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putInt(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsignedInt(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  unsigned int *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  {
+    // Convert the unsigned int[][] => unsigned int *
+    int i = 0, j = 0;
+    arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
+    arg4 = 0;
+    arg2 = NULL;
+    
+    
+    for (; i < arg3; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        unsigned int *arg2 ;
-        int arg3 ;
-        int arg4 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        {
-            // Convert the unsigned int[][] => unsigned int *
-            int i = 0, j = 0;
-            arg3 = (*jenv)->GetArrayLength(jenv, jarg2);
-            arg4 = 0;
-            arg2 = NULL;
-
-
-            for (; i < arg3; i++)
-            {
-                jboolean isCopy = JNI_FALSE;
-                jint* element = NULL;
-                jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
-                if (arg4 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg2 = (unsigned int*)malloc(sizeof(unsigned int) * arg3 * arg4);
-                }
-                isCopy = JNI_FALSE;
-                element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-
-                for (j = 0; j < arg4; j++)
-                {
-                    arg2[j * arg3 + i] = element[j];
-                }
-                (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
-                (*jenv)->DeleteLocalRef(jenv, oneDim);
-            }
-        }
-        result = (int)putUnsignedInt(arg1, arg2, arg3, arg4);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            free(arg2);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
+      jboolean isCopy = JNI_FALSE;
+      jint* element = NULL;
+      jintArray oneDim = (jintArray)(*jenv)->GetObjectArrayElement(jenv, jarg2, i);
+      if (arg4 == 0)
+      {
+        /* First time we are here, init + create the array where we store the data */
+        arg4 = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg2 = (unsigned int*)malloc(sizeof(unsigned int) * arg3 * arg4);
+      }
+      isCopy = JNI_FALSE;
+      element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+      
+      for (j = 0; j < arg4; j++)
+      {
+        arg2[j * arg3 + i] = element[j];
+      }
+      (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, JNI_ABORT);
+      (*jenv)->DeleteLocalRef(jenv, oneDim);
     }
+  }
+  result = (int)putUnsignedInt(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    free(arg2);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    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)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        int arg2 ;
-        int arg3 ;
-        int *arg4 = (int *) 0 ;
-        int arg5 ;
-        int *arg6 = (int *) 0 ;
-        int arg7 ;
-        double *arg8 = (double *) 0 ;
-        int arg9 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        arg2 = (int)jarg2;
-        arg3 = (int)jarg3;
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
-            arg4 = (int*)MALLOC(sizeof(int) * arg5);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
-            memcpy(arg4, element, sizeof(int) * arg5);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
-            arg6 = (int*)MALLOC(sizeof(int) * arg7);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
-            memcpy(arg6, element, sizeof(int) * arg7);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jdouble* element = NULL;
-            // Convert the double[][] => double *
-            arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
-            arg8 = (double*)MALLOC(sizeof(double) * arg9);
-
-            isCopy = JNI_FALSE;
-            element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
-            memcpy(arg8, element, sizeof(double) * arg9);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0);
-        }
-        result = (int)putSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg4);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg6);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg8);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+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) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int *arg4 = (int *) 0 ;
+  int arg5 ;
+  int *arg6 = (int *) 0 ;
+  int arg7 ;
+  double *arg8 = (double *) 0 ;
+  int arg9 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  arg2 = (int)jarg2; 
+  arg3 = (int)jarg3; 
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
+    arg4 = (int*)MALLOC(sizeof(int) * arg5);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
+    memcpy(arg4, element, sizeof(int) * arg5);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
+    arg6 = (int*)MALLOC(sizeof(int) * arg7);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
+    memcpy(arg6, element, sizeof(int) * arg7);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jdouble* element = NULL;
+    // Convert the double[][] => double *
+    arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
+    arg8 = (double*)MALLOC(sizeof(double) * arg9);
+    
+    isCopy = JNI_FALSE;
+    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
+    memcpy(arg8, element, sizeof(double) * arg9);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0); 
+  }
+  result = (int)putSparse(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg4);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg6);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg8);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    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)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        int arg2 ;
-        int arg3 ;
-        int *arg4 = (int *) 0 ;
-        int arg5 ;
-        int *arg6 = (int *) 0 ;
-        int arg7 ;
-        double *arg8 = (double *) 0 ;
-        int arg9 ;
-        double *arg10 = (double *) 0 ;
-        int arg11 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        arg2 = (int)jarg2;
-        arg3 = (int)jarg3;
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
-            arg4 = (int*)MALLOC(sizeof(int) * arg5);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
-            memcpy(arg4, element, sizeof(int) * arg5);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
-            arg6 = (int*)MALLOC(sizeof(int) * arg7);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
-            memcpy(arg6, element, sizeof(int) * arg7);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jdouble* element = NULL;
-            // Convert the double[][] => double *
-            arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
-            arg8 = (double*)MALLOC(sizeof(double) * arg9);
-
-            isCopy = JNI_FALSE;
-            element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
-            memcpy(arg8, element, sizeof(double) * arg9);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jdouble* element = NULL;
-            // Convert the double[][] => double *
-            arg11 = (*jenv)->GetArrayLength(jenv, jarg10);
-            arg10 = (double*)MALLOC(sizeof(double) * arg11);
-
-            isCopy = JNI_FALSE;
-            element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg10, &isCopy);
-            memcpy(arg10, element, sizeof(double) * arg11);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg10, element, 0);
-        }
-        result = (int)putComplexSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg4);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg6);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg8);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg10);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+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) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int *arg4 = (int *) 0 ;
+  int arg5 ;
+  int *arg6 = (int *) 0 ;
+  int arg7 ;
+  double *arg8 = (double *) 0 ;
+  int arg9 ;
+  double *arg10 = (double *) 0 ;
+  int arg11 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  arg2 = (int)jarg2; 
+  arg3 = (int)jarg3; 
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
+    arg4 = (int*)MALLOC(sizeof(int) * arg5);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
+    memcpy(arg4, element, sizeof(int) * arg5);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
+    arg6 = (int*)MALLOC(sizeof(int) * arg7);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
+    memcpy(arg6, element, sizeof(int) * arg7);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jdouble* element = NULL;
+    // Convert the double[][] => double *
+    arg9 = (*jenv)->GetArrayLength(jenv, jarg8);
+    arg8 = (double*)MALLOC(sizeof(double) * arg9);
+    
+    isCopy = JNI_FALSE;
+    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg8, &isCopy);
+    memcpy(arg8, element, sizeof(double) * arg9);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg8, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jdouble* element = NULL;
+    // Convert the double[][] => double *
+    arg11 = (*jenv)->GetArrayLength(jenv, jarg10);
+    arg10 = (double*)MALLOC(sizeof(double) * arg11);
+    
+    isCopy = JNI_FALSE;
+    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg10, &isCopy);
+    memcpy(arg10, element, sizeof(double) * arg11);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg10, element, 0); 
+  }
+  result = (int)putComplexSparse(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg4);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg6);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg8);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg10);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    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)
-    {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        int arg2 ;
-        int arg3 ;
-        int *arg4 = (int *) 0 ;
-        int arg5 ;
-        int *arg6 = (int *) 0 ;
-        int arg7 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        arg2 = (int)jarg2;
-        arg3 = (int)jarg3;
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
-            arg4 = (int*)MALLOC(sizeof(int) * arg5);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
-            memcpy(arg4, element, sizeof(int) * arg5);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0);
-        }
-        {
-            jboolean isCopy = JNI_FALSE;
-            jint* element = NULL;
-            // Convert the int[][] => int *
-            arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
-            arg6 = (int*)MALLOC(sizeof(int) * arg7);
-
-            isCopy = JNI_FALSE;
-            element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
-            memcpy(arg6, element, sizeof(int) * arg7);
-            (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0);
-        }
-        result = (int)putBooleanSparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg4);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            FREE(arg6);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        return jresult;
-    }
+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) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int *arg4 = (int *) 0 ;
+  int arg5 ;
+  int *arg6 = (int *) 0 ;
+  int arg7 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  arg2 = (int)jarg2; 
+  arg3 = (int)jarg3; 
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg5 = (*jenv)->GetArrayLength(jenv, jarg4);
+    arg4 = (int*)MALLOC(sizeof(int) * arg5);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg4, &isCopy);
+    memcpy(arg4, element, sizeof(int) * arg5);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg4, element, 0); 
+  }
+  {
+    jboolean isCopy = JNI_FALSE;
+    jint* element = NULL;
+    // Convert the int[][] => int *
+    arg7 = (*jenv)->GetArrayLength(jenv, jarg6);
+    arg6 = (int*)MALLOC(sizeof(int) * arg7);
+    
+    isCopy = JNI_FALSE;
+    element = (jint*)(*jenv)->GetPrimitiveArrayCritical(jenv, jarg6, &isCopy);
+    memcpy(arg6, element, sizeof(int) * arg7);
+    (*jenv)->ReleasePrimitiveArrayCritical(jenv, jarg6, element, 0); 
+  }
+  result = (int)putBooleanSparse(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg4);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    FREE(arg6);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  double **arg3 = (double **) 0 ;
+  int arg4 ;
+  int arg5 ;
+  int *arg6 = (int *) 0 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  arg2 = 0;
+  if (jarg2) {
+    arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
+    if (!arg2) return 0;
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0, k = 0;
+    arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
+    arg5 = 0;
+    arg3 = NULL;
+    
+    for (; i < arg4; i++) {
+      jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
+      if (arg5 == 0) {
+        /* First time we are here, init + create the array where we store the data */
+        arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
+        arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
+        arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
+      }
+      for (j = 0; j < arg5; j++)
+      {
+        jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
+        jboolean isCopy = JNI_FALSE;
+        jdouble* element = NULL;
+        arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
+        isCopy = JNI_FALSE;
+        element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+        memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
+        (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
+        (*jenv)->DeleteLocalRef(jenv, oneDim);
+      }
+      (*jenv)->DeleteLocalRef(jenv, dblDim);
+    }
+  }
+  result = (int)putPolynomial(arg1,arg2,arg3,arg4,arg5,arg6);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    int i = 0;
+    for (; i < arg4 * arg5; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        char *arg2 = (char *) 0 ;
-        double **arg3 = (double **) 0 ;
-        int arg4 ;
-        int arg5 ;
-        int *arg6 = (int *) 0 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        arg2 = 0;
-        if (jarg2)
-        {
-            arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
-            if (!arg2) return 0;
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0, k = 0;
-            arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
-            arg5 = 0;
-            arg3 = NULL;
-
-            for (; i < arg4; i++)
-            {
-                jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
-                if (arg5 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
-                    arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
-                    arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
-                }
-                for (j = 0; j < arg5; j++)
-                {
-                    jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
-                    jboolean isCopy = JNI_FALSE;
-                    jdouble* element = NULL;
-                    arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
-                    isCopy = JNI_FALSE;
-                    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-                    memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
-                    (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
-                    (*jenv)->DeleteLocalRef(jenv, oneDim);
-                }
-                (*jenv)->DeleteLocalRef(jenv, dblDim);
-            }
-        }
-        result = (int)putPolynomial(arg1, arg2, arg3, arg4, arg5, arg6);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            int i = 0;
-            for (; i < arg4 * arg5; i++)
-            {
-                FREE(arg3[i]);
-            }
-            FREE(arg3);
-            FREE(arg6);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
-        return jresult;
+      FREE(arg3[i]);
     }
+    FREE(arg3);
+    FREE(arg6);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
+  return jresult;
+}
 
 
-    SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putComplexPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3, jobjectArray jarg7)
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putComplexPolynomial(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jobjectArray jarg3, jobjectArray jarg7) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  double **arg3 = (double **) 0 ;
+  int arg4 ;
+  int arg5 ;
+  int *arg6 = (int *) 0 ;
+  double **arg7 = (double **) 0 ;
+  int arg8 ;
+  int arg9 ;
+  int *arg10 = (int *) 0 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  arg2 = 0;
+  if (jarg2) {
+    arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
+    if (!arg2) return 0;
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0, k = 0;
+    arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
+    arg5 = 0;
+    arg3 = NULL;
+    
+    for (; i < arg4; i++) {
+      jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
+      if (arg5 == 0) {
+        /* First time we are here, init + create the array where we store the data */
+        arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
+        arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
+        arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
+      }
+      for (j = 0; j < arg5; j++)
+      {
+        jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
+        jboolean isCopy = JNI_FALSE;
+        jdouble* element = NULL;
+        arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
+        isCopy = JNI_FALSE;
+        element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+        memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
+        (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
+        (*jenv)->DeleteLocalRef(jenv, oneDim);
+      }
+      (*jenv)->DeleteLocalRef(jenv, dblDim);
+    }
+  }
+  {
+    // Convert the double[][] => double *
+    int i = 0, j = 0, k = 0;
+    arg8 = (*jenv)->GetArrayLength(jenv, jarg7);
+    arg9 = 0;
+    arg7 = NULL;
+    
+    for (; i < arg8; i++) {
+      jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg7, i);
+      if (arg9 == 0) {
+        /* First time we are here, init + create the array where we store the data */
+        arg9 = (*jenv)->GetArrayLength(jenv, dblDim);
+        arg7 = (double**)malloc(sizeof(double*) * arg8 * arg9);
+        arg10 = (int*)malloc(sizeof(int) * arg8 * arg9);
+      }
+      for (j = 0; j < arg9; j++)
+      {
+        jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
+        jboolean isCopy = JNI_FALSE;
+        jdouble* element = NULL;
+        arg10[j * arg8 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
+        arg7[j * arg8 + i] = (double*)MALLOC(sizeof(jdouble) * arg10[j * arg8 + i]);
+        isCopy = JNI_FALSE;
+        element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
+        memcpy(arg7[j * arg8 + i], element, sizeof(jdouble) * arg10[j * arg8 + i]);
+        (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
+        (*jenv)->DeleteLocalRef(jenv, oneDim);
+      }
+      (*jenv)->DeleteLocalRef(jenv, dblDim);
+    }
+  }
+  result = (int)putComplexPolynomial(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+  jresult = (jint)result; 
+  {
+    // Specific target because it was freeing the wrong argument
+    int i = 0;
+    for (; i < arg4 * arg5; i++)
     {
-        jint jresult = 0 ;
-        char *arg1 = (char *) 0 ;
-        char *arg2 = (char *) 0 ;
-        double **arg3 = (double **) 0 ;
-        int arg4 ;
-        int arg5 ;
-        int *arg6 = (int *) 0 ;
-        double **arg7 = (double **) 0 ;
-        int arg8 ;
-        int arg9 ;
-        int *arg10 = (int *) 0 ;
-        int result;
-
-        (void)jenv;
-        (void)jcls;
-        arg1 = 0;
-        if (jarg1)
-        {
-            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-            if (!arg1) return 0;
-        }
-        arg2 = 0;
-        if (jarg2)
-        {
-            arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
-            if (!arg2) return 0;
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0, k = 0;
-            arg4 = (*jenv)->GetArrayLength(jenv, jarg3);
-            arg5 = 0;
-            arg3 = NULL;
-
-            for (; i < arg4; i++)
-            {
-                jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg3, i);
-                if (arg5 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg5 = (*jenv)->GetArrayLength(jenv, dblDim);
-                    arg3 = (double**)malloc(sizeof(double*) * arg4 * arg5);
-                    arg6 = (int*)malloc(sizeof(int) * arg4 * arg5);
-                }
-                for (j = 0; j < arg5; j++)
-                {
-                    jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
-                    jboolean isCopy = JNI_FALSE;
-                    jdouble* element = NULL;
-                    arg6[j * arg4 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg3[j * arg4 + i] = (double*)MALLOC(sizeof(jdouble) * arg6[j * arg4 + i]);
-                    isCopy = JNI_FALSE;
-                    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-                    memcpy(arg3[j * arg4 + i], element, sizeof(jdouble) * arg6[j * arg4 + i]);
-                    (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
-                    (*jenv)->DeleteLocalRef(jenv, oneDim);
-                }
-                (*jenv)->DeleteLocalRef(jenv, dblDim);
-            }
-        }
-        {
-            // Convert the double[][] => double *
-            int i = 0, j = 0, k = 0;
-            arg8 = (*jenv)->GetArrayLength(jenv, jarg7);
-            arg9 = 0;
-            arg7 = NULL;
-
-            for (; i < arg8; i++)
-            {
-                jobjectArray dblDim = (jobjectArray)(*jenv)->GetObjectArrayElement(jenv, jarg7, i);
-                if (arg9 == 0)
-                {
-                    /* First time we are here, init + create the array where we store the data */
-                    arg9 = (*jenv)->GetArrayLength(jenv, dblDim);
-                    arg7 = (double**)malloc(sizeof(double*) * arg8 * arg9);
-                    arg10 = (int*)malloc(sizeof(int) * arg8 * arg9);
-                }
-                for (j = 0; j < arg9; j++)
-                {
-                    jdoubleArray oneDim = (jdoubleArray)(*jenv)->GetObjectArrayElement(jenv, dblDim, j);
-                    jboolean isCopy = JNI_FALSE;
-                    jdouble* element = NULL;
-                    arg10[j * arg8 + i] = (*jenv)->GetArrayLength(jenv, oneDim);
-                    arg7[j * arg8 + i] = (double*)MALLOC(sizeof(jdouble) * arg10[j * arg8 + i]);
-                    isCopy = JNI_FALSE;
-                    element = (jdouble*)(*jenv)->GetPrimitiveArrayCritical(jenv, oneDim, &isCopy);
-                    memcpy(arg7[j * arg8 + i], element, sizeof(jdouble) * arg10[j * arg8 + i]);
-                    (*jenv)->ReleasePrimitiveArrayCritical(jenv, oneDim, element, 0);
-                    (*jenv)->DeleteLocalRef(jenv, oneDim);
-                }
-                (*jenv)->DeleteLocalRef(jenv, dblDim);
-            }
-        }
-        result = (int)putComplexPolynomial(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
-        jresult = (jint)result;
-        {
-            // Specific target because it was freeing the wrong argument
-            int i = 0;
-            for (; i < arg4 * arg5; i++)
-            {
-                FREE(arg3[i]);
-            }
-            FREE(arg3);
-            FREE(arg6);
-        }
-        {
-            // Specific target because it was freeing the wrong argument
-            int i = 0;
-            for (; i < arg8 * arg9; i++)
-            {
-                FREE(arg7[i]);
-            }
-            FREE(arg7);
-            FREE(arg10);
-        }
-        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
-        return jresult;
+      FREE(arg3[i]);
     }
+    FREE(arg3);
+    FREE(arg6);
+  }
+  {
+    // Specific target because it was freeing the wrong argument
+    int i = 0;
+    for (; i < arg8 * arg9; i++)
+    {
+      FREE(arg7[i]);
+    }
+    FREE(arg7);
+    FREE(arg10);
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
+  return jresult;
+}
 
 
 #ifdef __cplusplus
index beeb036..2ca008b 100644 (file)
@@ -59,7 +59,6 @@ knowledge of the CeCILL-B license and that you accept its terms.
         #endif
 
 
-
 #ifndef GIWSEXPORT
 # if defined(_MSC_VER) || defined(__WIN32__) || defined(__CYGWIN__)
 #   if defined(STATIC_LINKED)
index e8b3074..b58ce7d 100644 (file)
@@ -59,7 +59,6 @@ knowledge of the CeCILL-B license and that you accept its terms.
         #endif
 
 
-
 #ifndef GIWSEXPORT
 # if defined(_MSC_VER) || defined(__WIN32__) || defined(__CYGWIN__)
 #   if defined(STATIC_LINKED)