SWIGing for fun and profit

Introduction

Using SWIG

Interface files

%module test;

%{
#include "test.h";
%}

class Test
{
public:
Test();
~Test();
void PutNum(int num);
int GetNum();
};

Running SWIG

swig -python -c++ -shadow -o test_wrap.cxx test.i

swig -perl5 -c++ -shadow -o test_wrap.cxx test.i

Using the generated code

Python

from test import *
t=Test()
t.PutNum(5)
print t.GetNum()

Perl

use test;
$t=Test::new();
$t->PutNum(5);
printf "%d", $t->GetNum()

Java

import test.*;
public class TryIt
{
static
{
try
{
System.loadLibrary("test");
}
catch (UnsatisfiedLinkError e)
{
System.err.println(e.toString());
System.exit(-1);
}
}
public static void main(String args[])
{
Test t = new Test();
t.PutNum(5);
System.out.println(t.GetNum());
}
}

Tips

Modifying function signatures

%module test;

%{
#include "test.h";
%}

class Test
{
public:
Test();
~Test();
void PutNum(int num);
int GetNum();
};

%addmethods Test
{
int SwapNum(int newNum)
{
int oldNum = self->GetNum();
self->PutNum(newNum);
return oldNum;
}
}

Exception handling

%except(python)
{
try
{
$function
}
catch (XD_Exception &err)
{
PyObject *retVal = Py_BuildValue("l", err.m_xdStatus);
if (err.m_xdStatus==XD_ERR_INVALID_INDEX)
PyErr_SetObject(PyExc_IndexError, retVal);
else
PyErr_SetObject(PyExc_RuntimeError, retVal);
return NULL;
}
}

%except(java)
{
try
{
$function
}
catch (XD_Exception &err)
{
ThrowJavaException(err);
}
}

%except(perl5)
{
try
{
$function
}
catch (XD_Exception &err)
{
croak(err.m_errMsg);
}
}

Memory management

Object GetObject();

Object *GetObject();

Embedding

Approach

A simple example

%module info;

%{
#include "Info.h";
%}

class Info
{
public:
Info();
~Info();
int GetArg1();
int GetArg2();
void PutResult(int num);
};

#ifndef __Info_H
#define __Info_H

class Info
{
public:
Info();
~Info();
void PutArg1(int num) {m_arg1=num;};
int GetArg1() {return m_arg1;};
void PutArg2(int num) {m_arg2=num;};
int GetArg2() {return m_arg2;};
void PutResult(int num) {m_result=num;};
int GetResult() {return m_result;};
private:
int m_result;
int m_arg1;
int m_arg2;
};

#endif

Python specifics

from info import *
import cleverModule

def CallCleverMethod(infoThis):
infoPtr = InfoPtr(infoThis)
arg1 = InfoPtr.GetArg1()
arg2 = InfoPtr.GetArg2()
result = cleverModule.cleverMethod(arg1, arg2)
infoPtr.PutResult(result)

// initialise our information object
Info info;
info.SetArg1(10);
info.SetArg2(20);

// initialise the Python interpreter
if (!Py_IsInitialized())
Py_Initialize();

// create a SWIG pointer string
char infoBuf[128];
SWIG_MakePtr(infoBuf, &info,"_Info_p");

// find the shim module and entry point function
PyObject *pyModule = PyImport_ImportModule("CleverModuleShim");
PyObject *pyModuleDict = PyModule_GetDict(pyModule);
PyObject *pyFunc = PyDict_GetItemString(pyModuleDict, "CallCleverMethod");

// call the shim code
Py_INCREF(pyFunc);
PyObject *pyRetVal = PyObject_CallFunction(pyFunc, "(s)", infoBuf);
Py_DECREF(pyFunc);

// output the result
printf("%d",info.GetResult());

Java specifics

import info.*;
import cleverModule;

public class CleverMethodShim
{
public static void CallCleverMethod(long infoThis)
{
Info infoPtr = (Info)Info.newInstance(infoThis);
int arg1 = InfoPtr.GetArg1()
int arg2 = InfoPtr.GetArg2()
int result = cleverModule.cleverMethod(arg1, arg2)
infoPtr.PutResult(result)
}
}

// initialise our information object
Info info;
info.SetArg1(10);
info.SetArg2(20);

// create Java VM
JavaVMInitArgs vm_args;
JavaVM *pVM;
JNIEnv *pEnv;
vm_args.version = JNI_VERSION_1_2;
vm_args.options = NULL;
vm_args.nOptions = 0;
vm_args.ignoreUnrecognized = TRUE;
jint res = JNI_CreateJavaVM(&pVM, (void **)&pEnv, &vm_args);

// find the shim class and entry point function
jclass pClass = pEnv->FindClass("CleverMethodShim");
jmethodID methodID = pEnv->GetStaticMethodID(pClass, "CallCleverMethod",
"(J)V");

// call the shim code
pEnv->CallStaticVoidMethod(pClass, methodID, (jlong)&info);
pEnv->ExceptionClear();

// output the result
printf("%d",info.GetResult());

Real world examples

Wrapping a large C++ class library

Modularisation

%title Astoria Script API
%module asp;

%section "XD_Database"
%include xddatbse.i

%section "Core API"
%include xdobject.i

%subsection "XD_CapabilityGroup"
%include xdcapgrp.i

%subsection "XD_LinkItem"
%include xdlnkitm.i

%subsection "Named Objects"
%include xdnamobj.i

...

Callback functions

Error handling

Function signature changes

XDSTATUS GetObject(char *name, XD_Object *pObj, BOOL *foundIt);

XD_Object GetObject(char *name);

%addmethods XD_SomeClass
{
XD_Object GetObject(char *name)
{
BOOL foundIt = FALSE;
XD_Object object;
XDSTATUS status;
status = self->GetObject(name,&object,&foundIt);
CheckStatus(status);
CheckFound(foundIt);
return object;
}
}

Using Python to process SAX events generated in C++

%typemap(python,in) PyObject *pHandler
{
$target=$source;
}

class XD_SAXDriver
{
public:
XD_SAXDriver();
~XD_SAXDriver();

// Python callback function registration
void SetStartElementHandler(PyObject *pHandler);
void SetEndElementHandler(PyObject *pHandler);
void SetCharacterHandler(PyObject *pHandler);
void SetPIHandler(PyObject *pHandler);

// Entry point to start parsing from a given repository object
void ParseObject(XD_Database *database, XD_Object *object);

// Astoria specific options
void SetAddAstID(long addIt);
void SetAddCustAttrs(long addEm);
void SetResolveEntAttrs(long resolveEm);
};

from xml.sax import saxlib,saxutils
from asp import *

class asp_sax(saxlib.Parser):
"SAX parser for Astoria documents and sub documents"
 
def __init__(self):
saxlib.Parser.__init__(self)
self.xdDriver = XD_SAXDriver()
self.xdDriver.SetStartElementHandler(self.startElement)
self.xdDriver.SetEndElementHandler(self.endElement)
self.xdDriver.SetCharacterHandler(self.characters)
self.xdDriver.SetPIHandler(self.processingInstruction)

def startElement(self,name,attrs):
attrList = XD_StringMapPtr(attrs)
at={}
for key in attrList:
at[key]=attrList.GetValueByKey(key)
self.doc_handler.startElement(name,saxutils.AttributeMap(at))

def endElement(self,name):
self.doc_handler.endElement(name)

def characters(self,data):
self.doc_handler.characters(data,0,len(data))

def processingInstruction(self,target,data):
self.doc_handler.processingInstruction(target,data)

def parseObject(self,database,obj):
"Parse an Astoria structured document"
self.doc_handler.startDocument()
self.xdDriver.ParseObject(database,obj)
self.doc_handler.endDocument()

def create_parser():
return asp_sax()

from xml.sax import saxlib
import asp_sax

class XMLPrinter(saxlib.HandlerBase):
def __init__(self):
saxlib.HandlerBase.__init__(self)

def startDocument(self):
print "<?xml version=\\"1.0\\"\ "

def endDocument(self):
pass

def startElement(self, name, attrs):
print "<%s" % (name)
for i in attrs.keys():
print " %s=\\"%s\\"" % (i, attrs[i])
print ">"

def endElement(self,name):
print "</%s>\ " % (name)

def characters(self, ch, start, length):
print ch

parser = asp_sax.create_parser()
dh = XMLPrinter()
parser.setDocumentHandler(dh)
parser.parseObject(db,doc)

Using a Java XSLT processor from C++

%typemap(java,jni) jobject *IN {jobject}
%typemap(java,jtype) jobject *IN {Object}
%typemap(java,in) jobject *IN {
$target = &($source);
}
%typemap(java,out) jobject IN {
*$target = (jobject)$source;
}
%apply jobject IN {jobject cbHandler};
%apply jobject IN {jobject callerData};

class XD_JSAXDriver
{
public:
XD_JSAXDriver();
~XD_JSAXDriver();

void ParseObject(XD_Database *database, XD_Object *object,
jobject cbHandler, jobject callerData);
void SetAddAstID(long addIt);
void SetAddCustAttrs(long addEm);
void SetResolveEntAttrs(long resolveEm);
};

%module wsp
%{
#include "HttpUtil.h"
%}

class XW_HttpUtil
{
public:
XW_HttpUtil(XD_Database *pDB=NULL,XWIO *pXWIO=NULL);
~XW_HttpUtil();

XD_Database *GetDB();
char *GetParameterValue(char *parameterName);
void WriteHtml(char *string);
};

import com.chrystal.wsp.*;
import com.chrystal.asp.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import com.jclark.xsl.sax.*;

class XSLSupport extends HandlerBase
{
public static void DisplayObject(long objPtr)
{
try
{
XW_HttpUtil xwio = (XW_HttpUtil)XW_HttpUtil.newInstance(objPtr);
XD_Database db = (XD_Database)XD_Database.newInstance(xwio.GetDB());

// get the currently selected object
String selStr = xwio.GetParameterValue("xwObject");

// get the associated document
XD_SGMLDocument docObj =
(XD_SGMLDocument)asp_factory.Construct(db,selStr);
String docStr = asp.ObjectToString(db._self(),docObj._self());

// get the associated style object
XD_Style styleObj = docObj.GetStyle(db);
String styleStr = asp.ObjectToString(db._self(),styleObj._self());

// apply the stylesheet
XSLSupport xslProc = new XSLSupport(db,xwio);
xslProc.ApplyStylesheet(docStr,styleStr);
}
catch (Exception ex)
{
}
}

XSLSupport(XD_Database db, XW_HttpUtil xwio)
{
m_db = db;
m_xwio = xwio;
}

protected void ApplyStylesheet(String docObj,String styleObj)
throws SAXException, java.io.IOException
{
// initialise document source
InputSource docSource = new InputSource(docObj);
XD_SAXDriver docParser = new XD_SAXDriver();
docParser.setDatabase(m_db);

// initialise style source
InputSource styleSource = new InputSource(styleObj);
XD_SAXDriver styleParser = new XD_SAXDriver();
styleParser.setDatabase(m_db);

// initialise XSL processor
XSLProcessorImpl xslProcessor = new XSLProcessorImpl();
xslProcessor.setParser(docParser,styleParser);
DocumentHandler outputHandler = (DocumentHandler)this;
xslProcessor.setDocumentHandler(outputHandler);

// run the transformation
xslProcessor.loadStylesheet(styleSource);
xslProcessor.parse(docSource);
}

// SAX DocumentHandler overrides
public void characters (char ch[], int start, int length)
{
String str = new String(ch,start,length);
m_xwio.WriteHtml(str);
}

public void startElement (String name, AttributeList atts)
{
m_xwio.WriteHtml("<" + name);
for (int i = 0; i < atts.getLength(); i++)
{
m_xwio.WriteHtml(" "+atts.getName(i)+"="+atts.getValue(i));
}
m_xwio.WriteHtml(">");
}

public void endElement (String name)
{
m_xwio.WriteHtml("</" + name + ">" + "\ ");
}

XD_Database m_db;
XW_HttpUtil m_xwio;
}

Conclusion