jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

added some pointer support and fixed style problem

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2009-sploving@11415 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Baozeng Ding 2009-07-17 16:21:54 +00:00
commit 93a0308e21
14 changed files with 368 additions and 244 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Examples/Makefile.in
View file

@ -1152,8 +1152,14 @@ 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
# -----------------------------------------------------------------

2
Examples/octave/pointer/Makefile
View file

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

30
Examples/octave/pointer/example.i
View file

@ -1,30 +1,6 @@
/* File : example.i */
%module example
%{
extern void add(int *, int *, int *);
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);
FILE *fopen(char *filename, char *mode);
int fputs(char* , FILE *);
int fclose(FILE *);

2
Examples/python/pointer/Makefile
View file

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

2
Examples/scilab/constants/runme.sci
View file

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

4
Examples/scilab/contract/runme.sci
View file

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

2
Examples/scilab/enum/runme.sci
View file

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

2
Examples/scilab/pointer/runme.sci
View file

@ -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

2
Examples/scilab/simple/runme.sci
View file

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

6
Examples/scilab/variables/example.c
View file

@ -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]);
}

4
Examples/scilab/variables/example.i
View file

@ -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;
%}

16
Examples/scilab/variables/runme.sci
View file

@ -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

478
Lib/scilab/scitypemaps.swg
View file

@ -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) {
char* _piData;
%typemap(in) signed char [ANY] (int *piAddrVar, int iRows, int iCols) {
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++){
$1[index]=($*1_ltype)_piData[index];
for(index = 0; index < iRows * iCols; index++) {
$1[index] = ($*1_ltype)_piData[index];
}
}
%typemap(in) short [ANY](int *piAddrVar, int iRows, int iCols),
unsigned char [ANY](int *piAddrVar, int iRows, int iCols) {
short* _piData;
%typemap(in) short [ANY] (int *piAddrVar, int iRows, int iCols),
unsigned char [ANY] (int *piAddrVar, int iRows, int iCols) {
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));
for(index=0;index<iRows*iCols;index++){
$1[index]=($*1_ltype)_piData[index];
$1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
for(index = 0; index < iRows * iCols; index++) {
$1[index] = ($*1_ltype)_piData[index];
}
}
%typemap(in) unsigned short [ANY](int *piAddrVar, int iRows, int iCols),
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),
unsigned long [ANY](int *piAddrVar, int iRows, int iCols) {
int* _piData;
%typemap(in) unsigned short [ANY] (int *piAddrVar, int iRows, int iCols),
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),
unsigned long [ANY] (int *piAddrVar, int iRows, int iCols) {
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));
for(index=0;index<iRows*iCols;index++){
$1[index]=($*1_ltype)_piData[index];
$1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
for(index = 0; index < iRows * iCols; index++) {
$1[index] = ($*1_ltype)_piData[index];
}
}
%typemap(in) double [ANY](int *piAddrVar, int iRows, int iCols),
float [ANY](int *piAddrVar, int iRows, int iCols){
double* _piData;
%typemap(in) double [ANY] (int *piAddrVar, int iRows, int iCols),
float [ANY] (int *piAddrVar, int iRows, int iCols){
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));
for(index=0;index<iRows*iCols;index++){
$1[index]=($*1_ltype)_piData[index];
$1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
for(index = 0; index < iRows * iCols; index++){
$1[index] = ($*1_ltype)_piData[index];
}
}
%typemap(in) char [ANY](int *piAddrVar, int iRows, int iCols){
char* _pstStrings;
%typemap(in) char [ANY] (int *piAddrVar, int iRows, int iCols){
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) {
char* _piData;
%typemap(in) signed char [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
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++){
$1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
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];
for(jj=0; jj < iCols; jj++)
$1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
}
}
%typemap(in) short [ANY][ANY](int *piAddrVar, int iRows, int iCols),
unsigned char [ANY][ANY](int *piAddrVar, int iRows, int iCols) {
short* _piData;
%typemap(in) short [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
unsigned char [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
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++){
$1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
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];
for(jj = 0; jj < iCols; jj++)
$1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
}
}
%typemap(in) unsigned short [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),
long [ANY][ANY](int *piAddrVar, int iRows, int iCols),
unsigned long [ANY][ANY](int *piAddrVar, int iRows, int iCols){
int* _piData;
%typemap(in) unsigned short [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),
long [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
unsigned long [ANY][ANY] (int *piAddrVar, int iRows, int iCols){
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++){
$1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
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];
for(jj = 0; jj < iCols; jj++)
$1[ii][jj] = ($1_basetype)_piData[jj * iRows+ii];
}
}
%typemap(in) double [ANY][ANY](int *piAddrVar, int iRows, int iCols),
float [ANY][ANY](int *piAddrVar, int iRows, int iCols) {
double* _piData;
%typemap(in) double [ANY][ANY] (int *piAddrVar, int iRows, int iCols),
float [ANY][ANY] (int *piAddrVar, int iRows, int iCols) {
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++){
$1[ii]=($*1_ltype)malloc(iCols*sizeof($1_basetype));
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];
for(jj = 0; jj < iCols; jj++)
$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);
iRowsOut=1;
iColsOut=1;
temp = (char)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) short (int iRowsOut,int iColsOut),
unsigned char (int iRowsOut,int iColsOut) {
%typemap(out) short (int iRowsOut, int iColsOut),
unsigned char (int iRowsOut, int iColsOut) {
short temp;
temp=(short)($result);
iRowsOut=1;
iColsOut=1;
temp = (short)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) int (int iRowsOut,int iColsOut),
unsigned int (int iRowsOut,int iColsOut),
unsigned short (int iRowsOut,int iColsOut),
unsigned long (int iRowsOut,int iColsOut),
long (int iRowsOut,int iColsOut) {
%typemap(out) int (int iRowsOut, int iColsOut),
unsigned int (int iRowsOut, int iColsOut),
unsigned short (int iRowsOut, int iColsOut),
unsigned long (int iRowsOut, int iColsOut),
long (int iRowsOut, int iColsOut) {
int temp;
temp=(int)($result);
iRowsOut=1;
iColsOut=1;
temp = (int)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) double (int iRowsOut,int iColsOut),
float (int iRowsOut,int iColsOut) {
%typemap(out) double (int iRowsOut, int iColsOut),
float (int iRowsOut, int iColsOut) {
double temp;
temp=(double)($result);
iRowsOut=1;
iColsOut=1;
temp = (double)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) char (int iRowsOut,int iColsOut) {
char* temp;
temp=(char*)&($result);
iRowsOut=1;
iColsOut=1;
%typemap(out) char (int iRowsOut, int iColsOut) {
char *temp;
temp = (char*)&($result);
iRowsOut = 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);
iRowsOut=1;
iColsOut=1;
temp = (char *)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) short *(int iRowsOut,int iColsOut),
unsigned char *(int iRowsOut,int iColsOut) {
%typemap(out) short *(int iRowsOut, int iColsOut),
unsigned char *(int iRowsOut, int iColsOut) {
short *temp;
temp=(short *)($result);
iRowsOut=1;
iColsOut=1;
temp = (short *)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) int *(int iRowsOut,int iColsOut),
unsigned int *(int iRowsOut,int iColsOut),
unsigned short *(int iRowsOut,int iColsOut),
unsigned long *(int iRowsOut,int iColsOut),
long *(int iRowsOut,int iColsOut) {
%typemap(out) int *(int iRowsOut, int iColsOut),
unsigned int *(int iRowsOut, int iColsOut),
unsigned short *(int iRowsOut, int iColsOut),
unsigned long *(int iRowsOut, int iColsOut),
long *(int iRowsOut, int iColsOut) {
int *temp;
temp=(int *)($result);
iRowsOut=1;
iColsOut=1;
temp = (int *)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}
%typemap(out) double *,
float * {
double *temp;
temp=(double *)($result);
iRowsOut=1;
iColsOut=1;
temp = (double *)($result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, temp);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
iOutNum++;
iVarOut++;
}
%typemap(out) char *(int iRowsOut,int iColsOut){
iRowsOut=1;
iColsOut=1;
%typemap(out) char *(int iRowsOut, int iColsOut){
iRowsOut = 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) {
iRowsOut=1;
iColsOut=1;
%typemap(out) SWIGTYPE *(int iRowsOut, int iColsOut) {
iRowsOut = 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 *,
char [ANY] {
char* _pstStrings;
%typemap(varin,noblock=1) char * {
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));
for(index=0;index<iRows*iCols;index++){
$1[index]=($*1_ltype)_piData[index];
$1 = ($1_ltype)malloc(iRows * iCols * sizeof($*1_ltype));
for(index = 0; index < iRows * iCols; 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));
for(index=0;index<iRows*iCols;index++){
$1[index]=($*1_ltype)_piData[index];
$1[index+iRows*iCols]=(double)_pdblImg[index];
$1 = ($1_ltype)malloc(2 * iRows * iCols * sizeof($*1_ltype));
for(index = 0; index < iRows * iCols; index++){
$1[index] = ($*1_ltype)_piData[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;
temp=(char*)&($result);
char *temp;
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]);
LhsVar(iOutNum)=iVarOut;
createComplexMatrixOfDouble(iVarOut, iRowsOut, iColsOut, $result, &$result[iRowsOut * iColsOut]);
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
* ------------------------------------------------------------ */

54
Lib/scilab/typemaps.i
View file

@ -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;
$1=&temp;
temp = ($*1_ltype)*_piData;
$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) {
iRowsOut=1;
iColsOut=1;
createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp$argnum, &_piAddress);
LhsVar(iOutNum)=iVarOut;
%typemap(argout) signed char *OUTPUT(int iRowsOut, int iColsOut) {
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp$argnum);
LhsVar(iOutNum) = iVarOut;
}
%typemap(argout) short *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
unsigned char *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress) {
iRowsOut=1;
iColsOut=1;
createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp$argnum, &_piAddress);
LhsVar(iOutNum)=iVarOut;
%typemap(argout) short *OUTPUT(int iRowsOut, int iColsOut),
unsigned char *OUTPUT(int iRowsOut, int iColsOut) {
iRowsOut = 1;
iColsOut = 1;
createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp$argnum);
LhsVar(iOutNum) = iVarOut;
}
%typemap(argout) int *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
unsigned int *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
unsigned short *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
unsigned long *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress),
long *OUTPUT(int iRowsOut,int iColsOut,int* _piAddress) {
%typemap(argout) int *OUTPUT(int iRowsOut,int iColsOut),
unsigned int *OUTPUT(int iRowsOut,int iColsOut),
unsigned short *OUTPUT(int iRowsOut,int iColsOut),
unsigned long *OUTPUT(int iRowsOut,int iColsOut),
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),
float *OUTPUT(int iRowsOut,int iColsOut) {
%typemap(argout) double *OUTPUT(int iRowsOut, int iColsOut),
float *OUTPUT(int iRowsOut, int iColsOut) {
double temp;
temp=(double)(*$result);
iRowsOut=1;
iColsOut=1;
temp = (double)(*$result);
iRowsOut = 1;
iColsOut = 1;
createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp$argnum);
LhsVar(iOutNum)=iVarOut;
LhsVar(iOutNum) = iVarOut;
}