SWIG学習ノート

%module mymodule #            
%{                              #%{%}     ，     wrapper 
#include "myheader.h"
%}
// Now list ANSI C/C++ declarations
int foo;                      #swig                      
int bar(int x);

%init %{ # module       ，     ，java   ，  python   
init_variables();
%}

%inline %{ #                     （xx_wrap.cxx ）   swig                 
/* Create a new vector */
Vector *new_Vector() {
  return (Vector *) malloc(sizeof(Vector));
}
%}

%{
/* Create a new vector */
Vector *new_Vector() {
  return (Vector *) malloc(sizeof(Vector));
}
%}

Vector *new_Vector() {
  return (Vector *) malloc(sizeof(Vector));
}

%begin %{
... code in begin section ... xx_wrap.cxx    ，      ，        
%}

%runtime %{
... code in runtime section ...  %header  
%}

%header %{
... code in header section ...    %{%}
%}

%wrapper %{
... code in wrapper section ...   SWIG         
%}

%init %{
... code in init section ...          ，     java     xx_wrap.cxx     ，
python   SWIG_INIT       

%}

%module base_module
%{
#include "base.h"
%}
%include "base.h"//SWIG     #include，      SWIG     #include    %include     
#define STATUS 50//  C        ，       （get/set）  
#define VERSION "1.1"

#ifdef SWIG //swig         
%module foo
#endif

// File : interface.i
int a;       // Can read/write
%immutable;
int b, c, d;   // Read only variables
%mutable;
double x, y;  // read/write

char * foo;
//SWIG      ：
/ * C  * /
void foo_set（char * value）{
  if（foo）free（foo）;
  foo =（char *）malloc（strlen（value）+1）;
  strcpy（foo，value）;
}
/ * C ++  。  -c++   * /
void foo_set（char * value）{
  if（foo）delete [] foo;
  foo = new char [strlen（value）+1];
  strcpy（foo，value）;
}

％inline ％{
  void set_foo（char * value）{
    strncpy（foo，value，50）;
  }
％}

>>> set_foo（“Hello World”）

/ *     * /
int binary_op（int a，int b，int（* op）（int，int））;

/ *      * /
％constant int add（int，int）;
％constant int sub（int，int）;
％constant int mul（int，int）;

>>> binary_op（3,4，add）
7
>>> binary_op（3,4，mul）
12
>>>

/ *     * /
int binary_op（int a，int b，int（* op）（int，int））;

/ *      * /
％callback（ “％s_cb”）;
int add（int，int）;
int sub（int，int）;
int mul（int，int）;
％nocallback;

>>> binary_op（3,4，add_cb）
7
>>> binary_op（3,4，mul_cb）
12
>>> add（3,4）
7
>>> mul（3,4）
12

/* file : vector.h */
...
typedef struct Vector {
double x, y, z;
} Vector

// file : vector.i
%module mymodule
%{
#include "vector.h"
%}
%include "vector.h"
// Just grab original C header file
%extend Vector {
// Attach these functions to struct Vector
Vector(double x, double y, double z) {
Vector *v;
v = (Vector *) malloc(sizeof(Vector));
v->x = x;
v->y = y;
v->z = z;
return v;
}
~Vector() {
free($self);
}
double magnitude() {
return sqrt($self->x*$self->x+$self->y*$self->y+$self->z*$self->z);
}
void print() {
printf("Vector [%g, %g, %g]
", $self->x, $self->y, $self->z);
}
};

%ignore foo(double); //Ignore all foo(double)
%ignore Spam::foo; //Ignore foo in class Spam
%ignore Spam::foo(double);//Ignore foo(double) in class Spam
%ignore *::foo(double);//Ignore foo(double) in all classes

%rename(foo_i) *::foo(int);

%rename(foo_i) Spam::foo(int);
%rename(foo_d) Spam::foo(double);//          

%rename(foo_i) ::foo(int);

%rename(foo_i) foo;

%template(intList) vector<int>;
typedef int Integer;
...
void foo(vector<Integer> *x);

//     traits, but don't       
%template() traits<double, double>;

%define TEMPLATE_WRAP(prefix, T...) //    ...，         ， 
//std::pair          。                    。
%template(prefix ## Foo) Foo<T >;
%template(prefix ## Bar) Bar<T >;
...
%enddef
TEMPLATE_WRAP(int, int)
TEMPLATE_WRAP(double, double)
TEMPLATE_WRAP(String, char *)
TEMPLATE_WRAP(PairStringInt, std::pair<string, int>)
...

template<class T1, class T2> struct pair {
T1 first;
T2 second;
pair() : first(T1()), second(T2()) { }
pair(const T1 &x, const T2 &y) : first(x), second(y) { }
template<class U1, class U2> pair(const pair<U1, U2> &x)
: first(x.first), second(x.second) { }
};

%extend pair {
%template(pair) pair<T1, T2>; //           
};

// Instantiate a few versions
%template(pairii) pair<int, int>;
%template(pairdd) pair<double, double>;
// Create a default constructor only
%extend pair<int, int> {
%template(paird) pair<int, int>; // Default constructor
};
// Create default and conversion constructors
%extend pair<double, double> {
%template(paird) pair<double, dobule>;// Default constructor
%template(pairc) pair<int, int>;// Conversion constructor
}

class RCObj {
// implement the ref counting mechanism
int add_ref();
int del_ref();
int ref_count();
public:
virtual ~RCObj() = 0;
int ref() const {
return add_ref();
}
int unref() const {
if (ref_count() == 0 || del_ref() == 0 ) {
delete this;
return 0;
}
return ref_count();
}
};
class A : RCObj {
public:
A();
int foo();
};
class B {
A *_a;
public:
B(A *a) : _a(a) {
a->ref();
}
~B() {
a->unref();
}
};

%module example
...
%feature("ref") RCObj "$this->ref();"
%feature("unref") RCObj "$this->unref();"
%include "rcobj.h"
%include "A.h"
...

%newobject AFactory;
A *AFactory() {
return new A();
}

%newobject derived::bar;

%inline %{
class derived : public base {
public:
derived * bar(){
return new derived();
}
};
%}

%typemap(method [, modifiers]) typelist code ;

typelist : typepattern [, typepattern, typepattern, ... ] ;
typepattern : type [ (parms) ]               int/*       */ (int temp/*   wrapper        */)
| type name [ (parms) ]                         int len/*       */ (int temp/*   wrapper        */)
| ( typelist ) [ (parms) ]                         （char *str, int len)/*       */ (int temp/*   wrapper        */)

code       : { ... } //   {}
           | " ... " //    {}
           | %{ ... %}//    {}

namespace Foo {
  class string;
  %typemap(in) string {          /* Foo::string */
    ...
  }
}

%module TypemapExample //  java  
//argxx    wrapper       

//          ，                  。
//              ，          ，                 C/C++   （       %rename                 ）。                ，                        
%typemap(typecheck , precedence=SWIG_TYPECHECK_INTEGER) int {
$1 = Custom_Check_Int($input) ? 1 : 0;//     int  
}
//     
/* Required for C++ method overloading */
/*%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (int argc, char *argv[]) {
$1 = PyList_Check($input) ? 1 : 0;
}*/

//      （  C/C++    ）
%typemap(arginit) int flags {
//arginit，   wrapper      
$1 = NULL;
}

%typemap(default) int flags {
//default，  wrapper         
$1 = DEFAULT_FLAGS;
}

%typemap(in) int flags {
//in， java     c/c++ int
$1 = JavaObj_to_int($input);
}


%typemap(check) int flags {
//check，       
if ($1 <= 0) {
SWIG_exception(SWIG_ValueError, "Expected positive value.");
}
}

%typemap(out) int foo {
//out，C/C++         ——            
//\$\1，C/C++     
$result = To_Java_Int($1);
}

%typemap(argout) int flags {
//argout，         
$result += $1
}

%typemap(freearg) int flags {
//freearg
free($1);
}

%typemap(newfree) int {
//newfree，   C/C++        。    （%newobject）    
delete $1;
}

%typemap(varin) int {
//varin，      。    python     
$1 = PythonInt_To_C($input);
}

%typemap(varout) int {
//varout，      。    python     
$1 = C_To_PythonInt($result);
}

int ALL_TIMES;

%typemap(ret) stringheap_t %{
//ret，  C/C++         
free($1);
%}

typedef char * string_t;
typedef char * stringheap_t;

string_t MakeString1();
stringheap_t MakeString2();

//numinputs    0   1
//0  wrapper          ，                ，$input    
//1  wrapper         ，                 ，$input  
/*
%typemap(in, numinputs=0) int flags (int temp) {
$1 = &temp;
}*/

%newobject foo;
int foo(int x, int y, int flags);



/*%typemap(memberin) int x[20] {
//memberin，
memmove($1, $input, 4*sizeof(int));
}*/

%typemap(memberin) int x[ANY] {
//memberin，          set                C/C++     
memmove($1, $input, $1_dim0*sizeof(int));
}

struct A {
int x[4];
};


%fragment("AsMyClassFragment", "header") {
//%fragment("AsMyClassFragment", "header")
MyClass *AsMyClassA(PyObject *obj) {
MyClass *value = 0;

return value;
}
}

%typemap(in, fragment="AsMyClassFragment") MyClass * {
//in，             MyClass *   ，  wrapper header    fragment  
$result = AsMyClassA($input);
}

%typemap(varin, fragment="AsMyClassFragment") MyClass * {
//varin
$result = AsMyClassA($input);
}

void foo(MyClass *a, MyClass *b);

%fragment("", "header") {
%#include <limits.h>
}

%fragment("AsMyClass", "header", fragment="") {//fragment  fragment
MyClass *AsMyClass(PyObject *obj) {
MyClass *value = 0;

... some marshalling code ...

if (ival < CHAR_MIN /*defined in */) {
...
} else {
...
}
...
return value;
}
}

//%fragment("bigfragment", "header", fragment="frag1", fragment="frag2", fragment="frag3") "";//    fragment

//typemap    fragment
//%typemap(in, fragment="frag1, frag2, frag3") {...}
//  
//%typemap(in, fragment="bigfragment") {...}

//    fragment    
//%fragment("bigfragment");

//          C/C++        
//jstring jarg1 -> char *str, int len
%typemap(in) (char *str, int len) {
$1 = PyString_AsString($input);
/* char *str */
$2 = PyString_Size($input);
/* int len
*/
}

int foo(char *str, int len);



%typemap(in) const int* bar{
$symname
$argnum
$1_name

$1_type
$*1_type
$&1_type

$1_ltype
$*1_ltype
$&1_ltype

$1_basetype

$1_descriptor
$*1_descriptor
$&1_descriptor

$1_mangle
$*1_mangle
$&1_mangle

$descriptor(std :: vector <int> *)
}
int barf( const int *bar);



%typemap(in) (int argc, char *argv[]) {
int i;
if (!PyList_Check($input)) {
PyErr_SetString(PyExc_ValueError, "Expecting a list");
SWIG_fail;
}
$1 = PyList_Size($input);
$2 = (char **) malloc(($1+1)*sizeof(char *));
for (i = 0; i < $1; i++) {
PyObject *s = PyList_GetItem($input, i);
if (!PyString_Check(s)) {
free($2);
PyErr_SetString(PyExc_ValueError, "List items must be strings");
SWIG_fail;
}
$2[i] = PyString_AsString(s);
}
$2[i] = 0;
}

%typemap(freearg) (int argc, char *argv[]) {
if ($2) free($2);
}

%fragment("incode"{float}, "header") {
float in_method_float(PyObject *obj) {
}
}

%fragment("incode"{long}, "header") {
float in_method_long(PyObject *obj) {
}
}

// %my_typemaps macro definition
%define %my_typemaps(Type) 
%typemap(in, fragment="incode"{Type}) Type {
value = in_method_##Type(obj);
}
%enddef

%my_typemaps(float);
%my_typemaps(long);

int foo(int argc, char *argv[]);

int agoda(long argc, char *argv[]);