added some pointer support and fixed style problem

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2009-sploving@11415 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/Makefile.in

@@ -1153,6 +1153,12 @@ SCILAB        = @SCILAB@
 scilab: $(SRCS)
 	$(SWIG) -scilab $(SWIGOPT) $(INTERFACEPATH)
 
+# ----------------------------------------------------------------- 
+# Running a Scilab example
+# ----------------------------------------------------------------- 
+
+scilab_run:
+	 env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH SCILABPATH=$(srcdir):$$SCILABPATH $(SCILAB) -nwni < runme.sci
 	
 # -----------------------------------------------------------------
 # Cleaning the scilab examples

Examples/octave/pointer/Makefile

@@ -1,6 +1,6 @@
 TOP        = ../..
 SWIG       = $(TOP)/../preinst-swig
-SRCS       = example.c
+SRCS       = example.i
 TARGET     = example
 INTERFACE  = example.i
 

Examples/octave/pointer/example.i

@@ -1,30 +1,6 @@
 /* File : example.i */
 %module example
-
+FILE *fopen(char *filename, char *mode);
-%{
+int fputs(char* , FILE *);
-extern void add(int *, int *, int *);
+int fclose(FILE *);
-extern void sub(int *, int *, int *);
-extern int divide(int, int, int *);
-%}
-
-/* This example illustrates a couple of different techniques
-   for manipulating C pointers */
-
-/* First we'll use the pointer library */
-extern void add(int *x, int *y, int *result);
-%include cpointer.i
-%pointer_functions(int, intp);
-
-/* Next we'll use some typemaps */
-
-%include typemaps.i
-extern void sub(int *INPUT, int *INPUT, int *OUTPUT);
-
-/* Next we'll use typemaps and the %apply directive */
-
-%apply int *OUTPUT { int *r };
-extern int divide(int n, int d, int *r);
-
-
-
 

Examples/python/pointer/Makefile

@@ -1,6 +1,6 @@
 TOP        = ../..
 SWIG       = $(TOP)/../preinst-swig
-SRCS       = example.c
+SRCS       = example.i
 TARGET     = example
 INTERFACE  = example.i
 

Examples/scilab/constants/runme.sci

@@ -20,3 +20,5 @@ try
 catch
   printf("FOO is not defined (good)\n");
 end
+
+exit

Examples/scilab/contract/runme.sci

@@ -32,3 +32,7 @@ y=105;
 g=gcd(x,y);
 printf("The gcd of %d and %d is %d\n",x,y,g);
 
+exit
+
+
+

Examples/scilab/enum/runme.sci

@@ -20,3 +20,5 @@ enum_test(color.BLUE);
 enum_test(color.GREEN);
 enum_test(1234);
 
+exit
+

Examples/scilab/pointer/runme.sci

@@ -18,3 +18,5 @@ printf("Testing multiple return values\n");
 [q,r] = divide(42,37);
 printf("     42/37 = %d remainder %d\n",q,r);
 
+exit
+

Examples/scilab/simple/runme.sci

@@ -22,3 +22,5 @@ Foo_set(3.1415926)
 // See if the change took effect
 Foo_get()
 
+exit
+

Examples/scilab/variables/example.c

@@ -23,9 +23,12 @@ char             cvar = 0;
 float            fvar = 0;
 double           dvar = 0;
 char            *strvar=0;
+char             name[5] = "Dave";
 double          *Foo1;
 double          *Foo2;
-
+int             *pivar;
+short           *psvar;
+char            **foo;
 
 
 /* A debugging function to print out their values */
@@ -43,6 +46,7 @@ void print_vars() {
   printf("dvar      = %g\n", dvar);
   printf("cvar      = %c\n", cvar);
   printf("strvar    = %s\n",strvar);
+  printf("name      = %c%c%c%c%c\n", name[0],name[1],name[2],name[3],name[4]);
 }
 
 

Examples/scilab/variables/example.i

@@ -17,8 +17,12 @@
     extern float            fvar;
     extern double           dvar;
     extern char            *strvar;
+    extern char             name[256];
     extern double          *Foo1;
     extern double          *Foo2;
+    extern int             *pivar;
+    extern short             *psvar;
+    extern char            **foo;
 %}
 
 

Examples/scilab/variables/runme.sci

@@ -18,8 +18,16 @@ cvar_set  ("S");
 fvar_set  (3.14159);
 dvar_set  (2.1828);
 strvar_set("Hello World");
+name_set ("Bill");
 Foo1_set([1,2,3;4,5,6]);
 Foo2_set([1+2*%i,2+3*%i;3+4*%i,7+8*%i]);
+pivar_set(int32([   1   2   3   4   5; 
+                6   7   8   9   10; 
+                11  12  13  14  15]));
+psvar_set(int16([   1   2   3   4   5; 
+                6   7   8   9   10; 
+                11  12  13  14  15]));
+foo_set(["sample", "strings", "manipulation"; "with","gateway","API"]);
 
 // Now print out the values of the variables
 
@@ -37,10 +45,16 @@ printf("fvar      = %f\n", fvar_get());
 printf("dvar      = %f\n", dvar_get());
 printf("cvar      = %s\n", cvar_get());
 printf("strvar    = %s\n", strvar_get());
+printf("name      = %s\n", name_get());
 Foo1_get()
 Foo2_get()
+pivar_get()
+psvar_get()
+foo_get()
 
 printf("\nVariables (values printed from C)\n");
 
-print_vars();
+print_vars()
+
+exit
 

Lib/scilab/scitypemaps.swg

@@ -26,7 +26,7 @@
 	     unsigned long (int *piAddrVar, int iRows, int iCols),
 	     float (int *piAddrVar, int iRows, int iCols),
 	     double (int *piAddrVar, int iRows, int iCols) {
-  double* _piData;
+  double *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -34,11 +34,11 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)*_piData;
+  $1 = ($1_ltype)*_piData;
 }
 
 %typemap(in) char (int *piAddrVar, int iRows, int iCols) {   
-  char* _pstStrings;
+  char *_pstStrings;
   int _piLength;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -47,13 +47,13 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1=($1_ltype)*_pstStrings;
+  $1 = ($1_ltype)*_pstStrings;
 }
 
 
 /* Pointers */
 %typemap(in) signed char *(int *piAddrVar, int iRows, int iCols) {
-  char* _piData;
+  char *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -62,12 +62,12 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)_piData;
+  $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) short *(int *piAddrVar, int iRows, int iCols),
              unsigned char *(int *piAddrVar, int iRows, int iCols) {
-  short* _piData;
+  short *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -76,7 +76,7 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)_piData;
+  $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) unsigned short *(int *piAddrVar, int iRows, int iCols),
@@ -84,7 +84,7 @@
 	     unsigned int *(int *piAddrVar, int iRows, int iCols),
 	     long *(int *piAddrVar, int iRows, int iCols),
 	     unsigned long *(int *piAddrVar, int iRows, int iCols) {
-  int* _piData;
+  int *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -93,12 +93,12 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)_piData;
+  $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) double *(int *piAddrVar, int iRows, int iCols),
              float *(int *piAddrVar, int iRows, int iCols) {
-  double* _piData;
+  double *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -107,11 +107,11 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)_piData;
+  $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) char *(int *piAddrVar, int iRows, int iCols){
-  char* _pstStrings;
+  char *_pstStrings;
   int _piLength;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -120,11 +120,11 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1=strdup(_pstStrings);
+  $1 = strdup(_pstStrings);
 }
 
-%typemap(in) signed char [ANY](int *piAddrVar, int iRows, int iCols) {
+%typemap(in) signed char [ANY] (int *piAddrVar, int iRows, int iCols) {
-  char* _piData;
+  char *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -133,18 +133,18 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
   $1=($1_ltype)malloc(iRows*iCols*sizeof($*1_ltype));
-  for(index=0;index<iRows*iCols;index++){
+  for(index = 0; index < iRows * iCols; index++) {
-    $1[index]=($*1_ltype)_piData[index];
+    $1[index] = ($*1_ltype)_piData[index];
   }
 }
 
-%typemap(in) short [ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) short [ANY] (int *piAddrVar, int iRows, int iCols),
-             unsigned char [ANY](int *piAddrVar, int iRows, int iCols) {
+             unsigned char [ANY] (int *piAddrVar, int iRows, int iCols) {
-  short* _piData;
+  short *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -153,21 +153,21 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*iCols*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
-  for(index=0;index<iRows*iCols;index++){
+  for(index = 0; index < iRows * iCols; index++) {
-    $1[index]=($*1_ltype)_piData[index];
+    $1[index] = ($*1_ltype)_piData[index];
   }
 }
 
-%typemap(in) unsigned short [ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) unsigned short [ANY] (int *piAddrVar, int iRows, int iCols),
-	     int [ANY](int *piAddrVar, int iRows, int iCols),
+	     int [ANY] (int *piAddrVar, int iRows, int iCols),
-	     unsigned int [ANY](int *piAddrVar, int iRows, int iCols),
+	     unsigned int [ANY] (int *piAddrVar, int iRows, int iCols),
-	     long [ANY](int *piAddrVar, int iRows, int iCols),
+	     long [ANY] (int *piAddrVar, int iRows, int iCols),
-	     unsigned long [ANY](int *piAddrVar, int iRows, int iCols) {
+	     unsigned long [ANY] (int *piAddrVar, int iRows, int iCols) {
-  int* _piData;
+  int *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -176,18 +176,18 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*iCols*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
-  for(index=0;index<iRows*iCols;index++){
+  for(index = 0; index < iRows * iCols; index++) {
-    $1[index]=($*1_ltype)_piData[index];
+    $1[index] = ($*1_ltype)_piData[index];
   }
 }
 
-%typemap(in) double [ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) double [ANY] (int *piAddrVar, int iRows, int iCols),
-             float [ANY](int *piAddrVar, int iRows, int iCols){
+             float [ANY] (int *piAddrVar, int iRows, int iCols){
-  double* _piData;
+  double *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -196,19 +196,19 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*iCols*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
-  for(index=0;index<iRows*iCols;index++){
+  for(index = 0; index < iRows * iCols; index++){
-    $1[index]=($*1_ltype)_piData[index];
+    $1[index] = ($*1_ltype)_piData[index];
   }
 }
 
 
 
-%typemap(in) char [ANY](int *piAddrVar, int iRows, int iCols){
+%typemap(in) char [ANY] (int *piAddrVar, int iRows, int iCols){
-  char* _pstStrings;
+  char *_pstStrings;
   int _piLength;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -217,13 +217,13 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1=strdup(_pstStrings);
+  $1 = strdup(_pstStrings);
 }
 
 
 /* Arrays */
-%typemap(in) signed char [ANY][ANY](int *piAddrVar, int iRows, int iCols) {
+%typemap(in) signed char [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
-  char* _piData;
+  char *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -231,22 +231,22 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger8(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows * sizeof($*1_ltype));
   size_t ii;
-  for(ii=0;ii<iRows;ii++){
+  for(ii = 0; ii < iRows; ii++){
-    $1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
+    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
     size_t jj;
-    for(jj=0;jj<iCols;jj++)
+    for(jj=0; jj < iCols; jj++)
-    $1[ii][jj]=($1_basetype)_piData[jj*iRows+ii];
+    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
   }
 }
 
-%typemap(in) short [ANY][ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) short [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
-             unsigned char [ANY][ANY](int *piAddrVar, int iRows, int iCols) {
+             unsigned char [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
-  short* _piData;
+  short *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -254,25 +254,25 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger16(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows*sizeof($*1_ltype));
   size_t ii;
-  for(ii=0;ii<iRows;ii++){
+  for(ii = 0; ii < iRows; ii++){
-    $1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
+    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
     size_t jj;
-    for(jj=0;jj<iCols;jj++)
+    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj]=($1_basetype)_piData[jj*iRows+ii];
+    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
   }
 }
 
-%typemap(in) unsigned short [ANY][ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) unsigned short [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
-             int [ANY][ANY](int *piAddrVar, int iRows, int iCols), 
+             int [ANY][ANY] (int *piAddrVar, int iRows, int iCols), 
-             unsigned int [ANY][ANY](int *piAddrVar, int iRows, int iCols),
+             unsigned int [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
-             long [ANY][ANY](int *piAddrVar, int iRows, int iCols),
+             long [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
-             unsigned long [ANY][ANY](int *piAddrVar, int iRows, int iCols){
+             unsigned long [ANY][ANY] (int *piAddrVar, int iRows, int iCols){
-  int* _piData;
+  int *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -280,23 +280,23 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfInteger32(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows*sizeof($*1_ltype));
   size_t ii;
-  for(ii=0;ii<iRows;ii++){
+  for(ii = 0; ii < iRows;ii++){
-    $1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
+    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
     size_t jj;
-    for(jj=0;jj<iCols;jj++)
+    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj]=($1_basetype)_piData[jj*iRows+ii];
+    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
   }
 }
 
 
-%typemap(in) double [ANY][ANY](int *piAddrVar, int iRows, int iCols),
+%typemap(in) double [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
-             float [ANY][ANY](int *piAddrVar, int iRows, int iCols) {
+             float [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
-  double* _piData;
+  double *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -304,16 +304,16 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  if($1!=NULL) {
+  if($1 != NULL) {
     free($1);
   }
-  $1=($1_ltype)malloc(iRows*sizeof($*1_ltype));
+  $1 = ($1_ltype)malloc(iRows * sizeof($*1_ltype));
   size_t ii;
-  for(ii=0;ii<iRows;ii++){
+  for(ii = 0; ii < iRows; ii++){
-    $1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
+    $1[ii] = ($*1_ltype)malloc(iCols * sizeof($1_basetype));
     size_t jj;
-    for(jj=0;jj<iCols;jj++)
+    for(jj = 0; jj < iCols; jj++)
-    $1[ii][jj]=($1_basetype)_piData[jj*iRows+ii];
+    $1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
   }
 }
 
@@ -326,7 +326,7 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)*_piData;
+  $1 = ($1_ltype)*_piData;
 }
 %typemap(in) SWIGTYPE {
   
@@ -337,121 +337,121 @@
  * ----------------------------------------------------------------------------- */
 
 /* Basic C types */
-%typemap(out) signed char (int iRowsOut,int iColsOut) {
+%typemap(out) signed char (int iRowsOut, int iColsOut) {
   char temp;
-  temp=(char)($result);
+  temp = (char)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) short (int iRowsOut,int iColsOut),
+%typemap(out) short (int iRowsOut, int iColsOut),
-              unsigned char (int iRowsOut,int iColsOut) {
+              unsigned char (int iRowsOut, int iColsOut) {
   short temp;
-  temp=(short)($result);
+  temp = (short)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) int (int iRowsOut,int iColsOut),
+%typemap(out) int (int iRowsOut, int iColsOut),
-              unsigned int (int iRowsOut,int iColsOut),
+              unsigned int (int iRowsOut, int iColsOut),
-              unsigned short (int iRowsOut,int iColsOut),
+              unsigned short (int iRowsOut, int iColsOut),
-              unsigned long (int iRowsOut,int iColsOut),
+              unsigned long (int iRowsOut, int iColsOut),
-              long (int iRowsOut,int iColsOut) {
+              long (int iRowsOut, int iColsOut) {
   int temp;
-  temp=(int)($result);
+  temp = (int)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) double (int iRowsOut,int iColsOut),
+%typemap(out) double (int iRowsOut, int iColsOut),
-              float (int iRowsOut,int iColsOut) {
+              float (int iRowsOut, int iColsOut) {
   double temp;
-  temp=(double)($result);
+  temp = (double)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) char (int iRowsOut,int iColsOut) {
+%typemap(out) char (int iRowsOut, int iColsOut) {
-  char* temp;
+  char *temp;
-  temp=(char*)&($result);
+  temp = (char*)&($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfString(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out,noblock=1) void {
 }
 
 /* Pointers */
-%typemap(out) signed char *(int iRowsOut,int iColsOut) {
+%typemap(out) signed char *(int iRowsOut, int iColsOut) {
   char *temp;
-  temp=(char *)($result);
+  temp = (char *)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) short *(int iRowsOut,int iColsOut),
+%typemap(out) short *(int iRowsOut, int iColsOut),
-              unsigned char *(int iRowsOut,int iColsOut) {
+              unsigned char *(int iRowsOut, int iColsOut) {
   short *temp;
-  temp=(short *)($result);
+  temp = (short *)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(out) int *(int iRowsOut,int iColsOut),
+%typemap(out) int *(int iRowsOut, int iColsOut),
-              unsigned int *(int iRowsOut,int iColsOut),
+              unsigned int *(int iRowsOut, int iColsOut),
-              unsigned short *(int iRowsOut,int iColsOut),
+              unsigned short *(int iRowsOut, int iColsOut),
-              unsigned long *(int iRowsOut,int iColsOut),
+              unsigned long *(int iRowsOut, int iColsOut),
-              long *(int iRowsOut,int iColsOut) {
+              long *(int iRowsOut, int iColsOut) {
   int *temp;
-  temp=(int *)($result);
+  temp = (int *)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) double *,
               float * {
   double *temp;
-  temp=(double *)($result);
+  temp = (double *)($result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
   iOutNum++;
   iVarOut++;
 }
 
-%typemap(out) char *(int iRowsOut,int iColsOut){
+%typemap(out) char *(int iRowsOut, int iColsOut){
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfString(iVarOut, iRowsOut, iColsOut, &($result));
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(freearg, noblock=1) char * { 
   if ($1) free($1);  
 }
 
-%typemap(out) SWIGTYPE *(int iRowsOut,int iColsOut) {
+%typemap(out) SWIGTYPE *(int iRowsOut, int iColsOut) {
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &$result);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 /* -----------------------------------------------------------------------------
@@ -468,7 +468,7 @@
 	                  unsigned long,
 	                  float,
 	                  double {
-  double* _piData;
+  double *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -476,11 +476,11 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  $1=($1_ltype)*_piData;
+  $1 = ($1_ltype)*_piData;
 }
 
 %typemap(varin,noblock=1) char {   
-  char* _pstStrings;
+  char *_pstStrings;
   int _piLength;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -489,12 +489,11 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1=($1_ltype)*_pstStrings;
+  $1 = ($1_ltype)*_pstStrings;
 }
 
-%typemap(varin,noblock=1) char *, 
+%typemap(varin,noblock=1) char * {
-                char [ANY] {
+  char *_pstStrings;
-  char* _pstStrings;
   int _piLength;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
@@ -503,39 +502,90 @@
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, &_pstStrings);
-  $1=strdup(_pstStrings);
+  $1 = strdup(_pstStrings);
+}
+
+%typemap(varin,noblock=1) char [ANY] {
+  char *_pstStrings;
+  int _piLength;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  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);
+  strcpy($1,  _pstStrings);
+}
+
+%typemap(varin,noblock=1) int *{
+  int *_piData;
+  int index;
+  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);
+  if($1 != NULL) {
+    free($1);
+  }
+  $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
+  for(index = 0; index < iRows * iCols; index++) {
+    $1[index] = ($*1_ltype)_piData[index];
+  }
+}
+
+%typemap(varin,noblock=1) short * {
+  short *_piData;
+  int index;
+  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);
+  if($1 != NULL) {
+    free($1);
+  }
+  $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
+  for(index = 0; index < iRows * iCols; index++) {
+    $1[index] = ($*1_ltype)_piData[index];
+  }
 }
 
 %typemap(varin,noblock=1) double *,
                           float * {
-  double* _piData;
+  double *_piData;
   int index;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
   if (getVarType(piAddrVar) == sci_matrix ){
      if(!isVarComplex(piAddrVar)) {
-       isComplex=0;
+       isComplex = 0;
        getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-       if($1!=NULL) {
+       if($1 != NULL) {
          free($1);
        }
-       $1=($1_ltype)malloc(iRows*iCols*sizeof($*1_ltype));
+       $1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
-       for(index=0;index<iRows*iCols;index++){
+       for(index = 0; index < iRows * iCols; index++){
-         $1[index]=($*1_ltype)_piData[index];
+         $1[index] = ($*1_ltype)_piData[index];
        }
      }
      else {
-       isComplex=1;
+       isComplex = 1;
        double *_pdblImg;
        getComplexMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData, &_pdblImg);
-       if($1!=NULL) {
+       if($1 != NULL) {
          free($1);
        }
-       $1=($1_ltype)malloc(2*iRows*iCols*sizeof($*1_ltype));
+       $1 = ($1_ltype)malloc(2 * iRows * iCols * sizeof($*1_ltype));
-       for(index=0;index<iRows*iCols;index++){
+       for(index = 0; index < iRows * iCols; index++){
-         $1[index]=($*1_ltype)_piData[index];
+         $1[index] = ($*1_ltype)_piData[index];
-         $1[index+iRows*iCols]=(double)_pdblImg[index];
+         $1[index + iRows * iCols] = (double)_pdblImg[index];
        }
      }
   }
@@ -544,25 +594,49 @@
   }
 }
 
+%typemap(varin,noblock=1) char ** {
+  char **_pstStrings;
+  int *_piLength;
+  int i;
+  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarDimension(piAddrVar, &iRows, &iCols);
+  
+  if (getVarType(piAddrVar) != sci_strings || isVarComplex(piAddrVar)) {
+    Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
+  }
+  
+  _piLength = (int*)malloc(sizeof(int) * iRows * iCols);
+  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, NULL);
+  
+  _pstStrings = (char**)malloc(iRows * iCols * sizeof(char*));
+  for(i = 0; i < iRows * iCols; i++) {
+    _pstStrings[i] = (char*)malloc((_piLength[i] + 1) * sizeof(char));
+  }
+  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, _pstStrings);
+  
+  $1 = _pstStrings;
+}
+
+
 /* -----------------------------------------------------------------------------
  * --- Variable output --- 
  * ----------------------------------------------------------------------------- */
 /* Basic C types */
 %typemap(varout,noblock=1) signed char {
   createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &$result);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) short {
   createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &$result);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned char {
   short temp;
-  temp=$result;
+  temp = $result;
   createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) int,
@@ -571,45 +645,79 @@
                            unsigned long,
                            long {
   createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &$result);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) double {
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &$result);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) float {
   double temp;
-  temp=(double)$result;
+  temp = (double)$result;
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) char {
-  char* temp;
+  char *temp;
-  temp=(char*)&($result);
+  temp = (char*)&($result);
   createMatrixOfString(iVarOut, iRowsOut, iColsOut, &temp);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(varout,noblock=1) char * {
+%typemap(varout,noblock=1) char *{
   createMatrixOfString(iVarOut, iRowsOut, iColsOut, &($result));
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
+}
+
+%typemap(varout,noblock=1) int *{
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, $result);
+  LhsVar(iOutNum) = iVarOut;
+  if($result != NULL)
+    free($result);
+}
+
+%typemap(varout,noblock=1) short *{
+  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, $result);
+  LhsVar(iOutNum) = iVarOut;
+  if($result != NULL)
+    free($result);
 }
 
 %typemap(varout,noblock=1) double *,
                            float * {
   if(isComplex) {
-    createComplexMatrixOfDouble(iVarOut, iRowsOut, iColsOut, $result,&$result[iRowsOut*iColsOut]);
+    createComplexMatrixOfDouble(iVarOut, iRowsOut, iColsOut, $result, &$result[iRowsOut * iColsOut]);
-    LhsVar(iOutNum)=iVarOut;
+    LhsVar(iOutNum) = iVarOut;
   }
   else {
     createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, $result);
-    LhsVar(iOutNum)=iVarOut;
+    LhsVar(iOutNum) = iVarOut;
   }
 }
 
+%typemap(varout,noblock=1) char [ANY] {
+  char **pstData = NULL;
+  pstData = (char **)malloc(sizeof(char *));
+  pstData[0] = $result;
+  createMatrixOfString(iVarOut, iRowsOut, iColsOut, pstData);
+  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);
+  LhsVar(iOutNum) = iVarOut;
+}
+
+
+
+
 /* ------------------------------------------------------------
  *  Enums mapped as integer values
  * ------------------------------------------------------------ */

Lib/scilab/typemaps.i

@@ -63,7 +63,7 @@ or you can use the %apply directive :
 	     unsigned long *INPUT (int *piAddrVar, int iRows, int iCols, unsigned long temp),
 	     float *INPUT (int *piAddrVar, int iRows, int iCols, float temp),
 	     double *INPUT (int *piAddrVar, int iRows, int iCols, double temp) {
-  double* _piData;
+  double *_piData;
   getVarAddressFromPosition($argnum, &piAddrVar);
   getVarDimension(piAddrVar, &iRows, &iCols);
   
@@ -71,8 +71,8 @@ or you can use the %apply directive :
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   getMatrixOfDouble(piAddrVar, &iRows, &iCols,  &_piData);
-  temp=($*1_ltype)*_piData;
+  temp = ($*1_ltype)*_piData;
-  $1=&temp;
+  $1 = &temp;
 }
 #undef INPUT_TYPEMAP
                  
@@ -133,44 +133,44 @@ output values.
 	     unsigned long *OUTPUT (unsigned long temp),
 	     float *OUTPUT (float temp),
 	     double *OUTPUT (double temp) {
-  $1=($1_ltype)&temp;
+  $1 = ($1_ltype)&temp;
 }
 
-%typemap(argout) signed char *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress) {
+%typemap(argout) signed char *OUTPUT(int iRowsOut, int iColsOut) {
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp$argnum, &_piAddress);
+  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp$argnum);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(argout) short *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
+%typemap(argout) short *OUTPUT(int iRowsOut, int iColsOut),
-              unsigned char *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress) {
+              unsigned char *OUTPUT(int iRowsOut, int iColsOut) {
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp$argnum, &_piAddress);
+  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp$argnum);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }
 
-%typemap(argout) int *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
+%typemap(argout) int *OUTPUT(int iRowsOut,int iColsOut),
-              unsigned int *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
+              unsigned int *OUTPUT(int iRowsOut,int iColsOut),
-              unsigned short *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
+              unsigned short *OUTPUT(int iRowsOut,int iColsOut),
-              unsigned long *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
+              unsigned long *OUTPUT(int iRowsOut,int iColsOut),
-              long *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress) {
+              long *OUTPUT(int iRowsOut,int iColsOut) {
   iRowsOut=1; 
   iColsOut=1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp$argnum, &_piAddress);
+  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp$argnum);
   LhsVar(iOutNum)=iVarOut;
 }
 
 
-%typemap(argout) double *OUTPUT(int iRowsOut,int iColsOut),
+%typemap(argout) double *OUTPUT(int iRowsOut, int iColsOut),
-              float *OUTPUT(int iRowsOut,int iColsOut) {
+              float *OUTPUT(int iRowsOut, int iColsOut) {
   double temp;
-  temp=(double)(*$result);
+  temp = (double)(*$result);
-  iRowsOut=1; 
+  iRowsOut = 1; 
-  iColsOut=1;
+  iColsOut = 1;
   createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp$argnum);
-  LhsVar(iOutNum)=iVarOut;
+  LhsVar(iOutNum) = iVarOut;
 }