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

Merge remote-tracking branch 'upstream/gsoc2012-scilab' into gsoc2012-scilab

Browse source 
Conflicts:
	Source/Modules/scilab.cxx
This commit is contained in:
Simon Marchetto 2013-09-06 11:17:27 +02:00
commit 38750fd4ec
3 changed files with 190 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Doc/Manual/Preprocessor.html
View file

@ -117,7 +117,7 @@ SWIGGUILE Defined when using Guile
SWIGJAVA Defined when using Java
SWIGLUA Defined when using Lua
SWIGMODULA3 Defined when using Modula-3
SWIGMZSCHEME Defined when using Mzscheme
SWIGMZSCHEME Defined when using Mzscheme
SWIGOCAML Defined when using Ocaml
SWIGOCTAVE Defined when using Octave
SWIGPERL Defined when using Perl
@ -126,6 +126,7 @@ SWIGPIKE Defined when using Pike
SWIGPYTHON Defined when using Python
SWIGR Defined when using R
SWIGRUBY Defined when using Ruby
SWIGSCILAB Defined when using Scilab
SWIGSEXP Defined when using S-expressions
SWIGTCL Defined when using Tcl
SWIGXML Defined when using XML

250
Doc/Manual/Scilab.html
View file

@ -8,27 +8,27 @@
<body bgcolor="#ffffff">
<H1><a name="Scilab"></a>36 SWIG and Scilab</H1>
<H1><a name="Scilab"></a>37 SWIG and Scilab</H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Scilab_nn2">Preliminaries</a>
<li><a href="#Scilab_nn3">Running SWIG</a>
<li><a href="#Scilab_preliminaries">Preliminaries</a>
<li><a href="#Scilab_running">Running SWIG</a>
<ul>
<li><a href="#Scilab_nn5">Compiling a dynamic module</a>
<li><a href="#Scilab_nn6">Using your module</a>
<li><a href="#Scilab_compiling_dynamic">Compiling a dynamic module</a>
<li><a href="#Scilab_using_module">Using your module</a>
</ul>
<li><a href="#Scilab_nn7">A tour of basic C/C++ wrapping</a>
<li><a href="#Scilab_tour_of_basic_c">A tour of basic C wrapping</a>
<ul>
<li><a href="#Scilab_nn8">Modules</a>
<li><a href="#Scilab_nn9">Functions</a>
<li><a href="#scilab_nn10">Global variables</a>
<li><a href="#Scilab_nn11">Constants</a>
<li><a href="#Scilab_nn12">Enums</a>
<li><a href="#Scilab_nn13">Pointers</a>
<li><a href="#Scilab_nn14">Structs</a>
<li><a href="#Scilab_nn15">Arrays</a>
<li><a href="#Scilab_nn16">Matrices</a>
<li><a href="#Scilab_modules">Modules</a>
<li><a href="#Scilab_functions">Functions</a>
<li><a href="#Scilab_global_variables">Global variables</a>
<li><a href="#Scilab_constants">Constants</a>
<li><a href="#Scilab_enums">Enums</a>
<li><a href="#Scilab_pointers">Pointers</a>
<li><a href="#Scilab_structs">Structs</a>
<li><a href="#Scilab_arrays">Arrays</a>
<li><a href="#Scilab_matrices">Matrices</a>
</ul>
</ul>
</div>
@ -37,21 +37,25 @@
<p>
Scilab is a scientific software package for numerical computations providing a powerful open computing environment for engineering and scientific applications that is mostly compatible with MATLAB. More information can be found at <a href="http://www.scilab.org">www.scilab.org</a>.
Scilab is a scientific software package for numerical computations providing a powerful open computing environment for engineering and scientific applications that is mostly compatible with MATLAB. More information can be found at <a href="http://www.scilab.org">www.scilab.org</a>.
</p>
<p>
This chapter is intended to give an introduction to use the module. You should also read the SWIG documentation which is not specific to Scilab. Also, there are a dozen or so examples in the Examples/Scilab directory. As Scilab doesn't really do objects, so in this module, it supports mainly C features: variables, functions, constants, enums, structs, unions, pointers, arrays and matrices.
This chapter is intended to give an introduction to use the module.
You should also read the SWIG documentation which is not specific to Scilab.
Also, there are a dozen or so examples in the Examples/Scilab directory.
As Scilab doesn't really have objects, so in this module, it supports mainly C features:
variables, functions, constants, enums, structs, unions, pointers, arrays and matrices.
</p>
<H2><a name="Scilab_nn2"></a>36.1 Preliminaries</H2>
<H2><a name="Scilab_preliminaries"></a>37.1 Preliminaries</H2>
<p>
The current SWIG implemention is based on Scilab 5.2.2. Support for other higher versions has not been tested, nor has support for any OS other than Linux.
The current SWIG implemention is based on Scilab 5.2.2. Support for later versions has not been tested, nor has support for any OS other than Linux.
</p>
<H2><a name="Scilab_nn3"></a>36.2 Running SWIG</H2>
<H2><a name="Scilab_running"></a>37.2 Running SWIG</H2>
<p>
@ -63,10 +67,11 @@ Let's start with a very simple SWIG interface file:
#include "example.h"
%}
int gcd(int x, int y);
extern double Foo; </pre></div>
extern double Foo;
</pre></div>
<p>
To build an Scilab module, run SWIG using the <tt>-scilab</tt> option.
To build a Scilab module, run SWIG using the <tt>-scilab</tt> option.
</p>
<div class="shell"><pre>$ swig -scilab example.i </pre></div>
@ -79,7 +84,7 @@ This creates a C source file <tt>example_wrap.c</tt> and a interface file <tt>bu
The swig command line has a number of options you can use, like to redirect it's output. Use <tt>swig --help</tt> to learn about these.
</p>
<H3><a name="Scilab_nn5"></a>36.2.1 Compiling a dynamic module</H3>
<H3><a name="Scilab_compiling_dynamic"></a>37.2.1 Compiling a dynamic module</H3>
<p>
@ -89,7 +94,7 @@ Building such a file is usually done with the "exec" command (within Scilab itse
<div class="shell"><pre>
$ ./scilab
--> exec builder.sce
--&gt; exec builder.sce
</pre></div>
<p>
@ -117,9 +122,9 @@ ilib_build(ilib_name,table,files,libs);
"exec builder.sce" will produce *.so,and a file called "loader.sce" which contains how to load the module. Loading it into Scilab is then a matter of invoking
</p>
<div class="shell"><pre>--&gt; exec loader.sce</pre></div>
<div class="shell"><pre>--&gt; exec loader.sce</pre></div>
<H3><a name="Scilab_nn6"></a>36.2.2 Using your module</H3>
<H3><a name="Scilab_using_module"></a>37.2.2 Using your module</H3>
<p>
@ -127,7 +132,7 @@ Assuming all goes well, you will be able to do this:
<br>
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; gcd(4,6)
ans = 2
@ -139,17 +144,68 @@ ans = 3
--&gt; Foo_get
ans = 4 </pre></div>
<H2><a name="Scilab_nn7"></a>36.3 A tour of basic C wrapping</H2>
<H3><a name="Scilab_options"></a>Additional commandline options</H3>
<p>
The following table list the additional commandline options available for the Scilab module. They can also be seen by using:
</p>
<div class="code"><pre>
swig -scilab -help
</pre></div>
<table summary="Scilab specific options">
<tr>
<th>Scilab specific options</th>
</tr>
<tr>
<td>-addcflag &lt;opt&gt;</td>
<td>Additional include options &lt;opt&gt; to include in build script</td>
</tr>
<tr>
<td>-addldflag &lt;opt&gt;</td>
<td>Additional link options &lt;opt&gt; to include in build script</td>
</tr>
<tr>
<td>-addsrc &lt;files&gt;</td>
<td>Additional space separated source &lt;files&gt; to include in build script</td>
</tr>
<tr>
<td>-vbl &lt;level&gt;</td>
<td>Sets the build verbose &lt;level&gt; (default 0)</td>
</tr>
</table>
<p>
Some examples:
</p>
<div class="shell"><pre>
$ swig -scilab -addcflag -I/usr/includes example.i
$ swig -scilab -addldflag -lm example.i
$ swig -scilab -addsrc file1.cxx file2.cxx example.i
</pre></div>
</p>
<H3><a name="Scilab_nn8"></a>36.3.1 Modules</H3>
<H2><a name="Scilab_tour_of_basic_c"></a>37.3 A tour of basic C wrapping</H2>
<H3><a name="Scilab_modules"></a>37.3.1 Modules</H3>
<p>
The SWIG module directive specifies the name of the Scilab module. If you want to load the module, you'll need a file called "loader.sce" which is usually generated by the command "exec builder.sce". The loader.sce looks as following:
</p>
<div class="code"><pre>
<div class="code"><pre>
// ------------------------------------------------------
// generated by builder.sce: Please do not edit this file
// ------------------------------------------------------
@ -165,8 +221,8 @@ clear libexamplelib_path;
clear list_functions;
clear get_file_path;
// ------------------------------------------------------
</pre></div>
<p>addinter (files,spname,fcts) performs dynamic linking of a compiled C new Scilab interface routine.
</p>
<ul>
@ -177,32 +233,39 @@ clear get_file_path;
<p>
After you run the command "exec loader.sce", you could use the module.
After you run the command "exec loader.sce", you can use the module.
</pre>
<H3><a name="Scilab_nn9"></a>36.3.2 Functions</H3>
<H3><a name="Scilab_functions"></a>37.3.2 Functions</H3>
<p>
Global functions are wrapped as new Scilab built-in functions. For example,
</p>
<div class="code"><pre>&#037;module example
int fact(int n); </pre></div>
<div class="code"><pre>
&#037;module example
int fact(int n);
</pre></div>
<p>
creates a built-in function <tt>fact(n)</tt> that works exactly like you think it does:
</p>
<div class="targetlang"><pre>--&gt; fact(4)
ans=24 </pre></div>
<H3><a name="scilab_nn10"></a>36.3.3 Global variables</H3>
<div class="targetlang"><pre>
--&gt; fact(4)
ans=24
</pre></div>
<H3><a name="Scilab_global_variables"></a>37.3.3 Global variables</H3>
<p>
To expose variables, SWIG actually generates two functions, to get and set the value. In this case, Foo_set and Foo_get would be generated. SWIG then automatically calls these functions when you get and set the variable-- in the former case creating a local copy in the interpreter of the C variables, and in the latter case copying an interpreter variables onto the C variable.
To expose variables, SWIG actually generates two functions, to get and set the value. In this case, Foo_set and Foo_get would be generated. SWIG then automatically calls these functions when you get and set the variable-- in the former case creating a local copy in the interpreter of the C variables, and in the latter case copying an interpreter variable value into the C variable.
</p>
<div class="targetlang"><pre>--&gt; exec loader.sce;
<div class="targetlang"><pre>
--&gt; exec loader.sce;
--&gt; c=Foo_get();
--&gt; Foo_set(4);
@ -213,14 +276,16 @@ c = 3
--&gt; Foo_get()
ans = 4
</pre></div>
<H3><a name="Scilab_nn11"></a>36.3.4 Constants</H3>
<H3><a name="Scilab_constants"></a>37.3.4 Constants</H3>
<p>
C constants are not really constant in Scilab. When dealing with the constants, the get function will be generated. For example given some constants:
C constants are not really constant in Scilab. When dealing with the constants, a get function will be generated. For example given some constants:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>
%module example
#define ICONST 42
#define FCONST 2.1828
#define CCONST 'x'
@ -231,7 +296,7 @@ ans = 4
<p>It is easy to use them in Scilab:</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; exec loader.sce;
--&gt; ICONST_get();
ans= 42
@ -254,21 +319,22 @@ ans= 37
ans= 3.14
</pre></div>
<H3><a name="Scilab_nn12"></a>36.3.5 Enums</H3>
<H3><a name="Scilab_enums"></a>37.3.5 Enums</H3>
<p> The way that deals with the enums is similar to the constants. For example:
<p> The way SWIG deals with the enums is similar to constants. For example:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>%module example
typedef enum { RED, BLUE, GREEN } color;
</pre></div>
<p>
Some code like RED_get(), BLUE_get(),GREEN_get() will be generated. So it could be used as the following:
Some code like RED_get(), BLUE_get(),GREEN_get() will be generated. It can be used as the following:
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; exec loader.sce;
--&gt; printf(" RED = %i\n", RED_get());
RED = 0
@ -281,11 +347,14 @@ typedef enum { RED, BLUE, GREEN } color;
</pre></div>
<H3><a name="Scilab_nn13"></a>36.3.6 Pointers</H3>
<H3><a name="Scilab_pointers"></a>37.3.6 Pointers</H3>
<p>
Pointers are fully supported by SWIG. One way to deal with the pointers is using the INPUT and OUTPUT typemaps. For example, in order to call C functions as the following:
</p>
<div class="code"><pre>
<div class="code"><pre>
void sub(int *x, int *y, int *result) {
*result = *x - *y;
}
@ -296,19 +365,22 @@ int divide(int n, int d, int *r) {
return q;
}
</pre></div>
<p> We could write a interface file:
<p> We could write an interface file:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>%module example
%include typemaps.i
extern void sub(int *INPUT, int *INPUT, int *OUTPUT);
%apply int *OUTPUT { int *r };
extern int divide(int n, int d, int *r);
</pre></div>
<p>Then run it in Scilab:
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; r = sub(37,42);
--&gt; printf(" 37 - 42 = %i\n",r);
37 - 42 = -5
@ -318,15 +390,19 @@ extern int divide(int n, int d, int *r);
42/37 = 1 remainder 5
</pre></div>
<p> From the example above, it is clear that instead of passing a pointer to an object,
we only need a real value instead.
</p>
<H3><a name="Scilab_nn14"></a>36.3.7 Structs</H3>
<H3><a name="Scilab_structs"></a>37.3.7 Structs</H3>
<p>
SWIG creates a set of accessor functions when encountering a structure or union. For example:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>%module example
%inline %{
typedef struct {
int x;
@ -334,9 +410,11 @@ typedef struct {
%}
</pre></div>
<p> When wrappered, it would generate two main function: Foo_x_set(), which set the data value of the structrure and Foo_x_get() which could obtain the value of the structrure. Run it in Scilab:
<p> When wrapped, it would generate two main function: Foo_x_set(), which set the data value of the structure and Foo_x_get() which could obtain the value of the structure. Run it in Scilab:
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; a=new_Foo();
--&gt; Foo_x_set(a,100);
--&gt; Foo_x_get(a)
@ -345,11 +423,16 @@ ans =
100
</pre></div>
<H3><a name="Scilab_nn15"></a>36.3.8 Arrays</H3>
<H3><a name="Scilab_arrays"></a>37.3.8 Arrays</H3>
<p>
Arrays are fully supported by SWIG and Scilab. In SWIG, they are handled as pointers. And Scilab also supports the pointer well. So it is easy to deal with the arrays. For example:
Arrays are fully supported by SWIG and Scilab. In SWIG, they are handled as pointers.
It is easy to deal with arrays too. For example:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>
%module example
%inline %{
int x[10];
@ -359,18 +442,21 @@ void initArray()
int i, n;
n = sizeof(x)/sizeof(x[0]);
for(i = 0; i < n; i++)
for(i = 0; i &gt; n; i++)
x[i] = i;
n = sizeof(y)/sizeof(y[0]);
for(i = 0; i < n; i++)
for(i = 0; i &lt; n; i++)
y[i] = ((double) i)/ ((double) n);
return;
%}
</pre></div>
<p> When wrappered, it would generate the following funtion: x_set(), x_get(), y_set(), y_get(), and _wrap_initArray. So it could be used like this:
<p> When wrapped, the following functions are generated: x_set(), x_get(), y_set(), y_get(), and _wrap_initArray.
They can be used like this:
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; exec loader.sce
--&gt; initArray();
@ -384,11 +470,14 @@ ans =
0. 0.1428571 0.2857143 0.4285714 0.5714286 0.7142857 0.8571429
</pre></div>
<H3><a name="Scilab_nn16"></a>36.3.9 Matrices</H3>
<H3><a name="Scilab_matrices"></a>37.3.9 Matrices</H3>
<p>
Scilab uses matrices a lot for numerical mathematics and scientific visualization. So supporting matrices would make scilab more convenient. For example:
Scilab uses matrices a lot for numerical mathematics and scientific visualization. Supporting matrices makes Scilab more convenient. For example:
</p>
<div class="code"><pre>%module example
<div class="code"><pre>%module example
%inline %{
double **new_matrix() {
@ -398,7 +487,7 @@ double **new_matrix() {
M = (double **) malloc(4 * sizeof(double *));
M[0] = (double *) malloc(16 * sizeof(double));
for (i = 0; i < 4; i++) {
for (i = 0; i &lt; 4; i++) {
M[i] = M[0] + 4 * i;
}
return M;
@ -416,8 +505,8 @@ void print_matrix(double **M) {
int i,j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (i = 0; i &lt; 4; i++) {
for (j = 0; j &lt; 4; j++) {
printf("%10g ", M[i][j]);
}
printf("\n");
@ -429,20 +518,21 @@ void mat_mult(double **m1, double **m2, double **m3) {
int i,j,k;
double temp[4][4];
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++) {
for (i = 0; i &lt; 4; i++)
for (j = 0; j &lt; 4; j++) {
temp[i][j] = 0;
for (k = 0; k < 4; k++)
for (k = 0; k &lt; 4; k++)
temp[i][j] += m1[i][k] * m2[k][j];
}
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
for (i = 0; i &lt; 4; i++)
for (j = 0; j &lt; 4; j++)
m3[i][j] = temp[i][j];
}
%}
</pre></div>
<p> When wrappered, it would generate the following funtion:
<p> When wrapped, it would generate the following function:
</p>
<p>_wrap_new_matrix(): generate a new matrix.
</p>
@ -454,9 +544,10 @@ void mat_mult(double **m1, double **m2, double **m3) {
</p>
<p>_wrap_mat_mult(A, B, C): compute the A * B and the result is stored into C.
</p>
<p>So it could be used like this:
<p>It can be used like this:
</p>
<div class="targetlang"><pre>
<div class="targetlang"><pre>
--&gt; exec loader.sce
--&gt; x = new_matrix();
@ -491,3 +582,4 @@ void mat_mult(double **m1, double **m2, double **m3) {
26 12 -2 -16
32 14 -4 -22
</pre></div>

32
Source/Modules/scilab.cxx
View file

@ -17,14 +17,14 @@
/*#define SWIG_DEBUG*/
static const char *usage = (char *) "\
Scilab options\n\
-addsrc <source files> additionnal source files (separated by space) to include in build script (ex: myfile.cxx myfile2.cxx)\n\
-addcflag -I<path> additionnal include path to include in build script (ex: -I/usr/includes/)\n\
-addldlag <flag> additionnal link flag to include in build script (ex: -lm)\n\
-vbl <level> sets the build verbose level (default 0)\n\n";
Scilab options (available with -scilab)\n\
-addcflag <opt> - Additional include options <opt> to include in build script\n\
-addldflag <opt>- Additional link options <opt> to include in build script\n\
-addsrc <files> - Additional space separated source <files> to include in build script\n\
-vbl <level> - Sets the build verbose <level> (default 0)\n\n";
const char *SWIG_INIT_FUNCTION_NAME = "SWIG_Init";
const char *SWIG_CREATE_VARIABLES_FUNCTION_NAME = "SWIG_CreateScilabVariables";
static const char *SWIG_INIT_FUNCTION_NAME = "SWIG_Init";
static const char *SWIG_CREATE_VARIABLES_FUNCTION_NAME = "SWIG_CreateScilabVariables";
class SCILAB:public Language {
protected:
@ -61,10 +61,7 @@ public:
for (int argIndex = 1; argIndex < argc; argIndex++) {
if (argv[argIndex] != NULL) {
if (strcmp(argv[argIndex], "-help") == 0) {
/* Display message */
fputs(usage, stderr);
/* Indicate arg as valid */
Swig_mark_arg(argIndex);
Printf(stdout, "%s\n", usage);
} else if (strcmp(argv[argIndex], "-addsrc") == 0) {
if (argv[argIndex + 1] != NULL) {
Swig_mark_arg(argIndex);
@ -126,7 +123,7 @@ public:
String *outputFilename = Getattr(node, "outfile");
/* Initialize I/O */
beginSection = NewFile(NewStringf("%s%s", SWIG_output_directory(), outputFilename), "w", SWIG_output_files());
beginSection = NewFile(outputFilename, "w", SWIG_output_files());
if (!beginSection) {
FileErrorDisplay(outputFilename);
SWIG_exit(EXIT_FAILURE);
@ -188,7 +185,7 @@ public:
Printf(builderCode, "table = [");
/* add initialization function to builder table */
addFunctionInBuilder(NewString(SWIG_INIT_FUNCTION_NAME), NewString(SWIG_INIT_FUNCTION_NAME));
addFunctionInBuilder(SWIG_INIT_FUNCTION_NAME, SWIG_INIT_FUNCTION_NAME);
// Open Scilab wrapper variables creation function
variablesCode = NewString("");
@ -221,7 +218,12 @@ public:
Printf(builderCode, "cd(originaldir);\n");
Printf(builderCode, "exit(ret)");
builderFile = NewFile(NewStringf("%sbuilder.sce", SWIG_output_directory()), "w", SWIG_output_files());
String *builderFilename = NewStringf("%sbuilder.sce", SWIG_output_directory());
builderFile = NewFile(builderFilename, "w", SWIG_output_files());
if (!builderFile) {
FileErrorDisplay(builderFilename);
SWIG_exit(EXIT_FAILURE);
}
Printv(builderFile, builderCode, NIL);
Delete(builderFile);
@ -672,7 +674,7 @@ public:
/* -----------------------------------------------------------------------
* addFunctionInBuilder(): add a new function wrapper in builder.sce file
* ----------------------------------------------------------------------- */
void addFunctionInBuilder(String *scilabFunctionName, String *wrapperFunctionName) {
void addFunctionInBuilder(const_String_or_char_ptr scilabFunctionName, const_String_or_char_ptr wrapperFunctionName) {
if (++builderFunctionCount % 10 == 0) {
Printf(builderCode, "];\n\ntable = [table;");
}