diff --git a/Examples/test-suite/scilab/Makefile.in b/Examples/test-suite/scilab/Makefile.in
index 81931d41c..df7de6990 100644
--- a/Examples/test-suite/scilab/Makefile.in
+++ b/Examples/test-suite/scilab/Makefile.in
@@ -9,7 +9,6 @@ srcdir       = @srcdir@
 top_srcdir   = @top_srcdir@
 top_builddir = @top_builddir@
 
-
 include $(srcdir)/../common.mk
 
 # Overridden variables here
@@ -17,7 +16,7 @@ include $(srcdir)/../common.mk
 
 # Rules for the different types of tests
 %.cpptest: 
-	
+		
 %.ctest:
 	$(setup)
 	cp ../$*.i $*.i
@@ -37,7 +36,7 @@ run_testcase = \
 
 # Clean: remove the generated .sci file
 %.clean:
-	@rm -f $*.sci *_wrap.c *.i *.h
+	@rm -f $*.sci *_wrap.c *.i *.h *_wrap.cxx
 
 clean:
 	$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile scilab_clean
diff --git a/Examples/test-suite/scilab/integers_runme.sci b/Examples/test-suite/scilab/integers_runme.sci
deleted file mode 100644
index e971d090f..000000000
--- a/Examples/test-suite/scilab/integers_runme.sci
+++ /dev/null
@@ -1,13 +0,0 @@
-exec loader.sce;
-
-if signed_char_identity(-13) <> -13 then pause, end
-if unsigned_char_identity(251) <> 251 then pause, end
-if signed_short_identity(-31000) <> -31000 then pause, end
-if unsigned_short_identity(61000) <> 61000 then pause, end
-if signed_int_identity(42) <> 42 then pause, end
-if unsigned_int_identity(123456) <> 123456 then pause, end
-if signed_long_identity(65537) <> 65537 then pause, end
-if unsigned_long_identity(654321) <> 654321 then pause, end
-
-exit
-
diff --git a/Lib/scilab/scifragments.swg b/Lib/scilab/scifragments.swg
deleted file mode 100644
index e69de29bb..000000000
diff --git a/Lib/scilab/scilab.swg b/Lib/scilab/scilab.swg
index 094a96738..ac24d159f 100644
--- a/Lib/scilab/scilab.swg
+++ b/Lib/scilab/scilab.swg
@@ -1,6 +1,5 @@
 %include <typemaps/swigmacros.swg>
 %include <typemaps/fragments.swg>
 %include <sciruntime.swg>
-%include <sciprimtypes.swg>
 %include <scitypemaps.swg>
 
diff --git a/Lib/scilab/sciprimtypes.swg b/Lib/scilab/sciprimtypes.swg
deleted file mode 100644
index 8b1378917..000000000
--- a/Lib/scilab/sciprimtypes.swg
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/Lib/scilab/sciruntime.swg b/Lib/scilab/sciruntime.swg
index 06a7d792b..65db5970d 100644
--- a/Lib/scilab/sciruntime.swg
+++ b/Lib/scilab/sciruntime.swg
@@ -1,10 +1,15 @@
 %insert(runtime) "swigrun.swg";
 %insert(runtime) "swigerrors.swg";
 %insert(runtime) %{
-
+#ifdef __cplusplus
+extern "C" {
+#endif
 void SWIG_Error(int code, const char *msg) {
   Scierror(code, _("%s\n"), msg);
 }
+#ifdef __cplusplus
+}
+#endif
 
 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(999, msg); } else 
 
diff --git a/Lib/scilab/scitypemaps.swg b/Lib/scilab/scitypemaps.swg
index f4a89db2a..81c903f2f 100644
--- a/Lib/scilab/scitypemaps.swg
+++ b/Lib/scilab/scitypemaps.swg
@@ -1,16 +1,3 @@
-
-// Include fundamental fragemt definitions
-%include <typemaps/fragments.swg>
-
-// Look for user fragments file.
-%include <scifragments.swg>
-
-// Scilab fragments for primitive types
-%include <sciprimtypes.swg>
-
-// Include the unified typemap library
-//%include <typemaps/swigtypemaps.swg>
-
 /* -----------------------------------------------------------------------------
  * --- Input arguments --- 
  * ----------------------------------------------------------------------------- */
@@ -25,7 +12,9 @@
 	     long (int iRows, int iCols),
 	     unsigned long (int iRows, int iCols),
 	     float (int iRows, int iCols),
-	     double (int iRows, int iCols) {
+	     double (int iRows, int iCols),
+             long long (int iRows, int iCols),
+             unsigned long long (int iRows, int iCols) {
   int *piAddrVar;
   double *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
@@ -34,7 +23,7 @@
   if (getVarType(piAddrVar) != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
@@ -48,7 +37,7 @@
   if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)*_pstStrings;
 }
 
@@ -62,7 +51,9 @@
 	     long *,
 	     unsigned long *,
              double *,
-             float * {
+             float *,
+             long long *,
+             unsigned long long * {
   int *piAddrVar;
   void *_piData = NULL;
   getVarAddressFromPosition($argnum, &piAddrVar);
@@ -70,7 +61,7 @@
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
@@ -86,61 +77,106 @@
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength + 1);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, &_pstStrings);
-  $1 = strdup(_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
+  $1 = ($1_ltype)strdup(_pstStrings);
   free(_pstStrings);
 }
 
 %typemap(in) signed char [ANY] (int iRows, int iCols) {
   int *piAddrVar;
   char *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
-%typemap(in) short [ANY] (int iRows, int iCols),
-             unsigned char [ANY] (int iRows, int iCols) {
+%typemap(in) unsigned char [ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned char *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(in) short [ANY] (int iRows, int iCols) {
   int *piAddrVar;
   short *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
-%typemap(in) unsigned short [ANY] (int iRows, int iCols),
-	     int [ANY] (int iRows, int iCols),
-	     unsigned int [ANY] (int iRows, int iCols),
-	     long [ANY] (int iRows, int iCols),
-	     unsigned long [ANY] (int iRows, int iCols) {
+%typemap(in) unsigned short [ANY] (int iRows, int iCols) {
   int *piAddrVar;
-  int *_piData;
-  int index;
+  unsigned short *_piData;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(in) int [ANY] (int iRows, int iCols),
+	     long [ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  int *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(in) unsigned int [ANY] (int iRows, int iCols),
+	     unsigned long [ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned int *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
@@ -148,16 +184,48 @@
              float [ANY] (int iRows, int iCols) {
   int *piAddrVar;
   double *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++){
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++){
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(in) long long [ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  long long *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++){
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(in) unsigned long long [ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned long long *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++){
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
@@ -171,8 +239,8 @@
   if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1 = strdup(_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
+  $1 = ($1_ltype)strdup(_pstStrings);
 }
 
 /* Arrays */
@@ -185,22 +253,36 @@
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1 != NULL) {
-    free($1);
-  }
-  $1 = ($1_ltype)malloc(iRows * sizeof($*1_ltype));
-  size_t ii;
-  for(ii = 0; ii < iRows; ii++){
-    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
-    size_t jj;
-    for(jj=0; jj < iCols; jj++)
-    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
+  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
   }
 }
 
-%typemap(in) short [ANY][ANY] (int iRows, int iCols),
-             unsigned char [ANY][ANY] (int iRows, int iCols) {
+%typemap(in) unsigned char [ANY][ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned char *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(in) short [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
   short *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
@@ -209,25 +291,37 @@
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1 != NULL) {
-    free($1);
-  }
-  $1 = ($1_ltype)malloc(iRows*sizeof($*1_ltype));
-  size_t ii;
-  for(ii = 0; ii < iRows; ii++){
-    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
-    size_t jj;
-    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
+  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
   }
 }
 
-%typemap(in) unsigned short [ANY][ANY] (int iRows, int iCols),
-             int [ANY][ANY] (int iRows, int iCols), 
-             unsigned int [ANY][ANY] (int iRows, int iCols),
-             long [ANY][ANY] (int iRows, int iCols),
-             unsigned long [ANY][ANY] (int iRows, int iCols){
+%typemap(in) unsigned short [ANY][ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned short *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+ 
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(in) int [ANY][ANY] (int iRows, int iCols), 
+             long [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
   int *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
@@ -236,20 +330,35 @@
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1 != NULL) {
-    free($1);
-  }
-  $1 = ($1_ltype)malloc(iRows*sizeof($*1_ltype));
-  size_t ii;
-  for(ii = 0; ii < iRows;ii++){
-    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
-    size_t jj;
-    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
   }
 }
 
+%typemap(in) unsigned int [ANY][ANY] (int iRows, int iCols), 
+             unsigned long [ANY][ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned int *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
 
 %typemap(in) double [ANY][ANY] (int iRows, int iCols),
              float [ANY][ANY] (int iRows, int iCols) {
@@ -261,17 +370,51 @@
   if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1 != NULL) {
-    free($1);
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
   }
-  $1 = ($1_ltype)malloc(iRows * sizeof($*1_ltype));
-  size_t ii;
-  for(ii = 0; ii < iRows; ii++){
-    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
-    size_t jj;
-    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
+}
+
+%typemap(in) long long [ANY][ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  long long *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(in) unsigned long long [ANY][ANY] (int iRows, int iCols) {
+  int *piAddrVar;
+  unsigned long long *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
   }
 }
 
@@ -284,7 +427,7 @@
   if (getVarType(piAddrVar) != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
@@ -296,7 +439,7 @@
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
@@ -308,7 +451,7 @@
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = *(($&1_ltype)_piData);
 }
 
@@ -320,58 +463,66 @@
 %typemap(out) signed char (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &$result);
+  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, (char *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned char (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, &$result);
+  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, (unsigned char *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) short (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &$result);
+  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, (short *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned short (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, &$result);
+  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, (unsigned short *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) int (int iRowsOut, int iColsOut),
               long (int iRowsOut, int iColsOut) {
-  int temp;
-  temp = (int)($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned int (int iRowsOut, int iColsOut),
               unsigned long (int iRowsOut, int iColsOut) {
-  int temp;
-  temp = (int)($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, (unsigned int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) double (int iRowsOut, int iColsOut),
               float (int iRowsOut, int iColsOut) {
-  double temp;
-  temp = (double)($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, (double *)&$result);
+  LhsVar(iOutNum) = iVarOut;
+}
+
+%typemap(out) long long (int iRowsOut, int iColsOut) {
+  iRowsOut = 1; 
+  iColsOut = 1;
+  createMatrixOfInteger64(iVarOut, iRowsOut, iColsOut, (long long *)&$result);
+  LhsVar(iOutNum) = iVarOut;
+}
+
+%typemap(out) unsigned long long (int iRowsOut, int iColsOut) {
+  iRowsOut = 1; 
+  iColsOut = 1;
+  createMatrixOfUnsignedInteger64(iVarOut, iRowsOut, iColsOut, (unsigned long long *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -380,7 +531,7 @@
   temp = (char*)&($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -398,24 +549,24 @@
 	      long *,
 	      unsigned long *,
               double *,
-              float * {
+              float *,
+              long long,
+              unsigned long long * {
   createPointer(iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) char *(int iRowsOut, int iColsOut) {
+%typemap(out) char * (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, &($result));
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&($result));
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) enum SWIGTYPE (int iRowsOut, int iColsOut) {
-  int temp;
-  temp = (int)($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -452,7 +603,7 @@
   if (getVarType(piAddrVar) != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
@@ -465,7 +616,7 @@
   if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)*_pstStrings;
 }
 
@@ -480,8 +631,8 @@
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength + 1);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, &_pstStrings);
-  $1 = strdup(_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
+  $1 = ($1_ltype)strdup(_pstStrings);
   free(_pstStrings);
 }
 
@@ -497,116 +648,146 @@
   
   getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, &_pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
   strcpy($1, _pstStrings);
   free(_pstStrings);
 }
 
 %typemap(varin,noblock=1) signed char [ANY] {
   char *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) unsigned char [ANY] {
-  short *_piData;
-  int index;
+  unsigned char *_piData;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) short [ANY] {
   short *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) unsigned short [ANY] {
-  short *_piData;
-  int index;
+  unsigned short *_piData;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) int [ANY],
 	                  long [ANY] {
   int *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) unsigned int [ANY],
 	                  unsigned long [ANY] {
-  int *_piData;
-  int index;
+  unsigned int *_piData;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++) {
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
 %typemap(varin,noblock=1) double [ANY],
                           float [ANY] {
   double *_piData;
-  int index;
+  size_t ii = 0;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  for(index = 0; index < $1_dim0; index++){
-    $1[index] = ($*1_ltype)_piData[index];
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++){
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(varin,noblock=1) long long [ANY] {
+  int *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
+  }
+}
+
+%typemap(varin,noblock=1) unsigned long long [ANY] {
+  int *_piData;
+  size_t ii = 0;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  for(; ii < (size_t)$1_dim0; ii++) {
+    $1[ii] = ($*1_ltype)_piData[ii];
   }
 }
 
@@ -619,14 +800,16 @@
 	                  long *,
 	                  unsigned long *,
                           double *,
-                          float * {
+                          float *, 
+                          long long *,
+                          unsigned long long * {
   void *_piData = NULL;
   getVarAddressFromPosition($argnum, &piAddrVar);
   
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
@@ -648,11 +831,177 @@
   for(i = 0; i < iRows * iCols; i++) {
     _pstStrings[i] = (char*)malloc((_piLength[i] + 1) * sizeof(char));
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, _pstStrings);
+  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, (char **)_pstStrings);
   
   $1 = _pstStrings;
 }
 
+/* Arrays */
+%typemap(varin,noblock=1) signed char [ANY][ANY] {
+  char *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) unsigned char [ANY][ANY] {
+  unsigned char *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) short [ANY][ANY] {
+  short *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) unsigned short [ANY][ANY] {
+  unsigned short *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) int [ANY][ANY], 
+                          long [ANY][ANY] {
+  int *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) unsigned int [ANY][ANY],
+                          unsigned long [ANY][ANY] {
+  unsigned int *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) double [ANY][ANY],
+                          float [ANY][ANY] {
+  double *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+ 
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) long long [ANY][ANY] {
+  long long *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
+%typemap(varin,noblock=1) unsigned long long [ANY][ANY] {
+  unsigned long long *_piData;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = ($1_basetype)_piData[jj * $1_dim0+ii];
+  }
+}
+
 %typemap(varin,noblock=1) enum SWIGTYPE {
   int *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
@@ -661,7 +1010,7 @@
   if (getVarType(piAddrVar) != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
+  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 %typemap(varin,noblock=1) SWIGTYPE * {
@@ -671,21 +1020,38 @@
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
 %typemap(varin,noblock=1) SWIGTYPE [ANY] {
   void *_piData = NULL;
-  int index;
+  size_t ii;
   getVarAddressFromPosition($argnum, &piAddrVar);
   
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
-  for(index = 0; index < $1_dim0; index++){
-    $1[index] = (($1_ltype)_piData)[index];
+  getPointer(piAddrVar, (void **)&_piData);
+  for(ii = 0; ii < $1_dim0; ii++){
+    $1[ii] = (($1_ltype)_piData)[ii];
+  }
+}
+
+%typemap(varin,noblock=1) SWIGTYPE [ANY][ANY] {
+  void *_piData = NULL;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  
+  if (getVarType(piAddrVar) != sci_lufact_pointer) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
+  }
+  getPointer(piAddrVar, (void **)&_piData);
+  
+  size_t ii = 0;
+  for(; ii < (size_t)$1_dim0; ii++){
+    size_t jj = 0;
+    for(; jj < (size_t)$1_dim1; jj++)
+      $1[ii][jj] = (($1_basetype *)_piData)[jj * $1_dim0+ii];
   }
 }
 
@@ -696,7 +1062,7 @@
   if (getVarType(piAddrVar) != sci_lufact_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, &_piData);
+  getPointer(piAddrVar, (void **)&_piData);
   $1 = *(($&1_ltype)_piData);
 }
 
@@ -705,64 +1071,60 @@
  * ----------------------------------------------------------------------------- */
 /* Basic C types */
 %typemap(varout,noblock=1) signed char {
-  signed char temp = $result;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp);
+  char temp = $result;
+  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, (char *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned char {
   unsigned char temp = $result;
-  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, (unsigned char *)&temp);
   LhsVar(iOutNum) = iVarOut;
+
 }
 
 %typemap(varout,noblock=1) short {
   short temp = $result;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, (short *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned short {
   unsigned short temp = $result;
-  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, (unsigned short *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) int,
                            long {
   int temp = $result;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned int,
                            unsigned long {
   unsigned int temp = $result;
-  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, (unsigned int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(varout,noblock=1) double {
+%typemap(varout,noblock=1) double,
+                           float {
   double temp = $result;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum) = iVarOut;
-}
-
-%typemap(varout,noblock=1) float {
-  double temp = $result;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, (double *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) long long {
   long long temp = $result;
-  createMatrixOfInteger64(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger64(iVarOut, iRowsOut, iColsOut, (long long *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned long long {
   unsigned long long temp = $result;
-  createMatrixOfUnsignedInteger64(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfUnsignedInteger64(iVarOut, iRowsOut, iColsOut, (unsigned long long *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -770,14 +1132,14 @@
   char *temp = (char *)malloc(sizeof($result) + 1);
   *temp = $result;
   *(temp+1) = '\0';
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
   free(temp);
 }
 
 %typemap(varout,noblock=1) char * {
   char *temp = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -791,7 +1153,9 @@
 	                   long *,
 	                   unsigned long *,
                            double *,
-                           float * {
+                           float *,
+                           long long *,
+                           unsigned long long * {
   createPointer(iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
@@ -801,7 +1165,7 @@
   char **pstData = NULL;
   pstData = (char **)malloc(sizeof(char *));
   pstData[0] = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, pstData);
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)pstData);
   LhsVar(iOutNum) = iVarOut;
    
 }
@@ -848,18 +1212,27 @@
   LhsVar(iOutNum) = iVarOut;
 }
 
+%typemap(varout,noblock=1) long long [ANY] {
+  createMatrixOfInteger64(iVarOut, 1, $1_dim0, (long long *)$result);
+  LhsVar(iOutNum) = iVarOut;
+}
+
+%typemap(varout,noblock=1) unsigned long long [ANY] {
+  createMatrixOfUnsignedInteger64(iVarOut, 1, $1_dim0, (unsigned long long *)$result);
+  LhsVar(iOutNum) = iVarOut;
+}
+
 %typemap(varout,noblock=1) char ** {
   char **pstData = NULL;
   pstData = (char **)malloc(iRowsOut * iColsOut * sizeof(char*));
   pstData = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, pstData);
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)pstData);
   LhsVar(iOutNum) = iVarOut;
 }
 
 /* Enums */
 %typemap(varout,noblock=1) enum SWIGTYPE {
-  int temp = $result;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
diff --git a/Source/Modules/scilab.cxx b/Source/Modules/scilab.cxx
index c576329f8..a679f2717 100644
--- a/Source/Modules/scilab.cxx
+++ b/Source/Modules/scilab.cxx
@@ -188,7 +188,7 @@ public:
     if (overloaded)
       Append(overname, Getattr(n, "sym:overname"));
 
-    Printv(f->def, "int ", overname, " (char *fname,unsigned long fname_len) {\n", NIL);
+    Printv(f->def, "int ", overname, " (char *fname, unsigned long fname_len) {\n", NIL);
    
     /* Emit all of the local variables for holding arguments */
     emit_parameter_variables(l, f);
@@ -361,7 +361,7 @@ public:
     String *dispatch = Swig_overload_dispatch(n, "return %s(fname, fname_len);", &maxargs);
     String *tmp = NewString("");
 
-    Printv(f->def, "int ", wname, " (char *fname,unsigned long fname_len) {\n", NIL);
+    Printv(f->def, "int ", wname, " (char *fname, unsigned long fname_len) {\n", NIL);
     Wrapper_add_local(f, "argc", "int argc = Rhs;");
     //Printf(tmp, "octave_value_ref argv[%d]={", maxargs);
     //for (int j = 0; j < maxargs; ++j)
@@ -369,7 +369,7 @@ public:
     //Printf(tmp, "}");
     //Wrapper_add_local(f, "argv", tmp);
     Printv(f->code, dispatch, "\n", NIL);
-    Printf(f->code, "error(\"No matching function for overload\");\n", iname);
+    Printf(f->code, "Scierror(999, _(\"No matching function for overload\"));\n");
     Printf(f->code, "return 0;\n");
     Printv(f->code, "}\n", NIL);
 
@@ -418,7 +418,7 @@ public:
       Printf(globalVar, "int %s = 0;\n\n", iscomplexname);
     else
       Printf(globalVar, "\n");
-    Printv(setf->def, "int ", setname, " (char *fname,unsigned long fname_len) {\n", NIL);
+    Printv(setf->def, "int ", setname, " (char *fname, unsigned long fname_len) {\n", NIL);
     
     /* Check the number of input and output */
     Printf(setf->def, "CheckRhs(1, 1);\n");
@@ -453,7 +453,7 @@ public:
     /* deal with the get function */
     Setattr(n, "wrap:name", getname);
     int addfail = 0;
-    Printv(getf->def, "int ", getname, " (char *fname,unsigned long fname_len){\n", NIL);
+    Printv(getf->def, "int ", getname, " (char *fname, unsigned long fname_len){\n", NIL);
    
     /* Check the number of input and output */
     Printf(getf->def, "CheckRhs(0, 0);\n");
@@ -519,7 +519,7 @@ public:
     String *getname = Swig_name_get(iname);
     Setattr(n, "wrap:name", getname);
     int addfail = 0;
-    Printv(getf->def, "int ", getname, " (char *fname,unsigned long fname_len){\n", NIL);
+    Printv(getf->def, "int ", getname, " (char *fname, unsigned long fname_len){\n", NIL);
    
     /* Check the number of input and output */
     Printf(getf->def, "CheckRhs(0, 0);\n");