Adding binaries for 2.0.11
diff --git a/bin/ccache-swig.exe b/bin/ccache-swig.exe
new file mode 100755
index 0000000..820efa5
--- /dev/null
+++ b/bin/ccache-swig.exe
Binary files differ
diff --git a/bin/swig.exe b/bin/swig.exe
new file mode 100755
index 0000000..a0cc3bc
--- /dev/null
+++ b/bin/swig.exe
Binary files differ
diff --git a/build-common.sh b/build-common.sh
new file mode 100644
index 0000000..0c5c0a3
--- /dev/null
+++ b/build-common.sh
@@ -0,0 +1,116 @@
+# inputs
+# $PROJ - project name (cmake|ninja|swig)
+# $VER - project version
+# $1 - name of this file
+#
+# this file does the following:
+#
+# 1) define the following env vars
+# OS - linux|darwin|windows
+# USER - username
+# CORES - numer of cores (for parallel builds)
+# PATH (with appropriate compilers)
+# CFLAGS/CXXFLAGS/LDFLAGS
+# RD - root directory for source and object files
+# INSTALL - install directory/git repo root
+# SCRIPT_FILE=absolute path to the parent build script
+# SCRIPT_DIR=absolute path to the parent build script's directory
+# COMMON_FILE=absolute path to this file
+
+#
+# 2) create an empty tmp directory at /tmp/$PROJ-$USER
+# 3) checkout the destination git repo to /tmp/prebuilts/$PROJ/$OS-x86/$VER
+# 4) cd $RD
+
+UNAME="$(uname)"
+case "$UNAME" in
+Linux)
+    SCRATCH=/tmp
+    OS='linux'
+    INSTALL_VER=$VER
+    ;;
+Darwin)
+    SCRATCH=/tmp
+    OS='darwin'
+    OSX_MIN=10.6
+    export CFLAGS="$CFLAGS -mmacosx-version-min=$OSX_MIN"
+    export CXXFLAGS="$CXXFLAGS -mmacosx-version-min=$OSX_MIN"
+    export LDFLAGS="$LDFLAGS -mmacosx-version-min=$OSX_MIN"
+    INSTALL_VER=$VER
+    ;;
+*_NT-*)
+    if [[ "$UNAME" == CYGWIN_NT-* ]]; then
+        PATH_PREFIX=/cygdrive
+    else
+        # MINGW32_NT-*
+        PATH_PREFIX=
+    fi
+    SCRATCH=$PATH_PREFIX/d/src/tmp
+    USER=$USERNAME
+    OS='windows'
+    CORES=$NUMBER_OF_PROCESSORS
+    # VS2013 x64 Native Tools Command Prompt
+    case "$MSVS" in
+    2013)
+        export PATH="$PATH_PREFIX/c/Program Files (x86)/Microsoft Visual Studio 12.0/VC/bin/amd64/":"$PATH_PREFIX/c/Program Files (x86)/Microsoft Visual Studio 12.0/Common7/IDE/":"$PATH_PREFIX/c/Program Files (x86)/Windows Kits/8.1/bin/x64":"$PATH"
+        export INCLUDE="C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\INCLUDE;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\shared;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\um;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\winrt;"
+        export LIB="C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64;C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x64;"
+        export LIBPATH="C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64;C:\\Program Files (x86)\\Windows Kits\\8.1\\References\\CommonConfiguration\\Neutral;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1\\ExtensionSDKs\\Microsoft.VCLibs\\12.0\\References\\CommonConfiguration\\neutral;"
+        INSTALL_VER=${VER}_vs${MSVS}
+        ;;
+    *)
+        # g++/make build
+        export CC=x86_64-w64-mingw32-gcc
+        export CXX=x86_64-w64-mingw32-g++
+        export LD=x86_64-w64-mingw32-ld
+        ;;
+    esac
+    ;;
+*)
+    exit 1
+    ;;
+esac
+
+RD=$SCRATCH/$PROJ-$USER
+INSTALL="$RD/install"
+
+cd /tmp # windows can't delete if you're in the dir
+rm -rf $RD
+mkdir -p $INSTALL
+mkdir -p $RD
+cd $RD
+
+# OSX lacks a "realpath" bash command
+realpath() {
+    [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
+}
+
+SCRIPT_FILE=$(realpath "$0")
+SCRIPT_DIR="$(dirname "$SCRIPT_FILE")"
+COMMON_FILE="$SCRIPT_DIR/$1"
+
+commit_and_push()
+{
+    # check into a local git clone
+    rm -rf $SCRATCH/prebuilts/$PROJ/
+    mkdir -p $SCRATCH/prebuilts/$PROJ/
+    cd $SCRATCH/prebuilts/$PROJ/
+    git clone https://android.googlesource.com/platform/prebuilts/$PROJ/$OS-x86
+    GIT_REPO="$SCRATCH/prebuilts/$PROJ/$OS-x86"
+    cd $GIT_REPO
+    git rm -r * || true  # ignore error caused by empty directory
+    mv $INSTALL/* $GIT_REPO
+    cp $SCRIPT_FILE $GIT_REPO
+    cp $COMMON_FILE $GIT_REPO
+
+    git add .
+    if [ -n "$ANDROID_EMAIL" ]; then
+        git config user.email $ANDROID_EMAIL
+    fi
+    git commit -m "Adding binaries for $INSTALL_VER"
+
+    # execute this command to upload
+    #git push origin HEAD:refs/for/master
+
+    rm -rf $RD || true  # ignore error
+}
diff --git a/build-swig.sh b/build-swig.sh
new file mode 100755
index 0000000..9866faa
--- /dev/null
+++ b/build-swig.sh
@@ -0,0 +1,32 @@
+#!/bin/bash -ex
+# Download & build swig on the local machine
+# works on Linux, OSX, and Windows (Cygwin w/make 4.1, curl, gcc 4.9.2)
+# leaves output in /tmp/prebuilts/install/
+# cmake must be installed on Windows
+
+PROJ=swig
+VER=2.0.11
+
+source $(dirname "$0")/build-common.sh build-common.sh
+
+TGZ=$PROJ-$VER.tar.gz
+curl -L http://downloads.sourceforge.net/project/swig/swig/$PROJ-$VER/$TGZ -o $TGZ
+tar xzf $TGZ || cat $TGZ
+mkdir -p $RD/build
+cd $RD/build
+
+# build PCRE as a static library from a tarball just for use during the SWIG build.
+# GNU make 3.81 (MinGW version) crashes on Windows
+curl -L ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.37.tar.gz -o pcre-8.37.tar.gz
+$RD/$PROJ-$VER/Tools/pcre-build.sh
+
+if [ "$OS" == "windows" ]; then
+    SWIG_CFLAGS="-static -static-libgcc"
+    SWIG_CXXFLAGS="-static -static-libgcc -static-libstdc++"
+fi
+$RD/$PROJ-$VER/configure CFLAGS="$SWIG_CFLAGS" CXXFLAGS="$SWIG_CXXFLAGS" --prefix=$INSTALL
+make -j$CORES
+make install
+cd $INSTALL/bin
+
+commit_and_push
diff --git a/share/man/man1/ccache-swig.1 b/share/man/man1/ccache-swig.1
new file mode 100644
index 0000000..0081b6d
--- /dev/null
+++ b/share/man/man1/ccache-swig.1
@@ -0,0 +1,453 @@
+.TH "ccache\-swig" "1" "" "" ""
+
+.PP 
+.SH "NAME"
+ccache\-swig \- a fast compiler cache
+.PP 
+.SH "SYNOPSIS"
+
+.PP 
+ccache\-swig [OPTION]
+.PP 
+ccache\-swig <compiler> [COMPILER OPTIONS]
+.PP 
+<compiler> [COMPILER OPTIONS]
+.PP 
+.SH "DESCRIPTION"
+
+.PP 
+ccache\-swig is a compiler cache\&. It speeds up re\-compilation of C/C++/SWIG code 
+by caching previous compiles and detecting when the same compile is
+being done again\&. ccache\-swig is ccache plus support for SWIG\&. ccache
+and ccache\-swig are used interchangeably in this document\&.
+.PP 
+.SH "OPTIONS SUMMARY"
+
+.PP 
+Here is a summary of the options to ccache\-swig\&.
+.PP 
+.nf 
+
+\-s                      show statistics summary
+\-z                      zero statistics
+\-c                      run a cache cleanup
+\-C                      clear the cache completely
+\-F <n>                  set maximum files in cache
+\-M <n>                  set maximum size of cache (use G, M or K)
+\-h                      this help page
+\-V                      print version number
+
+.fi 
+
+.PP 
+.SH "OPTIONS"
+
+.PP 
+These options only apply when you invoke ccache as \(dq\&ccache\-swig\(dq\&\&. When
+invoked as a compiler none of these options apply\&. In that case your
+normal compiler options apply and you should refer to your compilers
+documentation\&.
+.PP 
+.IP "\fB\-h\fP"
+Print a options summary page
+.IP 
+.IP "\fB\-s\fP"
+Print the current statistics summary for the cache\&. The
+statistics are stored spread across the subdirectories of the
+cache\&. Using \(dq\&ccache\-swig \-s\(dq\& adds up the statistics across all
+subdirectories and prints the totals\&.
+.IP 
+.IP "\fB\-z\fP"
+Zero the cache statistics\&. 
+.IP 
+.IP "\fB\-V\fP"
+Print the ccache version number
+.IP 
+.IP "\fB\-c\fP"
+Clean the cache and re\-calculate the cache file count and
+size totals\&. Normally the \-c option should not be necessary as ccache
+keeps the cache below the specified limits at runtime and keeps
+statistics up to date on each compile\&. This option is mostly useful
+if you manually modify the cache contents or believe that the cache
+size statistics may be inaccurate\&.
+.IP 
+.IP "\fB\-C\fP"
+Clear the entire cache, removing all cached files\&.
+.IP 
+.IP "\fB\-F <maxfiles>\fP"
+This sets the maximum number of files allowed in
+the cache\&. The value is stored inside the cache directory and applies
+to all future compiles\&. Due to the way the value is stored the actual
+value used is always rounded down to the nearest multiple of 16\&.
+.IP 
+.IP "\fB\-M <maxsize>\fP"
+This sets the maximum cache size\&. You can specify
+a value in gigabytes, megabytes or kilobytes by appending a G, M or K
+to the value\&. The default is gigabytes\&. The actual value stored is
+rounded down to the nearest multiple of 16 kilobytes\&.
+.IP 
+.SH "INSTALLATION"
+
+.PP 
+There are two ways to use ccache\&. You can either prefix your compile
+commands with \(dq\&ccache\-swig\(dq\& or you can create a symbolic link between
+ccache\-swig and the names of your compilers\&. The first method is most
+convenient if you just want to try out ccache or wish to use it for
+some specific projects\&. The second method is most useful for when you
+wish to use ccache for all your compiles\&.
+.PP 
+To install for usage by the first method just copy ccache\-swig to somewhere
+in your path\&. 
+.PP 
+To install for the second method do something like this:
+.nf 
+
+  cp ccache\-swig /usr/local/bin/
+  ln \-s /usr/local/bin/ccache\-swig /usr/local/bin/gcc
+  ln \-s /usr/local/bin/ccache\-swig /usr/local/bin/g++
+  ln \-s /usr/local/bin/ccache\-swig /usr/local/bin/cc
+  ln \-s /usr/local/bin/ccache\-swig /usr/local/bin/swig
+
+.fi 
+This will work as long as /usr/local/bin comes before the path to gcc
+(which is usually in /usr/bin)\&. After installing you may wish to run
+\(dq\&which gcc\(dq\& to make sure that the correct link is being used\&.
+.PP 
+Note! Do not use a hard link, use a symbolic link\&. A hardlink will
+cause \(dq\&interesting\(dq\& problems\&.
+.PP 
+.SH "EXTRA OPTIONS"
+
+.PP 
+When run as a compiler front end ccache usually just takes the same
+command line options as the compiler you are using\&. The only exception
+to this is the option \(cq\&\-\-ccache\-skip\(cq\&\&. That option can be used to tell
+ccache that the next option is definitely not a input filename, and
+should be passed along to the compiler as\-is\&. 
+.PP 
+The reason this can be important is that ccache does need to parse the
+command line and determine what is an input filename and what is a
+compiler option, as it needs the input filename to determine the name
+of the resulting object file (among other things)\&. The heuristic
+ccache uses in this parse is that any string on the command line that
+exists as a file is treated as an input file name (usually a C
+file)\&. By using \-\-ccache\-skip you can force an option to not be
+treated as an input file name and instead be passed along to the
+compiler as a command line option\&.
+.PP 
+.SH "ENVIRONMENT VARIABLES"
+
+.PP 
+ccache uses a number of environment variables to control operation\&. In
+most cases you won\(cq\&t need any of these as the defaults will be fine\&.
+.PP 
+.IP "\fBCCACHE_DIR\fP"
+the CCACHE_DIR environment variable specifies
+where ccache will keep its cached compiler output\&. The default is
+\(dq\&$HOME/\&.ccache\(dq\&\&.
+.IP 
+.IP "\fBCCACHE_TEMPDIR\fP"
+the CCACHE_TEMPDIR environment variable specifies
+where ccache will put temporary files\&. The default is the same as
+CCACHE_DIR\&. Note that the CCACHE_TEMPDIR path must be on the same
+filesystem as the CCACHE_DIR path, so that renames of files between
+the two directories can work\&.
+.IP 
+.IP "\fBCCACHE_LOGFILE\fP"
+If you set the CCACHE_LOGFILE environment
+variable then ccache will write some log information on cache hits
+and misses in that file\&. This is useful for tracking down problems\&.
+.IP 
+.IP "\fBCCACHE_VERBOSE\fP"
+If you set the CCACHE_VERBOSE environment
+variable then ccache will display on stdout all the compiler invocations
+that it makes\&. This can useful for debugging unexpected problems\&.
+.IP 
+.IP "\fBCCACHE_PATH\fP"
+You can optionally set CCACHE_PATH to a colon
+separated path where ccache will look for the real compilers\&. If you
+don\(cq\&t do this then ccache will look for the first executable matching
+the compiler name in the normal PATH that isn\(cq\&t a symbolic link to
+ccache itself\&.
+.IP 
+.IP "\fBCCACHE_CC\fP"
+You can optionally set CCACHE_CC to force the name
+of the compiler to use\&. If you don\(cq\&t do this then ccache works it out
+from the command line\&.
+.IP 
+.IP "\fBCCACHE_PREFIX\fP"
+This option adds a prefix to the command line
+that ccache runs when invoking the compiler\&. Also see the section
+below on using ccache with distcc\&.
+.IP 
+.IP "\fBCCACHE_DISABLE\fP"
+If you set the environment variable
+CCACHE_DISABLE then ccache will just call the real compiler,
+bypassing the cache completely\&.
+.IP 
+.IP "\fBCCACHE_READONLY\fP"
+the CCACHE_READONLY environment variable
+tells ccache to attempt to use existing cached object files, but not
+to try to add anything new to the cache\&. If you are using this because
+your CCACHE_DIR is read\-only, then you may find that you also need to
+set CCACHE_TEMPDIR as otherwise ccache will fail to create the
+temporary files\&.
+.IP 
+.IP "\fBCCACHE_CPP2\fP"
+If you set the environment variable CCACHE_CPP2
+then ccache will not use the optimisation of avoiding the 2nd call to
+the pre\-processor by compiling the pre\-processed output that was used
+for finding the hash in the case of a cache miss\&. This is primarily a
+debugging option, although it is possible that some unusual compilers
+will have problems with the intermediate filename extensions used in
+this optimisation, in which case this option could allow ccache to be
+used\&.
+.IP 
+.IP "\fBCCACHE_NOCOMPRESS\fP"
+If you set the environment variable
+CCACHE_NOCOMPRESS then there is no compression used on files that go
+into the cache\&. However, this setting has no effect on how files are
+retrieved from the cache, compressed results will still be usable\&.
+.IP 
+.IP "\fBCCACHE_NOSTATS\fP"
+If you set the environment variable
+CCACHE_NOSTATS then ccache will not update the statistics files on
+each compile\&.
+.IP 
+.IP "\fBCCACHE_NLEVELS\fP"
+The environment variable CCACHE_NLEVELS allows
+you to choose the number of levels of hash in the cache directory\&. The
+default is 2\&. The minimum is 1 and the maximum is 8\&. 
+.IP 
+.IP "\fBCCACHE_HARDLINK\fP"
+If you set the environment variable
+CCACHE_HARDLINK then ccache will attempt to use hard links from the
+cache directory when creating the compiler output rather than using a
+file copy\&. Using hard links is faster, but can confuse programs like
+\(cq\&make\(cq\& that rely on modification times\&. Hard links are never made for
+compressed cache files\&.
+.IP 
+.IP "\fBCCACHE_RECACHE\fP"
+This forces ccache to not use any cached
+results, even if it finds them\&. New results are still cached, but
+existing cache entries are ignored\&.
+.IP 
+.IP "\fBCCACHE_UMASK\fP"
+This sets the umask for ccache and all child
+processes (such as the compiler)\&. This is mostly useful when you wish
+to share your cache with other users\&. Note that this also affects the
+file permissions set on the object files created from your
+compilations\&.
+.IP 
+.IP "\fBCCACHE_HASHDIR\fP"
+This tells ccache to hash the current working
+directory when calculating the hash that is used to distinguish two
+compiles\&. This prevents a problem with the storage of the current
+working directory in the debug info of a object file, which can lead
+ccache to give a cached object file that has the working directory in
+the debug info set incorrectly\&. This option is off by default as the
+incorrect setting of this debug info rarely causes problems\&. If you
+strike problems with gdb not using the correct directory then enable
+this option\&.
+.IP 
+.IP "\fBCCACHE_UNIFY\fP"
+If you set the environment variable CCACHE_UNIFY
+then ccache will use the C/C++ unifier when hashing the pre\-processor
+output if \-g is not used in the compile\&. The unifier is slower than a
+normal hash, so setting this environment variable loses a little bit
+of speed, but it means that ccache can take advantage of not
+recompiling when the changes to the source code consist of
+reformatting only\&. Note that using CCACHE_UNIFY changes the hash, so
+cached compiles with CCACHE_UNIFY set cannot be used when
+CCACHE_UNIFY is not set and vice versa\&. The reason the unifier is off
+by default is that it can give incorrect line number information in
+compiler warning messages\&.
+.IP 
+.IP "\fBCCACHE_EXTENSION\fP"
+Normally ccache tries to automatically
+determine the extension to use for intermediate C pre\-processor files
+based on the type of file being compiled\&. Unfortunately this sometimes
+doesn\(cq\&t work, for example when using the aCC compiler on HP\-UX\&. On
+systems like this you can use the CCACHE_EXTENSION option to override
+the default\&. On HP\-UX set this environment variable to \(dq\&i\(dq\& if you use
+the aCC compiler\&.
+.IP 
+.IP "\fBCCACHE_STRIPC\fP"
+If you set the environment variable 
+CCACHE_STRIPC then ccache will strip the \-c option when invoking
+the preprocessor\&. This option is primarily for the Sun Workshop
+C++ compiler as without this option an unwarranted warning is displayed:
+CC: Warning: \(dq\&\-E\(dq\& redefines product from \(dq\&object\(dq\& to \(dq\&source (stdout)\(dq\&
+when \-E and \-c is used together\&.
+.IP 
+.IP "\fBCCACHE_SWIG\fP"
+When using SWIG as the compiler and it does not
+have \(cq\&swig\(cq\& in the executable name, then the CCACHE_SWIG environment 
+variable needs to be set in order for ccache to work correctly with 
+SWIG\&. The use of CCACHE_CPP2 is also recommended for SWIG due to some
+preprocessor quirks, however, use of CCACHE_CPP2 can often be skipped
+\-\- check your generated code with and without this option set\&. Known
+problems are using preprocessor directives within %inline blocks and
+the use of \(cq\&#pragma SWIG\(cq\&\&.
+.IP 
+.SH "CACHE SIZE MANAGEMENT"
+
+.PP 
+By default ccache has a one gigabyte limit on the cache size and no
+maximum number of files\&. You can set a different limit using the
+\(dq\&ccache \-M\(dq\& and \(dq\&ccache \-F\(dq\& options, which set the size and number of
+files limits\&.
+.PP 
+When these limits are reached ccache will reduce the cache to 20%
+below the numbers you specified in order to avoid doing the cache
+clean operation too often\&.
+.PP 
+.SH "CACHE COMPRESSION"
+
+.PP 
+By default on most platforms ccache will compress all files it puts 
+into the cache
+using the zlib compression\&. While this involves a negligible
+performance slowdown, it significantly increases the number of files
+that fit in the cache\&. You can turn off compression setting the
+CCACHE_NOCOMPRESS environment variable\&.
+.PP 
+.SH "HOW IT WORKS"
+
+.PP 
+The basic idea is to detect when you are compiling exactly the same
+code a 2nd time and use the previously compiled output\&. You detect
+that it is the same code by forming a hash of:
+.PP 
+.IP o 
+the pre\-processor output from running the compiler with \-E
+.IP o 
+the command line options
+.IP o 
+the real compilers size and modification time
+.IP o 
+any stderr output generated by the compiler
+
+.PP 
+These are hashed using md4 (a strong hash) and a cache file is formed
+based on that hash result\&. When the same compilation is done a second
+time ccache is able to supply the correct compiler output (including
+all warnings etc) from the cache\&.
+.PP 
+ccache has been carefully written to always produce exactly the same
+compiler output that you would get without the cache\&. If you ever
+discover a case where ccache changes the output of your compiler then
+please let me know\&.
+.PP 
+.SH "USING CCACHE WITH DISTCC"
+
+.PP 
+distcc is a very useful program for distributing compilation across a
+range of compiler servers\&. It is often useful to combine distcc with
+ccache, so that compiles that are done are sped up by distcc, but that
+ccache avoids the compile completely where possible\&.
+.PP 
+To use distcc with ccache I recommend using the CCACHE_PREFIX
+option\&. You just need to set the environment variable CCACHE_PREFIX to
+\(cq\&distcc\(cq\& and ccache will prefix the command line used with the
+compiler with the command \(cq\&distcc\(cq\&\&. 
+.PP 
+.SH "SHARING A CACHE"
+
+.PP 
+A group of developers can increase the cache hit rate by sharing a
+cache directory\&.  The hard links however cause unwanted side effects,
+as all links to a cached file share the file\(cq\&s modification timestamp\&.
+This results in false dependencies to be triggered by timestamp\-based
+build systems whenever another user links to an existing
+file\&. Typically, users will see that their libraries and binaries are
+relinked without reason\&.  To share a cache without side effects, the
+following conditions need to be met:
+.PP 
+.IP o 
+Use the same \fBCCACHE_DIR\fP environment variable setting
+.IP o 
+Unset the \fBCCACHE_HARDLINK\fP environment variable
+.IP o 
+Make sure everyone sets the CCACHE_UMASK environment variable
+to 002, this ensures that cached files are accessible to everyone in
+the group\&.
+.IP o 
+Make sure that all users have write permission in the entire
+cache directory (and that you trust all users of the shared cache)\&. 
+.IP o 
+Make sure that the setgid bit is set on all directories in the
+cache\&. This tells the filesystem to inherit group ownership for new
+directories\&. The command \(dq\&chmod g+s `find $CCACHE_DIR \-type d`\(dq\& might
+be useful for this\&.
+.IP o 
+Set \fBCCACHE_NOCOMPRESS\fP for all users, if there are users with
+versions of ccache that do not support compression\&.
+
+.PP 
+.SH "HISTORY"
+
+.PP 
+ccache was inspired by the compilercache shell script script written
+by Erik Thiele and I would like to thank him for an excellent piece of
+work\&. See 
+http://www\&.erikyyy\&.de/compilercache/
+for the Erik\(cq\&s scripts\&.
+ccache\-swig is a port of the original ccache with support added for use
+with SWIG\&.
+.PP 
+I wrote ccache because I wanted to get a bit more speed out of a
+compiler cache and I wanted to remove some of the limitations of the
+shell\-script version\&.
+.PP 
+.SH "DIFFERENCES FROM COMPILERCACHE"
+
+.PP 
+The biggest differences between Erik\(cq\&s compilercache script and ccache
+are:
+.IP o 
+ccache is written in C, which makes it a bit faster (calling out to
+external programs is mostly what slowed down the scripts)\&.
+.IP o 
+ccache can automatically find the real compiler
+.IP o 
+ccache keeps statistics on hits/misses
+.IP o 
+ccache can do automatic cache management
+.IP o 
+ccache can cache compiler output that includes warnings\&. In many
+cases this gives ccache a much higher cache hit rate\&.
+.IP o 
+ccache can handle a much wider ranger of compiler options
+.IP o 
+ccache avoids a double call to cpp on a cache miss
+
+.PP 
+.SH "CREDITS"
+
+.PP 
+Thanks to the following people for their contributions to ccache
+.IP o 
+Erik Thiele for the original compilercache script
+.IP o 
+Luciano Rocha for the idea of compiling the pre\-processor output
+to avoid a 2nd cpp pass
+.IP o 
+Paul Russell for many suggestions and the debian packaging
+
+.PP 
+.SH "AUTHOR"
+
+.PP 
+ccache was written by Andrew Tridgell
+http://samba\&.org/~tridge/\&.
+ccache was adapted to create ccache\-swig for use with SWIG by William Fulton\&.
+.PP 
+If you wish to report a problem or make a suggestion then please email
+the SWIG developers on the swig\-devel mailing list, see
+http://www\&.swig\&.org/mail\&.html
+.PP 
+ccache is released under the GNU General Public License version 2 or
+later\&. Please see the file COPYING for license details\&.
+.PP 
+
diff --git a/share/swig/2.0.11/allegrocl/allegrocl.swg b/share/swig/2.0.11/allegrocl/allegrocl.swg
new file mode 100644
index 0000000..f08f87c
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/allegrocl.swg
@@ -0,0 +1,612 @@
+/* Define a C preprocessor symbol that can be used in interface files
+   to distinguish between the SWIG language modules. */ 
+
+#define SWIG_ALLEGRO_CL
+
+#define %ffargs(...) %feature("ffargs", "1", ##__VA_ARGS__)
+%ffargs(strings_convert="t");
+
+/* typemaps for argument and result type conversions. */
+%typemap(lin,numinputs=1)	SWIGTYPE 	"(cl::let (($out $in))\n  $body)";
+
+%typemap(lout) bool, char, unsigned char, signed char,
+               short, signed short, unsigned short,
+               int, signed int, unsigned int,
+               long, signed long, unsigned long,
+               float, double, long double, char *, void *,
+               enum SWIGTYPE    "(cl::setq ACL_ffresult $body)";
+%typemap(lout) void "$body";
+#ifdef __cplusplus
+%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *,
+               SWIGTYPE &       
+%{ (cl:let* ((address $body)
+	  (new-inst (cl:make-instance '$lclass :foreign-address address)))
+     (cl:when (cl:and $owner (cl:not (cl:zerop address)))
+       (excl:schedule-finalization new-inst #'$ldestructor))
+     (cl:setq ACL_ffresult new-inst)) %}
+
+%typemap(lout) SWIGTYPE         "(cl::let* ((address $body)\n         (new-inst (cl::make-instance '$lclass :foreign-address address)))\n    (cl::unless (cl::zerop address)\n      (excl:schedule-finalization new-inst #'$ldestructor))\n    (cl::setq ACL_ffresult new-inst))";
+#else
+%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *, SWIGTYPE &, SWIGTYPE
+%{ (cl:let* ((address $body)
+	  (new-inst (cl:make-instance '$lclass :foreign-address address)))
+     (cl:setq ACL_ffresult new-inst)) %}
+#endif
+
+%typemap(lisptype) bool, const bool "cl:boolean";
+%typemap(lisptype) char, const char "cl:character";
+%typemap(lisptype) unsigned char, const unsigned char "cl:integer";
+%typemap(lisptype) signed char, const signed char "cl:integer";
+
+%typemap(ffitype) bool, const bool ":int";
+%typemap(ffitype) char, const char,
+		  signed char, const signed char ":char";
+%typemap(ffitype) unsigned char, const unsigned char ":unsigned-char";
+%typemap(ffitype) short, const short,
+		  signed short, const signed short ":short";
+%typemap(ffitype) unsigned short, const unsigned short ":unsigned-short";
+%typemap(ffitype) int, const int, signed int, const signed int ":int";
+%typemap(ffitype) unsigned int, const unsigned int ":unsigned-int";
+%typemap(ffitype) long, const long, signed long, const signed long ":long";
+%typemap(ffitype) unsigned long, const unsigned long ":unsigned-long";
+%typemap(ffitype) float, const float ":float";
+%typemap(ffitype) double, const double ":double";
+%typemap(ffitype) char *, const char *, signed char *,
+		  const signed char *, signed char &,
+		  const signed char &			 "(* :char)";
+%typemap(ffitype) unsigned char *, const unsigned char *,
+		  unsigned char &, const unsigned char & "(* :unsigned-char)";
+%typemap(ffitype) short *, const short *, short &,
+		  const short &				"(* :short)";
+%typemap(ffitype) unsigned short *, const unsigned short *,
+		  unsigned short &, const unsigned short & "(* :unsigned-short)";
+%typemap(ffitype) int *, const int *, int &, const int & "(* :int)";
+%typemap(ffitype) unsigned int *, const unsigned int *,
+		  unsigned int &, const unsigned int &	"(* :unsigned-int)";
+%typemap(ffitype) void * "(* :void)";
+%typemap(ffitype) void ":void";
+%typemap(ffitype) enum SWIGTYPE ":int";
+%typemap(ffitype) SWIGTYPE & "(* :void)";
+
+/* const typemaps
+idea: marshall all primitive c types to their respective lisp types
+to maintain const corretness. For pointers/references, all bets
+are off if you try to modify them.
+
+idea: add a constant-p slot to the base foreign-pointer class. For
+constant pointer/references check this value when setting (around method?)
+and error if a setf operation is performed on the address of this object.
+
+*/
+
+/* 
+%exception %{
+   try {
+      $action
+   } catch (...) {
+      return $null;
+   }
+%}
+
+*/
+
+// %typemap(throws) SWIGTYPE {
+//   (void)$1;
+//   SWIG_fail;
+// }
+
+%typemap(ctype) bool, const bool		"int";
+%typemap(ctype) char, unsigned char, signed char,
+                short, signed short, unsigned short,
+                int, signed int, unsigned int,
+                long, signed long, unsigned long,
+                float, double, long double, char *, void *, void,
+                enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[],
+                SWIGTYPE[ANY], SWIGTYPE &, const SWIGTYPE  "$1_ltype";
+%typemap(ctype) SWIGTYPE                   "$&1_type";
+
+%typemap(in) bool                          "$1 = (bool)$input;";
+%typemap(in) char, unsigned char, signed char,
+             short, signed short, unsigned short,
+             int, signed int, unsigned int,
+             long, signed long, unsigned long,
+             float, double, long double, char *, void *, void,
+             enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[],
+             SWIGTYPE[ANY], SWIGTYPE &     "$1 = $input;";
+%typemap(in) SWIGTYPE                      "$1 = *$input;";
+
+/* We don't need to do any actual C-side typechecking, but need to
+   use the precedence values to choose which overloaded function
+   interfaces to generate when conflicts arise. */
+
+/* predefined precedence values
+
+Symbolic Name                   Precedence Value
+------------------------------  ------------------
+SWIG_TYPECHECK_POINTER           0  
+SWIG_TYPECHECK_VOIDPTR           10 
+SWIG_TYPECHECK_BOOL              15 
+SWIG_TYPECHECK_UINT8             20 
+SWIG_TYPECHECK_INT8              25 
+SWIG_TYPECHECK_UINT16            30 
+SWIG_TYPECHECK_INT16             35 
+SWIG_TYPECHECK_UINT32            40 
+SWIG_TYPECHECK_INT32             45 
+SWIG_TYPECHECK_UINT64            50 
+SWIG_TYPECHECK_INT64             55 
+SWIG_TYPECHECK_UINT128           60 
+SWIG_TYPECHECK_INT128            65 
+SWIG_TYPECHECK_INTEGER           70 
+SWIG_TYPECHECK_FLOAT             80 
+SWIG_TYPECHECK_DOUBLE            90 
+SWIG_TYPECHECK_COMPLEX           100 
+SWIG_TYPECHECK_UNICHAR           110 
+SWIG_TYPECHECK_UNISTRING         120 
+SWIG_TYPECHECK_CHAR              130 
+SWIG_TYPECHECK_STRING            140 
+SWIG_TYPECHECK_BOOL_ARRAY        1015 
+SWIG_TYPECHECK_INT8_ARRAY        1025 
+SWIG_TYPECHECK_INT16_ARRAY       1035 
+SWIG_TYPECHECK_INT32_ARRAY       1045 
+SWIG_TYPECHECK_INT64_ARRAY       1055 
+SWIG_TYPECHECK_INT128_ARRAY      1065 
+SWIG_TYPECHECK_FLOAT_ARRAY       1080 
+SWIG_TYPECHECK_DOUBLE_ARRAY      1090 
+SWIG_TYPECHECK_CHAR_ARRAY        1130 
+SWIG_TYPECHECK_STRING_ARRAY      1140
+*/
+
+%typecheck(SWIG_TYPECHECK_BOOL) bool { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_CHAR) char { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_FLOAT) float { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_DOUBLE) double { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_STRING) char * { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_INTEGER)
+                    unsigned char, signed char,
+                    short, signed short, unsigned short,
+                    int, signed int, unsigned int,
+                    long, signed long, unsigned long,
+                    enum SWIGTYPE { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &,
+				   SWIGTYPE[], SWIGTYPE[ANY],
+				   SWIGTYPE { $1 = 1; };
+
+/* This maps C/C++ types to Lisp classes for overload dispatch */
+
+%typemap(lispclass) bool "t";
+%typemap(lispclass) char "cl:character";
+%typemap(lispclass) unsigned char, signed char,
+                    short, signed short, unsigned short,
+                    int, signed int, unsigned int,
+                    long, signed long, unsigned long,
+                    enum SWIGTYPE       "cl:integer";
+%typemap(lispclass) float "cl:single-float";
+%typemap(lispclass) double "cl:double-float";
+%typemap(lispclass) char * "cl:string";
+
+%typemap(out) void                          "";
+%typemap(out) bool                          "$result = (int)$1;";
+%typemap(out) char, unsigned char, signed char,
+              short, signed short, unsigned short,
+              int, signed int, unsigned int,
+              long, signed long, unsigned long,
+              float, double, long double, char *, void *,
+              enum SWIGTYPE, SWIGTYPE *,
+              SWIGTYPE[ANY], SWIGTYPE &    "$result = $1;";
+#ifdef __cplusplus
+%typemap(out) SWIGTYPE                     "$result = new $1_ltype($1);";
+#else
+%typemap(out) SWIGTYPE {
+  $result = ($&1_ltype) malloc(sizeof($1_type));
+  memmove($result, &$1, sizeof($1_type));
+}
+#endif
+
+//////////////////////////////////////////////////////////////
+// UCS-2 string conversion
+
+// should this be SWIG_TYPECHECK_CHAR?
+%typecheck(SWIG_TYPECHECK_UNICHAR) wchar_t { $1 = 1; };
+
+%typemap(in)        wchar_t "$1 = $input;";
+%typemap(lin,numinputs=1)       wchar_t "(cl::let (($out (cl:char-code $in)))\n  $body)";
+%typemap(lin,numinputs=1)       wchar_t * "(excl:with-native-string ($out $in
+:external-format #+little-endian :fat-le #-little-endian :fat)\n
+$body)"
+
+%typemap(out)       wchar_t "$result = $1;";
+%typemap(lout)      wchar_t "(cl::setq ACL_ffresult (cl::code-char $body))";
+%typemap(lout)      wchar_t * "(cl::setq ACL_ffresult (excl:native-to-string $body
+:external-format #+little-endian :fat-le #-little-endian :fat))";
+
+%typemap(ffitype)   wchar_t ":unsigned-short";
+%typemap(lisptype)  wchar_t "";
+%typemap(ctype)     wchar_t "wchar_t";
+%typemap(lispclass) wchar_t "cl:character";
+%typemap(lispclass) wchar_t * "cl:string";
+//////////////////////////////////////////////////////////////
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* name conversion for overloaded operators. */
+#ifdef __cplusplus
+%rename(__add__)	     *::operator+;
+%rename(__pos__)	     *::operator+();
+%rename(__pos__)	     *::operator+() const;
+
+%rename(__sub__)	     *::operator-;
+%rename(__neg__)	     *::operator-() const;
+%rename(__neg__)	     *::operator-();
+
+%rename(__mul__)	     *::operator*;
+%rename(__deref__)	     *::operator*();
+%rename(__deref__)	     *::operator*() const;
+
+%rename(__div__)	     *::operator/;
+%rename(__mod__)	     *::operator%;
+%rename(__logxor__)	     *::operator^;
+%rename(__logand__)	     *::operator&;
+%rename(__logior__)	     *::operator|;
+%rename(__lognot__)	     *::operator~();
+%rename(__lognot__)	     *::operator~() const;
+
+%rename(__not__)	     *::operator!();
+%rename(__not__)	     *::operator!() const;
+
+%rename(__assign__)	     *::operator=;
+
+%rename(__add_assign__)      *::operator+=;
+%rename(__sub_assign__)	     *::operator-=;
+%rename(__mul_assign__)	     *::operator*=;
+%rename(__div_assign__)	     *::operator/=;
+%rename(__mod_assign__)	     *::operator%=;
+%rename(__logxor_assign__)   *::operator^=;
+%rename(__logand_assign__)   *::operator&=;
+%rename(__logior_assign__)   *::operator|=;
+
+%rename(__lshift__)	     *::operator<<;
+%rename(__lshift_assign__)   *::operator<<=;
+%rename(__rshift__)	     *::operator>>;
+%rename(__rshift_assign__)   *::operator>>=;
+
+%rename(__eq__)		     *::operator==;
+%rename(__ne__)		     *::operator!=;
+%rename(__lt__)		     *::operator<;
+%rename(__gt__)		     *::operator>;
+%rename(__lte__)	     *::operator<=;
+%rename(__gte__)	     *::operator>=;
+
+%rename(__and__)	     *::operator&&;
+%rename(__or__)		     *::operator||;
+
+%rename(__preincr__)	     *::operator++();
+%rename(__postincr__)	     *::operator++(int);
+%rename(__predecr__)	     *::operator--();
+%rename(__postdecr__)	     *::operator--(int);
+
+%rename(__comma__)	     *::operator,();
+%rename(__comma__)	     *::operator,() const;
+
+%rename(__member_ref__)      *::operator->;
+%rename(__member_func_ref__) *::operator->*;
+
+%rename(__funcall__)	     *::operator();
+%rename(__aref__)	     *::operator[];
+
+%rename(__bool__)	     *::operator bool();
+%rename(__bool__)	     *::operator bool() const;
+#endif
+
+%insert("lisphead") %{
+(eval-when (:compile-toplevel :load-toplevel :execute)
+
+  ;; avoid compiling ef-templates at runtime
+  (excl:find-external-format :fat)
+  (excl:find-external-format :fat-le)
+
+;;; You can define your own identifier converter if you want.
+;;; Use the -identifier-converter command line argument to
+;;; specify its name.
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+   (cl::defparameter *swig-export-list* nil))
+
+(cl::defconstant *void* :..void..)
+
+;; parsers to aid in finding SWIG definitions in files.
+(cl::defun scm-p1 (form)
+  (let* ((info (cl::second form))
+	 (id (car info))
+	 (id-args (if (eq (cl::car form) 'swig-dispatcher)
+		      (cl::cdr info)
+		      (cl::cddr info))))
+    (cl::apply *swig-identifier-converter* id 
+	   (cl::progn (cl::when (cl::eq (cl::car form) 'swig-dispatcher)
+		    (cl::remf id-args :arities))
+		  id-args))))
+
+(cl::defmacro defswig1 (name (&rest args) &body body)
+  `(cl::progn (cl::defmacro ,name ,args
+	    ,@body)
+	  (excl::define-simple-parser ,name scm-p1)) )
+
+(cl::defmacro defswig2 (name (&rest args) &body body)
+  `(cl::progn (cl::defmacro ,name ,args
+	    ,@body)
+	  (excl::define-simple-parser ,name second)))
+
+(defun read-symbol-from-string (string)
+  (cl::multiple-value-bind (result position)
+      (cl::read-from-string string nil "eof" :preserve-whitespace t)
+    (cl::if (cl::and (cl::symbolp result)
+    	             (cl::eql position (cl::length string)))
+        result
+	(cl::multiple-value-bind (sym)
+	    (cl::intern string)
+	  sym))))
+
+(cl::defun full-name (id type arity class)
+  ; We need some kind of a hack here to handle template classes
+  ; and other synonym types right. We need the original name.
+  (let*( (sym (read-symbol-from-string 
+                (if (eq *swig-identifier-converter* 'identifier-convert-lispify)
+                  (string-lispify id)
+                  id)))
+         (sym-class (find-class sym nil))
+         (id (cond ( (not sym-class)
+                     id )
+                   ( (and sym-class
+                          (not (eq (class-name sym-class)
+                                sym)))
+                     (class-name sym-class) )
+                   ( t
+                     id ))) )
+    (cl::case type
+      (:getter (cl::format nil "~@[~A_~]~A" class id))
+      (:constructor (cl::format nil "new_~A~@[~A~]" id arity))
+      (:destructor (cl::format nil "delete_~A" id))
+      (:type (cl::format nil "ff_~A" id))
+      (:slot id)
+      (:ff-operator (cl::format nil "ffi_~A" id))
+      (otherwise (cl::format nil "~@[~A_~]~A~@[~A~]"
+                         class id arity)))))
+  
+(cl::defun identifier-convert-null (id &key type class arity)
+  (cl::if (cl::eq type :setter)
+      `(cl::setf ,(identifier-convert-null
+               id :type :getter :class class :arity arity))
+      (read-symbol-from-string (full-name id type arity class))))
+
+(cl::defun string-lispify (str)
+  (cl::let ( (cname (excl::replace-regexp str "_" "-"))
+             (lastcase :other)
+             newcase char res ) 
+    (cl::dotimes (n (cl::length cname))
+      (cl::setf char (cl::schar cname n))
+      (excl::if* (cl::alpha-char-p char)
+         then
+              (cl::setf newcase (cl::if (cl::upper-case-p char) :upper :lower))
+              (cl::when (cl::and (cl::eq lastcase :lower)
+                                 (cl::eq newcase :upper))
+                ;; case change... add a dash
+                (cl::push #\- res)
+                (cl::setf newcase :other))
+              (cl::push (cl::char-downcase char) res)
+              (cl::setf lastcase newcase)
+         else
+              (cl::push char res)
+              (cl::setf lastcase :other)))
+    (cl::coerce (cl::nreverse res) 'string)))
+  
+(cl::defun identifier-convert-lispify (cname &key type class arity)
+  (cl::assert (cl::stringp cname))
+  (cl::when (cl::eq type :setter)
+    (cl::return-from identifier-convert-lispify
+      `(cl::setf ,(identifier-convert-lispify
+               cname :type :getter :class class :arity arity))))
+  (cl::setq cname (full-name cname type arity class))
+  (cl::if (cl::eq type :constant)
+      (cl::setf cname (cl::format nil "*~A*" cname)))
+  (read-symbol-from-string (string-lispify cname)))
+
+(cl::defun id-convert-and-export (name &rest kwargs)
+  (cl::multiple-value-bind (symbol package)
+      (cl::apply *swig-identifier-converter* name kwargs)
+    (cl::let ((args (cl::list (cl::if (cl::consp symbol)
+    	     	    	         (cl::cadr symbol) symbol)
+                      (cl::or package cl::*package*))))
+      (cl::apply #'cl::export args)
+      (cl::pushnew args *swig-export-list*))
+    symbol))
+
+(cl::defmacro swig-insert-id (name namespace &key (type :type) class)
+  `(cl::let ((cl::*package* (cl::find-package ,(package-name-for-namespace namespace))))
+    (id-convert-and-export ,name :type ,type :class ,class)))
+
+(defswig2 swig-defconstant (string value)
+  (cl::let ((symbol (id-convert-and-export string :type :constant)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (cl::defconstant ,symbol ,value))))
+
+(cl::defun maybe-reorder-args (funcname arglist)
+  ;; in the foreign setter function the new value will be the last argument
+  ;; in Lisp it needs to be the first
+  (cl::if (cl::consp funcname)
+      (cl::append (cl::last arglist) (cl::butlast arglist))
+      arglist))
+
+(cl::defun maybe-return-value (funcname arglist)
+  ;; setf functions should return the new value
+  (cl::when (cl::consp funcname)
+    `(,(cl::if (cl::consp (cl::car arglist))
+           (cl::caar arglist)
+           (cl::car arglist)))))
+
+(cl::defun swig-anyvarargs-p (arglist)
+  (cl::member :SWIG__varargs_ arglist))
+
+(defswig1 swig-defun ((name &optional (mangled-name name)
+                            &key (type :operator) class arity)
+                      arglist kwargs
+		      &body body)
+  (cl::let* ((symbol (id-convert-and-export name :type type
+                          :arity arity :class class))
+             (mangle (excl::if* (cl::string-equal name mangled-name)
+                      then (id-convert-and-export 
+				    (cl::cond
+					  ((cl::eq type :setter) (cl::format nil "~A-set" name))
+					  ((cl::eq type :getter) (cl::format nil "~A-get" name))
+					  (t name))
+				    :type :ff-operator :arity arity :class class)
+                      else (cl::intern mangled-name)))
+         (defun-args (maybe-reorder-args
+                      symbol
+		      (cl::mapcar #'cl::car (cl::and (cl::not (cl::equal arglist '(:void)))
+					 (cl::loop as i in arglist
+					       when (cl::eq (cl::car i) :p+)
+					       collect (cl::cdr i))))))
+	 (ffargs (cl::if (cl::equal arglist '(:void))
+	 	      arglist
+		    (cl::mapcar #'cl::cdr arglist)))
+	 )
+    (cl::when (swig-anyvarargs-p ffargs)
+      (cl::setq ffargs '()))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (excl::compiler-let ((*record-xref-info* nil))
+         (ff:def-foreign-call (,mangle ,mangled-name) ,ffargs ,@kwargs))
+       (cl::macrolet ((swig-ff-call (&rest args)
+                      (cl::cons ',mangle args)))
+         (cl::defun ,symbol ,defun-args
+           ,@body
+           ,@(maybe-return-value symbol defun-args))))))
+
+(defswig1 swig-defmethod ((name &optional (mangled-name name)
+	  	                &key (type :operator) class arity)
+                          ffargs kwargs
+                          &body body)
+  (cl::let* ((symbol (id-convert-and-export name :type type
+                          :arity arity :class class))
+         (mangle (cl::intern mangled-name))
+         (defmethod-args (maybe-reorder-args
+                          symbol
+                          (cl::unless (cl::equal ffargs '(:void))
+                            (cl::loop for (lisparg name dispatch) in ffargs
+			    	  when (eq lisparg :p+)
+                                  collect `(,name ,dispatch)))))
+         (ffargs (cl::if (cl::equal ffargs '(:void))
+                     ffargs
+                     (cl::loop for (nil name nil . ffi) in ffargs
+                           collect `(,name ,@ffi)))))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (excl::compiler-let ((*record-xref-info* nil))
+         (ff:def-foreign-call (,mangle ,mangled-name) ,ffargs ,@kwargs))
+       (cl::macrolet ((swig-ff-call (&rest args)
+                      (cl::cons ',mangle args)))
+         (cl::defmethod ,symbol ,defmethod-args
+           ,@body
+           ,@(maybe-return-value symbol defmethod-args))))))
+
+(defswig1 swig-dispatcher ((name &key (type :operator) class arities))
+  (cl::let ((symbol (id-convert-and-export name
+                         :type type :class class)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (cl::defun ,symbol (&rest args)
+         (cl::case (cl::length args)
+           ,@(cl::loop for arity in arities
+                   for symbol-n = (id-convert-and-export name
+                                           :type type :class class :arity arity)
+                   collect `(,arity (cl::apply #',symbol-n args)))
+	   (t (cl::error "No applicable wrapper-methods for foreign call ~a with args ~a of classes ~a" ',symbol args (cl::mapcar #'(cl::lambda (x) (cl::class-name (cl::class-of x))) args)))
+	   )))))
+
+(defswig2 swig-def-foreign-stub (name)
+  (cl::let ((lsymbol (id-convert-and-export name :type :class))
+	    (symbol (id-convert-and-export name :type :type)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+	(ff:def-foreign-type ,symbol (:class ))
+	(cl::defclass ,lsymbol (ff:foreign-pointer) ()))))
+
+(defswig2 swig-def-foreign-class (name supers &rest rest)
+  (cl::let ((lsymbol (id-convert-and-export name :type :class))
+	    (symbol (id-convert-and-export name :type :type)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (ff:def-foreign-type ,symbol ,@rest)
+       (cl::defclass ,lsymbol ,supers
+	 ((foreign-type :initform ',symbol :initarg :foreign-type
+			:accessor foreign-pointer-type))))))
+
+(defswig2 swig-def-foreign-type (name &rest rest)
+  (cl::let ((symbol (id-convert-and-export name :type :type)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+       (ff:def-foreign-type ,symbol ,@rest))))
+
+(defswig2 swig-def-synonym-type (synonym of ff-synonym)
+  `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+     (cl::setf (cl::find-class ',synonym) (cl::find-class ',of))
+     (ff:def-foreign-type ,ff-synonym (:struct ))))
+
+(cl::defun package-name-for-namespace (namespace)
+  (excl::list-to-delimited-string
+   (cl::cons *swig-module-name*
+         (cl::mapcar #'(cl::lambda (name)
+                     (cl::string
+                      (cl::funcall *swig-identifier-converter*
+                               name
+                               :type :namespace)))
+                 namespace))
+   "."))
+
+(cl::defmacro swig-defpackage (namespace)
+  (cl::let* ((parent-namespaces (cl::maplist #'cl::reverse (cl::cdr (cl::reverse namespace))))
+             (parent-strings (cl::mapcar #'package-name-for-namespace
+                                 parent-namespaces))
+             (string (package-name-for-namespace namespace)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+      (cl::defpackage ,string
+        (:use :swig :ff #+ignore '(:common-lisp :ff :excl)
+              ,@parent-strings ,*swig-module-name*)
+	(:import-from :cl :* :nil :t)))))
+
+(cl::defmacro swig-in-package (namespace)
+  `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+    (cl::in-package ,(package-name-for-namespace namespace))))
+
+(defswig2 swig-defvar (name mangled-name &key type (ftype :unsigned-natural))
+  (cl::let ((symbol (id-convert-and-export name :type type)))
+    `(cl::eval-when (:compile-toplevel :load-toplevel :execute)
+      (ff:def-foreign-variable (,symbol ,mangled-name) :type ,ftype))))
+
+) ;; eval-when
+
+(cl::eval-when (:compile-toplevel :execute)
+  (cl::flet ((starts-with-p (str prefix)
+              (cl::and (cl::>= (cl::length str) (cl::length prefix))
+                (cl::string= str prefix :end1 (cl::length prefix)))))
+    (cl::export (cl::loop for sym being each present-symbol of cl::*package*
+                  when (cl::or (starts-with-p (cl::symbol-name sym) (cl::symbol-name :swig-))
+                           (starts-with-p (cl::symbol-name sym) (cl::symbol-name :identifier-convert-)))
+                  collect sym))))
+
+%}
+
+typedef void *__SWIGACL_FwdReference;
+
+%{
+
+#ifdef __cplusplus
+#  define EXTERN   extern "C"
+#else
+#  define EXTERN   extern
+#endif
+
+#define EXPORT   EXTERN SWIGEXPORT
+
+typedef void *__SWIGACL_FwdReference;
+
+#include <string.h>
+#include <stdlib.h>
+%}
diff --git a/share/swig/2.0.11/allegrocl/inout_typemaps.i b/share/swig/2.0.11/allegrocl/inout_typemaps.i
new file mode 100644
index 0000000..d8d61fe
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/inout_typemaps.i
@@ -0,0 +1,111 @@
+/* inout_typemaps.i
+
+   Support for INPUT, OUTPUT, and INOUT typemaps. OUTPUT variables are returned
+   as multiple values.
+
+*/
+
+
+/* Note that this macro automatically adds a pointer to the type passed in.
+   As a result, INOUT typemaps for char are for 'char *'. The definition
+   of typemaps for 'char' takes advantage of this, believing that it's more
+   likely to see an INOUT argument for strings, than a single char. */
+%define INOUT_TYPEMAP(type_, OUTresult_, INbind_)
+// OUTPUT map.
+%typemap(lin,numinputs=0) type_ *OUTPUT, type_ &OUTPUT
+%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c)))
+     $body
+     OUTresult_
+     (ff:free-fobject $out)) %}
+
+// INPUT map.
+%typemap(in) type_ *INPUT, type_ &INPUT
+%{ $1 = &$input; %}
+
+%typemap(ctype) type_ *INPUT, type_ &INPUT "$*1_ltype";
+
+
+// INOUT map.
+// careful here. the input string is converted to a C string
+// with length equal to the input string. This should be large
+// enough to contain whatever OUTPUT value will be stored in it.
+%typemap(lin,numinputs=1) type_ *INOUT, type_ &INOUT
+%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c)))
+     INbind_
+     $body
+     OUTresult_
+     (ff:free-fobject $out)) %}
+
+%enddef
+
+// $in, $out, $lclass,
+// $in_fftype, $*in_fftype
+
+INOUT_TYPEMAP(int,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(short,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(long,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(unsigned int,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(unsigned short,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(unsigned long,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+// char * mapping for passing strings. didn't quite work
+// INOUT_TYPEMAP(char,
+//              (cl::push (excl:native-to-string $out) ACL_result),
+//	      (cl::setf (ff:fslot-value-typed (cl::quote $in_fftype) :c $out)
+//		    (excl:string-to-native $in)))
+INOUT_TYPEMAP(float,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(double,
+	      (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
+INOUT_TYPEMAP(bool,
+	      (cl::push (not (zerop (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out)))
+		    ACL_result),
+	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) (if $in 1 0)));
+
+%typemap(lisptype) bool *INPUT, bool &INPUT "boolean";
+
+// long long support not yet complete
+// INOUT_TYPEMAP(long long);
+// INOUT_TYPEMAP(unsigned long long);
+
+// char *OUTPUT map.
+// for this to work, swig needs to know how large an array to allocate.
+// you can fake this by 
+// %typemap(ffitype) char *myarg	"(:array :char 30)";
+// %apply char *OUTPUT { char *myarg };
+%typemap(lin,numinputs=0) char *OUTPUT, char &OUTPUT
+%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c)))
+     $body
+     (cl::push (excl:native-to-string $out) ACL_result)
+     (ff:free-fobject $out)) %}
+
+// char *INPUT map.
+%typemap(in) char *INPUT, char &INPUT
+%{ $1 = &$input; %}
+%typemap(ctype) char *INPUT, char &INPUT "$*1_ltype";
+
+// char *INOUT map.
+%typemap(lin,numinputs=1) char *INOUT, char &INOUT
+%{(cl::let (($out (excl:string-to-native $in)))
+     $body
+     (cl::push (excl:native-to-string $out) ACL_result)
+     (ff:free-fobject $out)) %}
+
+// uncomment this if you want INOUT mappings for chars instead of strings.
+// INOUT_TYPEMAP(char,
+// 	      (cl::push (code-char (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out))
+//		    ACL_result),
+//	      (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in));
diff --git a/share/swig/2.0.11/allegrocl/longlongs.i b/share/swig/2.0.11/allegrocl/longlongs.i
new file mode 100644
index 0000000..a15adcd
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/longlongs.i
@@ -0,0 +1,49 @@
+/* -----------------------------------------------------------------------------
+ * longlongs.i
+ *
+ * Typemap addition for support of 'long long' type and 'unsigned long long 
+ * Makes use of swig-def-foreign-class, so this header should be loaded
+ * after allegrocl.swg and after any custom user identifier-conversion
+ * functions have been defined.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef Acl64Bit
+%typemap(ctype) long long, unsigned long long "$1_ltype";
+%typemap(out) long long, unsigned long long "$result = $1;";
+
+%typemap(ffitype) long long ":nat";
+%typemap(ffitype) unsigned long long ":unsigned-nat";
+
+%typemap(lout) long long, unsigned long long "  #+64bit (cl::setq ACL_ffresult $body)";
+
+#else
+%typemap(out) long long, unsigned long long "$result = &$1;";
+%typemap(ffitype) long long "(:struct (l1 :long) (l2 :long))";
+
+%typemap(ffitype) unsigned long long "(:struct (l1 :unsigned-long) (l2 :unsigned-long))";
+
+%typemap(lout) long long 
+"  (cl::setq ACL_ffresult (make-instance '#.(swig-insert-id \"longlong\" () :type :class)
+                  :foreign-address $body))";
+
+%typemap(lout) unsigned long long
+"  (cl:setq ACL_ffresult (make-instance '#.(swig-insert-id \"ulonglong\" () :type :class)
+                  :foreign-address $body))";
+
+#endif
+
+%typemap(in) long long, unsigned long long "$1 = $input;";
+
+
+%insert("lisphead") %{
+
+#-64bit
+(swig-def-foreign-class "longlong"
+ (ff:foreign-pointer)
+ (:struct (l1 :long) (l2 :long)))
+
+#-64bit
+(swig-def-foreign-class "ulonglong"
+ (ff:foreign-pointer)
+ (:struct (l1 :unsigned-long) (l2 :unsigned-long)))
+%}
diff --git a/share/swig/2.0.11/allegrocl/std_list.i b/share/swig/2.0.11/allegrocl/std_list.i
new file mode 100644
index 0000000..4e26089
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/std_list.i
@@ -0,0 +1,230 @@
+/* -----------------------------------------------------------------------------
+ * std_list.i
+ *
+ * SWIG typemaps for std::list types
+ * 
+ * To use, add:
+ * 
+ * %include "std_list.i"
+ *
+ * to your interface file. You will also need to include a template directive
+ * for each instance of the list container you want to use in your application.
+ * e.g.
+ * 
+ * %template (intlist) std::list<int>;
+ * %template (floatlist) std::list<float>;
+ * ----------------------------------------------------------------------------- */
+
+%module std_list
+%warnfilter(468) std::list;
+
+%{
+#include <list>
+#include <stdexcept>
+%}
+
+
+namespace std{
+    template<class T> class list
+    {
+    public:
+	     
+	typedef T &reference;
+	typedef const T& const_reference;
+	typedef T &iterator;
+	typedef const T& const_iterator; 
+	    
+	list();
+	list(unsigned int size, const T& value = T());
+	list(const list<T> &);
+
+	~list();
+	void assign(unsigned int n, const T& value);
+	void swap(list<T> &x);
+
+	const_reference front();
+	const_reference back();
+	const_iterator begin();
+	const_iterator end();
+	     
+	void resize(unsigned int n, T c = T());
+	bool empty() const;
+
+	void push_front(const T& INPUT);
+	void push_back(const T& INPUT);
+
+
+	void pop_front();
+	void pop_back();
+	void clear();
+	unsigned int size() const;
+	unsigned int max_size() const;
+	void resize(unsigned int n, const T& INPUT);
+		
+	void remove(const T& INPUT);
+	void unique();
+	void reverse();
+	void sort();
+
+	%extend 
+	    {
+	        %typemap(lout) T &__getitem__ "(cl::setq ACL_ffresult (ff:fslot-value-typed '$*out_fftype :c $body))";
+		%typemap(lout) T *__getitem__ "(cl::setq ACL_ffresult (make-instance '$lclass :foreign-address $body))";
+
+		const_reference __getitem__(int i) throw (std::out_of_range) 
+		    {
+			std::list<T>::iterator first = self->begin(); 
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (i>=0 && i<size)
+			{
+			    for (int k=0;k<i;k++)
+			    {
+				first++;
+			    }
+			    return *first;
+			}
+			else throw std::out_of_range("list index out of range");
+		    }
+		void __setitem__(int i, const T& INPUT) throw (std::out_of_range)
+		    {
+			std::list<T>::iterator first = self->begin(); 
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (i>=0 && i<size)
+			{
+			    for (int k=0;k<i;k++)
+			    {
+				first++;
+			    }
+			    *first = INPUT;
+			}
+			else throw std::out_of_range("list index out of range");
+		    }
+		void __delitem__(int i) throw (std::out_of_range)
+		    {
+			std::list<T>::iterator first = self->begin(); 
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (i>=0 && i<size)
+			{
+			    for (int k=0;k<i;k++)
+			    {
+				first++;
+			    }
+			    self->erase(first);
+			}
+			else throw std::out_of_range("list index out of range");
+		    }	     
+		std::list<T> __getslice__(int i,int j) 
+		    {
+			std::list<T>::iterator first = self->begin();
+			std::list<T>::iterator end = self->end();
+
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (j<0) j += size;
+			if (i<0) i = 0;
+			if (j>size) j = size;
+			if (i>=j) i=j;
+			if (i>=0 && i<size && j>=0)
+			{
+			    for (int k=0;k<i;k++)
+			    {
+				first++;
+			    }
+			    for (int m=0;m<j;m++)
+			    {
+				end++;
+			    }
+			    std::list<T> tmp(j-i);
+			    if (j>i) std::copy(first,end,tmp.begin());
+			    return tmp;
+			}
+			else throw std::out_of_range("list index out of range");
+		    }
+		void __delslice__(int i,int j) 
+		    {
+			std::list<T>::iterator first = self->begin();
+			std::list<T>::iterator end = self->end();
+
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (j<0) j += size;
+			if (i<0) i = 0;
+			if (j>size) j = size;
+	
+			for (int k=0;k<i;k++)
+			{
+			    first++;
+			}
+			for (int m=0;m<=j;m++)
+			{
+			    end++;
+			}		   
+			self->erase(first,end);		
+		    }
+		void __setslice__(int i,int j, const std::list<T>& v) 
+		    {
+			std::list<T>::iterator first = self->begin();
+			std::list<T>::iterator end = self->end();
+
+			int size = int(self->size());
+			if (i<0) i += size;
+			if (j<0) j += size;
+			if (i<0) i = 0;
+			if (j>size) j = size;
+		
+			for (int k=0;k<i;k++)
+			{
+			    first++;
+			}
+			for (int m=0;m<=j;m++)
+			{
+			    end++;
+			}
+			if (int(v.size()) == j-i) 
+			{
+			    std::copy(v.begin(),v.end(),first);
+			}
+			else {
+			    self->erase(first,end);
+			    if (i+1 <= int(self->size())) 
+			    {
+				first = self->begin();
+				for (int k=0;k<i;k++)
+				{
+				    first++;
+				}
+				self->insert(first,v.begin(),v.end());
+			    }
+			    else self->insert(self->end(),v.begin(),v.end());
+			}
+			   	
+		    }
+		unsigned int __len__() 
+		    {
+			return self->size();
+		    }	
+		bool __nonzero__()
+		    {
+			return !(self->empty());
+		    }
+		void append(const T& INPUT)
+		    {
+			self->push_back(INPUT);
+		    }
+		void pop()
+		    {
+			self->pop_back();
+		    }
+	      
+	    };   
+    };
+}
+
+
+
+
+
+
diff --git a/share/swig/2.0.11/allegrocl/std_string.i b/share/swig/2.0.11/allegrocl/std_string.i
new file mode 100644
index 0000000..cbcd250
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/std_string.i
@@ -0,0 +1,209 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * SWIG typemaps for std::string
+ * ----------------------------------------------------------------------------- */
+
+// ------------------------------------------------------------------------
+// std::string is typemapped by value
+// This can prevent exporting methods which return a string
+// in order for the user to modify it.
+// However, I think I'll wait until someone asks for it...
+// ------------------------------------------------------------------------
+
+// %include <exception.i>
+%warnfilter(404) std::string;
+%warnfilter(404) std::wstring;
+
+%{
+#include <string>
+%}
+
+// %include <std_vector.i>
+
+// %naturalvar std::string;
+// %naturalvar std::wstring;
+
+namespace std {
+    typedef unsigned long size_t;
+    typedef signed long ptrdiff_t;
+
+    template <class charT> class basic_string {
+    public:
+	typedef charT *pointer;
+	typedef charT &reference;
+	typedef const charT &const_reference;
+	typedef size_t size_type;
+	typedef ptrdiff_t difference_type;
+	basic_string();
+	basic_string( charT *str );
+	size_type size();
+	charT operator []( int pos ) const;
+	charT *c_str() const;
+	basic_string<charT> &operator = ( const basic_string &ws );
+	basic_string<charT> &operator = ( const charT *str );
+	basic_string<charT> &append( const basic_string<charT> &other );
+	basic_string<charT> &append( const charT *str );
+	void push_back( charT c );
+	void clear();
+	void reserve( size_type t );
+	void resize( size_type n, charT c = charT() );
+	int compare( const basic_string<charT> &other ) const;
+	int compare( const charT *str ) const;
+	basic_string<charT> &insert( size_type pos, 
+				     const basic_string<charT> &str );
+	size_type find( const basic_string<charT> &other, int pos = 0 ) const;
+	size_type find( charT c, int pos = 0 ) const;
+	%extend {
+	    bool operator == ( const basic_string<charT> &other ) const {
+		return self->compare( other ) == 0;
+	    }
+	    bool operator != ( const basic_string<charT> &other ) const {
+		return self->compare( other ) != 0;
+	    }
+	    bool operator < ( const basic_string<charT> &other ) const {
+		return self->compare( other ) == -1;
+	    }
+	    bool operator > ( const basic_string<charT> &other ) const {
+		return self->compare( other ) == 1;
+	    }
+	    bool operator <= ( const basic_string<charT> &other ) const {
+		return self->compare( other ) != 1;
+	    }
+	    bool operator >= ( const basic_string<charT> &other ) const {
+		return self->compare( other ) != -1;
+	    }
+
+	}
+    };
+
+    %template(string) basic_string<char>;
+    %template(wstring) basic_string<wchar_t>;
+
+    %apply char * { string };
+    %apply wchar_t * { wstring };
+
+    typedef basic_string<char> string;
+    typedef basic_string<wchar_t> wstring;
+
+    // automatically convert constant std::strings to cl:strings
+    %typemap(ctype) string "char *";
+    %typemap(in) string "$1.assign($input);";
+    %typemap(out) string "$result = (char *)(&$1)->c_str();";
+    %typemap(lisptype) string "cl:string";
+    %typemap(lout) string "(cl::setq ACL_ffresult $body)";
+
+    %typemap(ctype) const string *"char *";
+    %typemap(in) const string * "$1.assign($input);";
+    %typemap(out) const string * "$result = (char *)($1)->c_str();";
+    %typemap(lisptype) const string * "cl:string";
+    %typemap(lout) const string * "(cl::setq ACL_ffresult $body)";
+
+    %typemap(ctype) wstring "wchar_t *";
+    %typemap(in) wstring "$1.assign($input);";
+    %typemap(out) wstring "$result = (wchar_t *)(&$1)->c_str();";
+    %typemap(lisptype) wstring "cl:string";
+    %typemap(lout) wstring "(cl::setq ACL_ffresult (excl:native-to-string $body
+:external-format #+little-endian :fat-le #-little-endian :fat))";
+
+    %typemap(ctype) const wstring *"char *";
+    %typemap(in) const wstring * "$1.assign($input);";
+    %typemap(out) const wstring * "$result = (char *)($1)->c_str();";
+    %typemap(lisptype) const wstring * "cl:string";
+    %typemap(lout) const wstring * "(cl::setq ACL_ffresult $body)";
+
+    /* Overloading check */
+//     %typemap(in) string {
+//         if (caml_ptr_check($input))
+//             $1.assign((char *)caml_ptr_val($input,0),
+// 			 caml_string_len($input));
+//         else
+//             SWIG_exception(SWIG_TypeError, "string expected");
+//     }
+
+//     %typemap(in) const string & ($*1_ltype temp) {
+//         if (caml_ptr_check($input)) {
+//             temp.assign((char *)caml_ptr_val($input,0),
+// 			   caml_string_len($input));
+//             $1 = &temp;
+//         } else {
+//             SWIG_exception(SWIG_TypeError, "string expected");
+//         }
+//     }
+
+//     %typemap(in) string & ($*1_ltype temp) {
+//         if (caml_ptr_check($input)) {
+//             temp.assign((char *)caml_ptr_val($input,0),
+// 			   caml_string_len($input));
+//             $1 = &temp;
+//         } else {
+//             SWIG_exception(SWIG_TypeError, "string expected");
+//         }
+//     }
+
+//     %typemap(in) string * ($*1_ltype *temp) {
+//         if (caml_ptr_check($input)) {
+//             temp = new $*1_ltype((char *)caml_ptr_val($input,0),
+// 				   caml_string_len($input));
+//             $1 = temp;
+//         } else {
+//             SWIG_exception(SWIG_TypeError, "string expected");
+//         }
+//     }
+
+//     %typemap(free) string * ($*1_ltype *temp) {
+// 	delete temp;
+//     }
+
+//    %typemap(argout) string & {
+//	caml_list_append(swig_result,caml_val_string_len((*$1).c_str(),
+//							 (*$1).size()));
+//    }
+
+//    %typemap(directorout) string {
+//	$result.assign((char *)caml_ptr_val($input,0),
+//		       caml_string_len($input));
+//    }
+
+//    %typemap(out) string {
+//        $result = caml_val_string_len($1.c_str(),$1.size());
+//    }
+
+//    %typemap(out) string * {
+//	$result = caml_val_string_len((*$1).c_str(),(*$1).size());
+//    }
+}
+
+// #ifdef ENABLE_CHARPTR_ARRAY
+// char **c_charptr_array( const std::vector <string > &str_v );
+
+// %{
+//   SWIGEXT char **c_charptr_array( const std::vector <string > &str_v ) {
+//     char **out = new char *[str_v.size() + 1];
+//     out[str_v.size()] = 0;
+//     for( int i = 0; i < str_v.size(); i++ ) {
+//       out[i] = (char *)str_v[i].c_str();
+//     }
+//     return out;
+//   }
+// %}
+// #endif
+
+// #ifdef ENABLE_STRING_VECTOR
+// %template (StringVector) std::vector<string >;
+
+// %insert(ml) %{
+//   (* Some STL convenience items *)
+
+//   let string_array_to_vector sa = 
+//     let nv = _new_StringVector C_void in
+//       array_to_vector nv (fun x -> C_string x) sa ; nv
+	
+//   let c_string_array ar = 
+//     _c_charptr_array (string_array_to_vector ar)
+// %}
+
+// %insert(mli) %{
+//   val c_string_array: string array -> c_obj
+// %}
+// #endif
diff --git a/share/swig/2.0.11/allegrocl/typemaps.i b/share/swig/2.0.11/allegrocl/typemaps.i
new file mode 100644
index 0000000..293d1cd
--- /dev/null
+++ b/share/swig/2.0.11/allegrocl/typemaps.i
@@ -0,0 +1,4 @@
+/* Unused for Allegro CL module */
+
+%include "inout_typemaps.i"
+%include "longlongs.i"
diff --git a/share/swig/2.0.11/allkw.swg b/share/swig/2.0.11/allkw.swg
new file mode 100644
index 0000000..2e0dad6
--- /dev/null
+++ b/share/swig/2.0.11/allkw.swg
@@ -0,0 +1,32 @@
+#ifndef __Lib_allkw_swg__
+#define __Lib_allkw_swg__
+
+
+/*  
+  Include all the known keyword warnings.  Very useful for adding test
+  files to the test-suite, or check if your own library is ok for all
+  the swig supported languages.
+
+  Use as 
+
+    swig -Wallkw ...
+
+  If you add a new language, remember to create a separete languagekw.swg
+  file, and add it here.
+  
+*/
+
+%include <chicken/chickenkw.swg>
+%include <csharp/csharpkw.swg>
+%include <d/dkw.swg>
+%include <java/javakw.swg>
+%include <php/phpkw.swg>
+%include <pike/pikekw.swg>
+%include <python/pythonkw.swg>
+%include <ocaml/ocamlkw.swg>
+%include <ruby/rubykw.swg>
+%include <tcl/tclkw.swg>
+%include <perl5/perlkw.swg>
+
+
+#endif //__Lib_allkw_swg__
diff --git a/share/swig/2.0.11/attribute.i b/share/swig/2.0.11/attribute.i
new file mode 100644
index 0000000..d580dbf
--- /dev/null
+++ b/share/swig/2.0.11/attribute.i
@@ -0,0 +1,21 @@
+/* -----------------------------------------------------------------------------
+ * attribute.i
+ *
+ * SWIG library file for implementing attributes.
+ * ----------------------------------------------------------------------------- */
+
+/* we use a simple exception warning here */
+%{
+#include <stdio.h>
+%}
+#define %attribute_exception(code,msg) printf("%s\n",msg)
+
+#ifndef %arg
+#define %arg(x...) x
+#endif
+
+#ifndef %mangle
+#define %mangle(Type...)  #@Type
+#endif
+
+%include <typemaps/attribute.swg>
diff --git a/share/swig/2.0.11/carrays.i b/share/swig/2.0.11/carrays.i
new file mode 100644
index 0000000..f125105
--- /dev/null
+++ b/share/swig/2.0.11/carrays.i
@@ -0,0 +1,116 @@
+/* -----------------------------------------------------------------------------
+ * carrays.i
+ *
+ * SWIG library file containing macros that can be used to manipulate simple
+ * pointers as arrays.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %array_functions(TYPE,NAME)
+ *
+ * Generates functions for creating and accessing elements of a C array
+ * (as pointers).  Creates the following functions:
+ *
+ *        TYPE *new_NAME(int nelements)
+ *        void delete_NAME(TYPE *);
+ *        TYPE NAME_getitem(TYPE *, int index);
+ *        void NAME_setitem(TYPE *, int index, TYPE value);
+ * 
+ * ----------------------------------------------------------------------------- */
+
+%define %array_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME(int nelements) { %}
+#ifdef __cplusplus
+%{  return new TYPE[nelements]; %}
+#else
+%{  return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *ary) { %}
+#ifdef __cplusplus
+%{  delete [] ary; %}
+#else
+%{  free(ary); %}
+#endif
+%{}
+
+static TYPE NAME##_getitem(TYPE *ary, int index) {
+    return ary[index];
+}
+static void NAME##_setitem(TYPE *ary, int index, TYPE value) {
+    ary[index] = value;
+}
+%}
+
+TYPE *new_##NAME(int nelements);
+void delete_##NAME(TYPE *ary);
+TYPE NAME##_getitem(TYPE *ary, int index);
+void NAME##_setitem(TYPE *ary, int index, TYPE value);
+
+%enddef
+
+
+/* -----------------------------------------------------------------------------
+ * %array_class(TYPE,NAME)
+ *
+ * Generates a class wrapper around a C array.  The class has the following
+ * interface:
+ *
+ *          struct NAME {
+ *              NAME(int nelements);
+ *             ~NAME();
+ *              TYPE getitem(int index);
+ *              void setitem(int index, TYPE value);
+ *              TYPE * cast();
+ *              static NAME *frompointer(TYPE *t);
+  *         }
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %array_class(TYPE,NAME)
+%{
+typedef TYPE NAME;
+%}
+typedef struct {
+  /* Put language specific enhancements here */
+} NAME;
+
+%extend NAME {
+
+#ifdef __cplusplus
+NAME(int nelements) {
+  return new TYPE[nelements];
+}
+~NAME() {
+  delete [] self;
+}
+#else
+NAME(int nelements) {
+  return (TYPE *) calloc(nelements,sizeof(TYPE));
+}
+~NAME() {
+  free(self);
+}
+#endif
+
+TYPE getitem(int index) {
+  return self[index];
+}
+void setitem(int index, TYPE value) {
+  self[index] = value;
+}
+TYPE * cast() {
+  return self;
+}
+static NAME *frompointer(TYPE *t) {
+  return (NAME *) t;
+}
+
+};
+
+%types(NAME = TYPE);
+
+%enddef
+
diff --git a/share/swig/2.0.11/cdata.i b/share/swig/2.0.11/cdata.i
new file mode 100644
index 0000000..22a6d9d
--- /dev/null
+++ b/share/swig/2.0.11/cdata.i
@@ -0,0 +1,81 @@
+/* -----------------------------------------------------------------------------
+ * cdata.i
+ *
+ * SWIG library file containing macros for manipulating raw C data as strings.
+ * ----------------------------------------------------------------------------- */
+
+%{
+typedef struct SWIGCDATA {
+    char *data;
+    int   len;
+} SWIGCDATA;
+%}
+
+/* -----------------------------------------------------------------------------
+ * Typemaps for returning binary data
+ * ----------------------------------------------------------------------------- */
+
+#if SWIGGUILE
+%typemap(out) SWIGCDATA {
+   $result = scm_from_locale_stringn($1.data,$1.len);
+}
+%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
+#elif SWIGCHICKEN
+%typemap(out) SWIGCDATA {
+  C_word *string_space = C_alloc(C_SIZEOF_STRING($1.len));
+  $result = C_string(&string_space, $1.len, $1.data);
+}
+%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
+#elif SWIGPHP
+%typemap(out) SWIGCDATA {
+  ZVAL_STRINGL($result, $1.data, $1.len, 1);
+}
+%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
+#else
+%echo "cdata.i module not supported."
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * %cdata(TYPE [, NAME]) 
+ *
+ * Convert raw C data to a binary string.
+ * ----------------------------------------------------------------------------- */
+
+%define %cdata(TYPE,NAME...)
+
+%insert("header") {
+#if #NAME == ""
+static SWIGCDATA cdata_##TYPE(TYPE *ptr, int nelements) {
+#else
+static SWIGCDATA cdata_##NAME(TYPE *ptr, int nelements) {
+#endif
+   SWIGCDATA d;
+   d.data = (char *) ptr;
+#if #TYPE != "void"
+   d.len  = nelements*sizeof(TYPE);
+#else
+   d.len  = nelements;
+#endif
+   return d;
+}
+}
+
+%typemap(default) int nelements "$1 = 1;"
+
+#if #NAME == ""
+SWIGCDATA cdata_##TYPE(TYPE *ptr, int nelements);
+#else
+SWIGCDATA cdata_##NAME(TYPE *ptr, int nelements);
+#endif
+%enddef
+
+%typemap(default) int nelements;
+
+%rename(cdata) ::cdata_void(void *ptr, int nelements);
+
+%cdata(void);
+
+/* Memory move function. Due to multi-argument typemaps this appears to be wrapped as
+void memmove(void *data, const char *s); */
+void memmove(void *data, const void *indata, int inlen);
diff --git a/share/swig/2.0.11/cffi/cffi.swg b/share/swig/2.0.11/cffi/cffi.swg
new file mode 100644
index 0000000..427a8dc
--- /dev/null
+++ b/share/swig/2.0.11/cffi/cffi.swg
@@ -0,0 +1,291 @@
+/* Define a C preprocessor symbol that can be used in interface files
+   to distinguish between the SWIG language modules. */ 
+
+#define SWIG_CFFI
+
+/* Typespecs for basic types. */
+
+%typemap(cin) void ":void";
+
+%typemap(cin) char ":char";
+%typemap(cin) char * ":string";
+%typemap(cin) unsigned char ":unsigned-char";
+%typemap(cin) signed char ":char";
+
+%typemap(cin) short ":short";
+%typemap(cin) signed short ":short";
+%typemap(cin) unsigned short ":unsigned-short";
+
+%typemap(cin) int ":int";
+%typemap(cin) signed int ":int";
+%typemap(cin) unsigned int ":unsigned-int";
+
+%typemap(cin) long ":long";
+%typemap(cin) signed long ":long";
+%typemap(cin) unsigned long ":unsigned-long";
+
+%typemap(cin) long long ":long-long";
+%typemap(cin) signed long long ":long-long";
+%typemap(cin) unsigned long long ":unsigned-long-long";
+
+%typemap(cin) float ":float";
+%typemap(cin) double ":double";
+%typemap(cin) SWIGTYPE ":pointer";
+
+%typemap(cout) void ":void";
+
+%typemap(cout) char ":char";
+%typemap(cout) char * ":string";
+%typemap(cout) unsigned char ":unsigned-char";
+%typemap(cout) signed char ":char";
+
+%typemap(cout) short ":short";
+%typemap(cout) signed short ":short";
+%typemap(cout) unsigned short ":unsigned-short";
+
+%typemap(cout) int ":int";
+%typemap(cout) signed int ":int";
+%typemap(cout) unsigned int ":unsigned-int";
+
+%typemap(cout) long ":long";
+%typemap(cout) signed long ":long";
+%typemap(cout) unsigned long ":unsigned-long";
+
+%typemap(cout) long long ":long-long";
+%typemap(cout) signed long long ":long-long";
+%typemap(cout) unsigned long long ":unsigned-long-long";
+
+%typemap(cout) float ":float";
+%typemap(cout) double ":double";
+%typemap(cout) SWIGTYPE ":pointer";
+
+
+%typemap(ctype) bool                       "int";
+%typemap(ctype) char, unsigned char, signed char,
+                short, signed short, unsigned short,
+                int, signed int, unsigned int,
+                long, signed long, unsigned long,
+                float, double, long double, char *, void *, void,
+                enum SWIGTYPE, SWIGTYPE *,
+                SWIGTYPE[ANY], SWIGTYPE &  "$1_ltype";
+%typemap(ctype) SWIGTYPE                   "$&1_type";
+
+%typemap(in) bool                          "$1 = (bool)$input;";
+%typemap(in) char, unsigned char, signed char,
+             short, signed short, unsigned short,
+             int, signed int, unsigned int,
+             long, signed long, unsigned long,
+             float, double, long double, char *, void *, void,
+             enum SWIGTYPE, SWIGTYPE *,
+             SWIGTYPE[ANY], SWIGTYPE &     "$1 = $input;";
+%typemap(in) SWIGTYPE                      "$1 = *$input;";
+
+%typemap(out) void                         "";
+%typemap(out) bool                          "$result = (int)$1;";
+%typemap(out) char, unsigned char, signed char,
+              short, signed short, unsigned short,
+              int, signed int, unsigned int,
+              long, signed long, unsigned long,
+              float, double, long double, char *, void *,
+              enum SWIGTYPE, SWIGTYPE *,
+              SWIGTYPE[ANY], SWIGTYPE &    "$result = $1;";
+#ifdef __cplusplus
+%typemap(out) SWIGTYPE                     "$result = new $1_type($1);";
+#else
+%typemap(out) SWIGTYPE {
+  $result = ($&1_ltype) malloc(sizeof($1_type));
+  memmove($result, &$1, sizeof($1_type));
+}
+#endif
+
+%typecheck(SWIG_TYPECHECK_BOOL) bool { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_CHAR) char { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_FLOAT) float { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_DOUBLE) double { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_STRING) char * { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_INTEGER)
+                    unsigned char, signed char,
+                    short, signed short, unsigned short,
+                    int, signed int, unsigned int,
+                    long, signed long, unsigned long,
+                    enum SWIGTYPE { $1 = 1; };
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &,
+                                   SWIGTYPE[ANY], SWIGTYPE { $1 = 1; };
+/* This maps C/C++ types to Lisp classes for overload dispatch */
+
+%typemap(lisptype) bool "cl:boolean";
+%typemap(lisptype) char "cl:character";
+%typemap(lisptype) unsigned char "cl:integer";
+%typemap(lisptype) signed char "cl:integer";
+
+%typemap(lispclass) bool "t";
+%typemap(lispclass) char "cl:character";
+%typemap(lispclass) unsigned char, signed char,
+                    short, signed short, unsigned short,
+                    int, signed int, unsigned int,
+                    long, signed long, unsigned long,
+                    enum SWIGTYPE       "cl:integer";
+/* CLOS methods can't be specialized on single-float or double-float */
+%typemap(lispclass) float "cl:number";
+%typemap(lispclass) double "cl:number";
+%typemap(lispclass) char * "cl:string";
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+%{
+
+#ifdef __cplusplus
+#  define EXTERN   extern "C"
+#else
+#  define EXTERN   extern
+#endif
+
+#define EXPORT   EXTERN SWIGEXPORT
+
+#include <string.h>
+%}
+
+%insert("swiglisp") %{
+;;;SWIG wrapper code starts here
+
+(cl:defmacro defanonenum (cl:&body enums)
+   "Converts anonymous enums to defconstants."
+  `(cl:progn ,@(cl:loop for value in enums
+                        for index = 0 then (cl:1+ index)
+                        when (cl:listp value) do (cl:setf index (cl:second value)
+                                                          value (cl:first value))
+                        collect `(cl:defconstant ,value ,index))))
+
+(cl:eval-when (:compile-toplevel :load-toplevel)
+  (cl:unless (cl:fboundp 'swig-lispify)
+    (cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
+      (cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
+                    (cl:cond
+                      ((cl:null lst)
+                       rest)
+                      ((cl:upper-case-p c)
+                       (helper (cl:cdr lst) 'upper
+                               (cl:case last
+                                 ((lower digit) (cl:list* c #\- rest))
+                                 (cl:t (cl:cons c rest)))))
+                      ((cl:lower-case-p c)
+                       (helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
+                      ((cl:digit-char-p c)
+                       (helper (cl:cdr lst) 'digit 
+                               (cl:case last
+                                 ((upper lower) (cl:list* c #\- rest))
+                                 (cl:t (cl:cons c rest)))))
+                      ((cl:char-equal c #\_)
+                       (helper (cl:cdr lst) '_ (cl:cons #\- rest)))
+                      (cl:t
+                       (cl:error "Invalid character: ~A" c)))))
+        (cl:let ((fix (cl:case flag
+                        ((constant enumvalue) "+")
+                        (variable "*")
+                        (cl:t ""))))
+          (cl:intern
+           (cl:concatenate
+            'cl:string
+            fix
+            (cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
+            fix)
+           package))))))
+
+;;;SWIG wrapper code ends here
+%}
+
+#ifdef __cplusplus
+%typemap(out) SWIGTYPE                     "$result = new $1_type($1);";
+#else
+%typemap(out) SWIGTYPE {
+  $result = ($&1_ltype) malloc(sizeof($1_type));
+  memmove($result, &$1, sizeof($1_type));
+}
+#endif
+
+//////////////////////////////////////////////////////////////
+
+/* name conversion for overloaded operators. */
+#ifdef __cplusplus
+%rename(__add__)	     *::operator+;
+%rename(__pos__)	     *::operator+();
+%rename(__pos__)	     *::operator+() const;
+
+%rename(__sub__)	     *::operator-;
+%rename(__neg__)	     *::operator-() const;
+%rename(__neg__)	     *::operator-();
+
+%rename(__mul__)	     *::operator*;
+%rename(__deref__)	     *::operator*();
+%rename(__deref__)	     *::operator*() const;
+
+%rename(__div__)	     *::operator/;
+%rename(__mod__)	     *::operator%;
+%rename(__logxor__)	     *::operator^;
+%rename(__logand__)	     *::operator&;
+%rename(__logior__)	     *::operator|;
+%rename(__lognot__)	     *::operator~();
+%rename(__lognot__)	     *::operator~() const;
+
+%rename(__not__)	     *::operator!();
+%rename(__not__)	     *::operator!() const;
+
+%rename(__assign__)	     *::operator=;
+
+%rename(__add_assign__)      *::operator+=;
+%rename(__sub_assign__)	     *::operator-=;
+%rename(__mul_assign__)	     *::operator*=;
+%rename(__div_assign__)	     *::operator/=;
+%rename(__mod_assign__)	     *::operator%=;
+%rename(__logxor_assign__)   *::operator^=;
+%rename(__logand_assign__)   *::operator&=;
+%rename(__logior_assign__)   *::operator|=;
+
+%rename(__lshift__)	     *::operator<<;
+%rename(__lshift_assign__)   *::operator<<=;
+%rename(__rshift__)	     *::operator>>;
+%rename(__rshift_assign__)   *::operator>>=;
+
+%rename(__eq__)		     *::operator==;
+%rename(__ne__)		     *::operator!=;
+%rename(__lt__)		     *::operator<;
+%rename(__gt__)		     *::operator>;
+%rename(__lte__)	     *::operator<=;
+%rename(__gte__)	     *::operator>=;
+
+%rename(__and__)	     *::operator&&;
+%rename(__or__)		     *::operator||;
+
+%rename(__preincr__)	     *::operator++();
+%rename(__postincr__)	     *::operator++(int);
+%rename(__predecr__)	     *::operator--();
+%rename(__postdecr__)	     *::operator--(int);
+
+%rename(__comma__)	     *::operator,();
+%rename(__comma__)	     *::operator,() const;
+
+%rename(__member_ref__)      *::operator->;
+%rename(__member_func_ref__) *::operator->*;
+
+%rename(__funcall__)	     *::operator();
+%rename(__aref__)	     *::operator[];
+#endif
+
+
+%{
+
+#ifdef __cplusplus
+#  define EXTERN   extern "C"
+#else
+#  define EXTERN   extern
+#endif
+
+#define EXPORT   EXTERN SWIGEXPORT
+
+#include <string.h>
+#include <stdlib.h>
+%}
diff --git a/share/swig/2.0.11/chicken/chicken.swg b/share/swig/2.0.11/chicken/chicken.swg
new file mode 100644
index 0000000..525c1a6
--- /dev/null
+++ b/share/swig/2.0.11/chicken/chicken.swg
@@ -0,0 +1,781 @@
+/* -----------------------------------------------------------------------------
+ * chicken.swg
+ *
+ * CHICKEN configuration module.
+ * ----------------------------------------------------------------------------- */
+
+/* chicken.h has to appear first. */
+
+%insert(runtime) %{
+#include <assert.h>
+#include <chicken.h>
+%}
+
+%insert(runtime) "swigrun.swg";            // Common C API type-checking code
+%insert(runtime) "chickenrun.swg";      // CHICKEN run-time code
+
+/* -----------------------------------------------------------------------------
+ *                          standard typemaps
+ * ----------------------------------------------------------------------------- */
+
+/*
+  CHICKEN: C
+  ----------
+
+  fixnum: int, short, unsigned int, unsigned short, unsigned char,
+  signed char
+
+  char: char
+
+  bool: bool
+
+  flonum: float, double, long, long long, unsigned long, unsigned long
+  long
+ */
+
+/* --- Primitive types --- */
+
+%define SIMPLE_TYPEMAP(type_, from_scheme, to_scheme, checker, convtype, storage_)
+
+%typemap(in) type_ 
+%{  if (!checker ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'");
+  }
+  $1 = ($1_ltype) from_scheme ($input); %}
+
+/* Const primitive references.  Passed by value */
+
+%typemap(in) const type_ & ($*1_ltype temp)
+%{  if (!checker ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'");
+  }
+  temp = ($*1_ltype) from_scheme ($input); 
+  $1 = &temp; %}
+
+/* --- Variable input --- */
+%typemap(varin) type_
+%{  if (!checker ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Cannot use '$1_ltype' for variable '$name' of type 'type_'");
+  }
+  $1 = ($1_ltype) from_scheme ($input); %}
+
+#if "storage_" == "0"
+
+%typemap(out) type_ 
+%{
+  $result = to_scheme (convtype ($1));
+%}
+
+/* References to primitive types.  Return by value */
+
+%typemap(out) const type_ &
+%{
+  $result = to_scheme (convtype (*$1));
+%}
+
+/* --- Variable output --- */
+%typemap(varout) type_ 
+%{
+  $result = to_scheme (convtype ($varname));
+%}
+
+%typemap(throws) type_
+%{
+  SWIG_Chicken_ThrowException(to_scheme ( convtype ($1)));
+%}
+
+#else
+
+%typemap(out) type_ 
+%{
+  {
+  C_word *space = C_alloc(storage_);
+  $result = to_scheme (&space, convtype ($1));
+  }
+%}
+
+/* References to primitive types.  Return by value */
+
+%typemap(out) const type_ &
+%{
+  {
+  C_word *space = C_alloc(storage_);
+  $result = to_scheme (&space, convtype (*$1));
+  }
+%}
+
+/* --- Variable output --- */
+%typemap(varout) type_ 
+%{
+  {
+  C_word *space = C_alloc(storage_);
+  $result = to_scheme (&space, convtype ($varname));
+  }
+%}
+
+%typemap(throws) type_
+%{
+  {
+  C_word *space = C_alloc(storage_);
+  SWIG_Chicken_ThrowException(to_scheme (&space, convtype ($1)));
+  }
+%}
+
+#endif
+
+/* --- Constants --- */
+
+%typemap(constcode) type_
+"static const $1_type $result = $value;"
+
+%enddef
+
+SIMPLE_TYPEMAP(int, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
+//SIMPLE_TYPEMAP(enum SWIGTYPE, C_unfix, C_fix, C_swig_is_fixnum, (int), 0);
+SIMPLE_TYPEMAP(short, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
+SIMPLE_TYPEMAP(long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(long long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(unsigned int, C_num_to_unsigned_int, C_unsigned_int_to_num, C_swig_is_number, (unsigned int), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(unsigned short, C_num_to_unsigned_int, C_fix, C_swig_is_number, (unsigned int), 0);
+SIMPLE_TYPEMAP(unsigned long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(unsigned long long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(unsigned char, C_character_code, C_make_character, C_swig_is_char, (unsigned int), 0);
+SIMPLE_TYPEMAP(signed char, C_character_code, C_make_character, C_swig_is_char, (int), 0);
+SIMPLE_TYPEMAP(char, C_character_code, C_make_character, C_swig_is_char, (char), 0);
+SIMPLE_TYPEMAP(bool, C_truep, C_mk_bool, C_swig_is_bool, (bool), 0);
+SIMPLE_TYPEMAP(float, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
+SIMPLE_TYPEMAP(double, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
+
+/* enum SWIGTYPE */
+%apply int { enum SWIGTYPE };
+%apply const int& { const enum SWIGTYPE& };
+
+%typemap(varin) enum SWIGTYPE
+{
+  if (!C_swig_is_fixnum($input) && sizeof(int) != sizeof($1)) {
+    swig_barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "enum variable '$name' can not be set");
+  }
+  *((int *)(void *)&$1) = C_unfix($input);
+}
+
+
+/* --- Input arguments --- */
+
+/* Strings */
+
+%typemap(in) char * 
+{ if ($input == C_SCHEME_FALSE) {
+  $1 = NULL;
+ }
+ else { 
+   if (!C_swig_is_string ($input)) {
+     swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'char *'");
+   }
+   $1 = ($ltype) SWIG_MakeString ($input);
+ }
+}
+
+%typemap(freearg) char * "if ($1 != NULL) { free ($1); }"
+
+/* Pointers, references, and arrays */
+%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *, SWIGTYPE [], SWIGTYPE &  {
+   $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, $disown);
+}
+
+%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *DISOWN {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, SWIG_POINTER_DISOWN);
+}
+
+/* Void pointer.  Accepts any kind of pointer */
+%typemap(in) void * {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0);
+}
+
+%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE * {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, SWIG_POINTER_DISOWN);
+}
+
+%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE & {
+  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
+}
+
+%typemap(varin) SWIGTYPE [] {
+  SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "Type error");
+}
+
+%typemap(varin) SWIGTYPE [ANY] {
+  void *temp;
+  int ii;
+  $1_basetype *b = 0;
+  temp = SWIG_MustGetPtr($input, $1_descriptor, 1, 0);
+  b = ($1_basetype *) $1;
+  for (ii = 0; ii < $1_size; ii++) b[ii] = *(($1_basetype *) temp + ii);
+}
+
+%typemap(varin) void * {
+  $1 = SWIG_MustGetPtr($input, NULL, 1, 0);
+}
+
+%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  $result = SWIG_NewPointerObj($1, $descriptor, $owner);
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
+  $result = SWIG_NewPointerObj($1, ty, $owner);
+}
+    
+%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  $result = SWIG_NewPointerObj($varname, $descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE & {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  $result = SWIG_NewPointerObj((void *) &$varname, $1_descriptor, 0);
+}
+
+/* special typemaps for class pointers */
+%typemap(in) SWIGTYPE (CLASS::*) {
+  char err_msg[256];
+
+  if (C_swig_is_pair($input)) {
+    /* try and convert pointer object */
+    void *result;
+    if (!SWIG_ConvertPtr(C_block_item($input,1), &result, $descriptor, 0)) {
+      C_word ptr = C_block_item($input,0);
+      if (C_swig_is_string(ptr)) {
+        SWIG_UnpackData(C_c_string(ptr), (void *) &$1, sizeof($type));
+      } else {
+        snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name));
+        SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+      }
+    } else {
+      snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name));
+      SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+    }
+  } else {
+    snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name));
+    SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+  }
+}
+
+%typemap(out) SWIGTYPE (CLASS::*) {
+  size_t ptr_size = sizeof($type);
+  C_word *known_space = C_alloc(C_SIZEOF_PAIR + C_SIZEOF_STRING(2*ptr_size) + C_SIZEOF_SWIG_POINTER);
+  char *temp = (char *)malloc(2*ptr_size);
+  C_word ptr = SWIG_NewPointerObj((void *) known_space, $descriptor, 0);
+
+  SWIG_PackData(temp, (void *) &$1, ptr_size);
+  $result = C_pair(&known_space, C_string(&known_space, 2*ptr_size, temp), ptr);
+  free(temp);
+}
+
+%typemap(varin) SWIGTYPE (CLASS::*) {
+  char err_msg[256];
+
+  if (C_swig_is_pair($input)) {
+    /* try and convert pointer object */
+    void *result;
+    if (!SWIG_ConvertPtr(C_block_item($input,1), &result, $descriptor, 0)) {
+      C_word ptr = C_block_item($input,0);
+      if (C_swig_is_string(ptr)) {
+        SWIG_UnpackData(C_c_string(ptr), (void *) &$1, sizeof($type));
+      } else {
+        snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name));
+        SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+      }
+    } else {
+      snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name));
+      SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+    }
+  } else {
+    snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name));
+    SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+  }
+}
+
+%typemap(varout) SWIGTYPE (CLASS::*) {
+  size_t ptr_size = sizeof($type);
+  C_word *known_space = C_alloc(C_SIZEOF_PAIR + C_SIZEOF_STRING(2*ptr_size) + C_SIZEOF_SWIG_POINTER);
+  char *temp = (char *)malloc(2*ptr_size);
+  C_word ptr = SWIG_NewPointerObj((void *) known_space, $descriptor, 0);
+
+  SWIG_PackData(temp, (void *) &$varname, ptr_size);
+  $result = C_pair(&known_space, C_string(&known_space, 2*ptr_size, temp), ptr);
+  free(temp);
+}
+
+  
+
+/* Pass-by-value */
+
+%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE($&1_ltype argp) {
+  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
+  $1 = *argp;
+}
+
+%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE {
+  $&1_ltype argp;
+  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
+  $1 = *argp;
+}
+
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+{
+  $&1_ltype resultptr;
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  resultptr = new $1_ltype((const $1_ltype &) $1);
+  $result =  SWIG_NewPointerObj(resultptr, $&1_descriptor, 1);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 1);
+}
+#endif
+
+%typemap(varout) SWIGTYPE 
+#ifdef __cplusplus
+{
+  $&1_ltype resultptr;
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  resultptr = new $1_ltype((const $1_ltype&) $1);
+  $result =  SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
+}
+#endif
+
+/* --- Output values --- */
+
+/* Strings */
+
+%typemap(out) 
+  char *
+{ char *s = (char*) $1;
+  if ($1 == NULL) {
+    $result = C_SCHEME_FALSE;
+  } 
+  else {
+    int string_len = strlen ((char *) ($1));
+    C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len));
+    $result = C_string (&string_space, string_len, s);
+  }
+}
+
+%typemap(varout) 
+  char *
+{ char *s = (char*) $varname;
+  if ($varname == NULL) {
+    $result = C_SCHEME_FALSE;
+  } 
+  else {
+    int string_len = strlen ($varname);
+    C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len));
+    $result = C_string (&string_space, string_len, s);
+  }
+}
+
+%typemap(throws) char *
+{ 
+  if ($1 == NULL) {
+    SWIG_Chicken_ThrowException(C_SCHEME_FALSE);
+  } else {
+    int string_len = strlen($1);
+    C_word *string_space = C_alloc(C_SIZEOF_STRING(string_len));
+    SWIG_Chicken_ThrowException(C_string(&string_space, string_len, (char *) $1));
+  }
+}
+
+/* Void */
+%typemap(out) void
+%{
+$result = C_SCHEME_UNDEFINED;
+%}
+
+/* Special typemap for character array return values */
+
+%typemap(out) 
+  char [ANY], const char [ANY] 
+%{ if ($1 == NULL) {
+  $result = C_SCHEME_FALSE;
+ }
+ else {
+   const int string_len = strlen ($1);
+   C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len));
+   $result = C_string (&string_space, string_len, $1);
+ } %}
+
+/* Primitive types--return by value */
+
+/* --- Variable input --- */
+
+/* A string */
+#ifdef __cplusplus
+%typemap(varin) char * {
+  if ($input == C_SCHEME_FALSE) {
+    $1 = NULL;
+  }
+  else if (!C_swig_is_string ($input)) {
+      swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'");
+  }
+  else {
+    char *temp = C_c_string ($input);
+    int  len   = C_header_size ($input);
+    if ($1) delete [] $1;
+    $1 = ($type) new char[len+1];
+    strncpy((char*)$1, temp, len);
+    ((char*)$1) [len] = 0;
+  }
+}
+%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * {
+  if ($input == C_SCHEME_FALSE) {
+    $1 = NULL;
+  }
+  else if (!C_swig_is_string ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'");
+  }
+  else {
+    char *temp = C_c_string ($input);
+    int  len   = C_header_size ($input);
+    $1 = ($type) new char[len+1];
+    strncpy((char*)$1,temp,len);
+    ((char*)$1) [len] = 0;
+  }
+}
+#else
+%typemap(varin) char * {
+  if ($input == C_SCHEME_FALSE) {
+    $1 = NULL;
+  }
+  else if (!C_swig_is_string ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'");
+  }
+  else {
+    char *temp = C_c_string ($input);
+    int  len   = C_header_size ($input);
+    if ($1) free((char*) $1);
+    $1 = ($type) malloc(len+1);
+    strncpy((char*)$1,temp,len);
+    ((char*)$1) [len] = 0;
+  }
+}
+%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * {
+  if ($input == C_SCHEME_FALSE) {
+    $1 = NULL;
+  }
+  else if (!C_swig_is_string ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'");
+  }
+  else {
+    char *temp = C_c_string ($input);
+    int  len   = C_header_size ($input);
+    $1 = ($type) malloc(len+1);
+    strncpy((char*)$1,temp,len);
+    ((char*)$1) [len] = 0;
+  }
+}
+#endif
+
+%typemap(varin) char [] {
+  swig_barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "C/C++ variable '$name' is read-only");
+}
+
+/* Special case for string array variables */
+%typemap(varin) char [ANY] {
+  if ($input == C_SCHEME_FALSE) {
+    memset($1,0,$1_dim0*sizeof(char));
+  }
+  else if (!C_swig_is_string ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'");
+  }
+  else {
+    char *temp = C_c_string ($input);
+    strncpy($1,temp,$1_dim0*sizeof(char));
+  }
+}
+
+/* --- Variable output --- */
+
+/* Void */
+%typemap(varout) void "$result = C_SCHEME_UNDEFINED;";
+
+/* Special typemap for character array return values */
+%typemap(varout) char [ANY], const char [ANY] 
+%{  if ($varname == NULL) {
+    $result = C_SCHEME_FALSE;
+  }
+  else {
+   const int string_len = strlen ($varname);
+   C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len));
+   $result = C_string (&string_space, string_len, (char *) $varname);
+  }
+%}
+
+
+/* --- Constants --- */
+
+%typemap(constcode) char *
+"static const char *$result = $value;"
+
+%typemap(constcode) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
+"static const void *$result = (void*) $value;"
+
+/* ------------------------------------------------------------
+ * String & length
+ * ------------------------------------------------------------ */
+
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
+  if ($input == C_SCHEME_FALSE) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Cannot use a null/#f string for a char*, int arguments");
+  }
+  else if (C_swig_is_string ($input)) {
+    $1 = ($1_ltype) C_c_string ($input);
+    $2 = ($2_ltype) C_header_size ($input);
+  }
+  else {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'string'");
+  }
+}
+
+/* ------------------------------------------------------------
+ * CHICKEN types
+ * ------------------------------------------------------------ */
+
+%typemap(in)   C_word "$1 = $input;";
+%typemap(out)  C_word "$result = $1;";
+
+/* ------------------------------------------------------------
+ * Typechecking rules
+ * ------------------------------------------------------------ */
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+         bool, const bool & 
+{
+  $1 = C_swig_is_bool ($input);
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, 
+ 	 unsigned int, unsigned short,
+	 signed char, unsigned char,
+	 const int &, const short &, 
+ 	 const unsigned int &, const unsigned short &,
+	 enum SWIGTYPE
+{
+  $1 = C_swig_is_fixnum ($input);
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 long,
+ 	 unsigned long,
+	 long long, unsigned long long,
+	 const long &,
+ 	 const unsigned long &,
+	 const long long &, const unsigned long long &
+{
+  $1 = (C_swig_is_bool ($input) || 
+    C_swig_is_fixnum ($input) || 
+    C_swig_is_flonum ($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+	float, double,
+	const float &, const double &
+{
+  $1 = C_swig_is_flonum ($input);
+}
+
+%typecheck(SWIG_TYPECHECK_CHAR) char {
+  $1 = C_swig_is_string ($input);
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+  $1 = C_swig_is_string ($input);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+  void *ptr;
+  $1 = !SWIG_ConvertPtr($input, &ptr, $1_descriptor, 0);
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  $1 = !SWIG_ConvertPtr($input, &ptr, 0, 0);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE &
+{
+  void *ptr = 0;
+  if (SWIG_ConvertPtr($input, &ptr, $descriptor, 0)) {
+    /* error */
+    $1 = 0;
+  } else {
+    $1 = (ptr != 0);
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE 
+{
+  void *ptr = 0;
+  if (SWIG_ConvertPtr($input, &ptr, $&descriptor, 0)) {
+    /* error */
+    $1 = 0;
+  } else {
+    $1 = (ptr != 0);
+  }
+}
+
+
+/* ------------------------------------------------------------
+ * Exception handling
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ * --- Exception handling ---
+ * ------------------------------------------------------------ */
+
+%typemap(throws) SWIGTYPE {
+  $&ltype temp = new $ltype($1);
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  C_word ptr = SWIG_NewPointerObj(temp, $&descriptor,1);
+  SWIG_Chicken_ThrowException(ptr);
+}
+
+%typemap(throws) SWIGTYPE * {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  C_word ptr = SWIG_NewPointerObj((void *) $1, $descriptor, 0);
+  SWIG_Chicken_ThrowException(ptr);
+}
+
+%typemap(throws) SWIGTYPE [ANY] {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  C_word ptr = SWIG_NewPointerObj((void *) $1, $descriptor, 0);
+  SWIG_Chicken_ThrowException(ptr);
+}
+
+%typemap(throws) SWIGTYPE & {
+  C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
+  C_word ptr = SWIG_NewPointerObj((void *)&($1),$descriptor,0);
+  SWIG_Chicken_ThrowException(ptr);
+}
+
+/* ------------------------------------------------------------
+ * ANSI C typemaps
+ * ------------------------------------------------------------ */
+
+%apply unsigned long { size_t };
+
+/* ------------------------------------------------------------
+ * Various
+ * ------------------------------------------------------------ */
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* ------------------------------------------------------------
+ * Overloaded operator support
+ * ------------------------------------------------------------ */
+
+#ifdef __cplusplus
+%rename(__add__)      *::operator+;
+%rename(__pos__)      *::operator+();
+%rename(__pos__)      *::operator+() const;
+%rename(__sub__)      *::operator-;
+%rename(__neg__)      *::operator-();
+%rename(__neg__)      *::operator-() const;
+%rename(__mul__)      *::operator*;
+%rename(__div__)      *::operator/;
+%rename(__mod__)      *::operator%;
+%rename(__lshift__)   *::operator<<;
+%rename(__rshift__)   *::operator>>;
+%rename(__and__)      *::operator&;
+%rename(__or__)       *::operator|;
+%rename(__xor__)      *::operator^;
+%rename(__invert__)   *::operator~;
+%rename(__iadd__)     *::operator+=;
+%rename(__isub__)     *::operator-=;
+%rename(__imul__)     *::operator*=;
+%rename(__idiv__)     *::operator/=;
+%rename(__imod__)     *::operator%=;
+%rename(__ilshift__)  *::operator<<=;
+%rename(__irshift__)  *::operator>>=;
+%rename(__iand__)     *::operator&=;
+%rename(__ior__)      *::operator|=;
+%rename(__ixor__)     *::operator^=;
+%rename(__lt__)       *::operator<;
+%rename(__le__)       *::operator<=;
+%rename(__gt__)       *::operator>;
+%rename(__ge__)       *::operator>=;
+%rename(__eq__)       *::operator==;
+%rename(__ne__)       *::operator!=;
+
+/* Special cases */
+%rename(__call__)     *::operator();
+
+#endif
+/* Warnings for certain CHICKEN keywords */
+%include <chickenkw.swg>
+
+/* TinyCLOS <--> Low-level CHICKEN */
+
+%typemap("clos_in") SIMPLE_CLOS_OBJECT * "(slot-ref $input (quote this))"
+%typemap("clos_out") SIMPLE_CLOS_OBJECT * "(make $class (quote this) $1)"
+
+%insert(header) %{
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Chicken initialization function */
+SWIGEXPORT void SWIG_init(C_word, C_word, C_word) C_noret;
+#ifdef __cplusplus
+}
+#endif
+%}
+
+%insert(closprefix) "swigclosprefix.scm"
+
+%insert(init) "swiginit.swg"
+
+%insert(init) %{
+/* CHICKEN initialization function */
+#ifdef __cplusplus
+extern "C" {
+#endif
+SWIGEXPORT void SWIG_init(C_word argc, C_word closure, C_word continuation) {
+  int       i;
+  C_word sym;
+  C_word tmp;
+  C_word *a;
+  C_word ret;
+  C_word *return_vec;
+
+  SWIG_InitializeModule(0);
+  SWIG_PropagateClientData();
+  ret = C_SCHEME_TRUE;
+  
+#if $veclength
+  return_vec = C_alloc(C_SIZEOF_VECTOR($veclength));
+  ret = (C_word) return_vec;
+  *(return_vec++) = C_VECTOR_TYPE | $veclength;
+#endif
+
+  a = C_alloc(2*$nummethods$symsize);
+
+%}
diff --git a/share/swig/2.0.11/chicken/chickenkw.swg b/share/swig/2.0.11/chicken/chickenkw.swg
new file mode 100644
index 0000000..d2c26c7
--- /dev/null
+++ b/share/swig/2.0.11/chicken/chickenkw.swg
@@ -0,0 +1,31 @@
+#ifndef CHICKEN_CHICKENKW_SWG_
+#define CHICKEN_CHICKENKW_SWG_
+
+/* Warnings for certain CHICKEN keywords. From Section 7.1.1 of
+   Revised^5 Report on the Algorithmic Language Scheme */
+#define CHICKENKW(x) %namewarn("314: '" #x "' is a R^5RS syntatic keyword")  #x
+
+CHICKENKW(else);
+CHICKENKW(=>);
+CHICKENKW(define);
+CHICKENKW(unquote);
+CHICKENKW(unquote-splicing);
+CHICKENKW(quote);
+CHICKENKW(lambda);
+CHICKENKW(if);
+CHICKENKW(set!);
+CHICKENKW(begin);
+CHICKENKW(cond);
+CHICKENKW(and);
+CHICKENKW(or);
+CHICKENKW(case);
+CHICKENKW(let);
+CHICKENKW(let*);
+CHICKENKW(letrec);
+CHICKENKW(do);
+CHICKENKW(delay);
+CHICKENKW(quasiquote);
+
+#undef CHICKENKW 
+
+#endif //CHICKEN_CHICKENKW_SWG_
diff --git a/share/swig/2.0.11/chicken/chickenrun.swg b/share/swig/2.0.11/chicken/chickenrun.swg
new file mode 100644
index 0000000..07db419
--- /dev/null
+++ b/share/swig/2.0.11/chicken/chickenrun.swg
@@ -0,0 +1,374 @@
+/* -----------------------------------------------------------------------------
+ * chickenrun.swg
+ * ----------------------------------------------------------------------------- */
+
+#include <chicken.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
+# ifndef snprintf
+#  define snprintf _snprintf
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_malloc(size) \
+  malloc(size)
+#define SWIG_free(mem) \
+  free(mem)
+#define SWIG_MakeString(c) \
+  SWIG_Chicken_MakeString(c)
+#define SWIG_ConvertPtr(s, result, type, flags) \
+  SWIG_Chicken_ConvertPtr(s, result, type, flags)
+#define SWIG_MustGetPtr(s, type, argnum, flags) \
+  SWIG_Chicken_MustGetPtr(s, type, argnum, flags)
+#define SWIG_NewPointerObj(ptr, type, owner) \
+  SWIG_Chicken_NewPointerObj((void*)ptr, type, owner, &known_space)
+#define swig_barf SWIG_Chicken_Barf
+#define SWIG_ThrowException(val) SWIG_Chicken_ThrowException(val)
+
+#define SWIG_contract_assert(expr, message) if (!(expr)) { \
+                                              SWIG_Chicken_Barf(SWIG_BARF1_CONTRACT_ASSERT, C_text(message)); } else
+
+/* Runtime API */
+#define SWIG_GetModule(clientdata) SWIG_Chicken_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Chicken_SetModule(pointer)
+
+#define C_swig_is_bool(x) C_truep (C_booleanp (x))
+#define C_swig_is_char(x) C_truep (C_charp (x))
+#define C_swig_is_fixnum(x) C_truep (C_fixnump (x))
+#define C_swig_is_flonum(x) (C_truep (C_blockp (x)) && C_truep (C_flonump (x)))
+#define C_swig_is_string(x) (C_truep (C_blockp (x)) && C_truep (C_stringp (x)))
+#define C_swig_is_vector(x) (C_truep (C_blockp (x)) && C_truep (C_vectorp (x)))
+#define C_swig_is_list(x) (C_truep (C_i_listp (x)))
+#define C_swig_is_pair(x) (C_truep (C_blockp(x)) && C_truep (C_pairp(x)))
+#define C_swig_is_ptr(x) (C_truep (C_blockp (x)) && C_truep (C_pointerp (x)))
+#define C_swig_is_swigpointer(x) (C_truep (C_blockp(x)) && C_truep (C_swigpointerp(x)))
+#define C_swig_is_closurep(x) (C_truep (C_blockp(x)) && C_truep(C_closurep(x)))
+#define C_swig_is_number(x) (C_swig_is_fixnum(x) || C_swig_is_flonum(x))
+#define C_swig_is_long(x) C_swig_is_number(x)
+
+#define C_swig_sizeof_closure(num) (num+1)
+
+#define SWIG_Chicken_SetupArgout { \
+  C_word *a = C_alloc(C_swig_sizeof_closure(2)); \
+  C_word *closure = a; \
+  *(a++)=C_CLOSURE_TYPE|2; \
+  *(a++)=(C_word)SWIG_Chicken_ApplyResults; \
+  *(a++)=continuation; \
+  continuation=(C_word)closure; \
+}
+
+#define SWIG_APPEND_VALUE(obj) { \
+  C_word val = (C_word)(obj); \
+  if (val != C_SCHEME_UNDEFINED) { \
+    C_word *a = C_alloc(C_swig_sizeof_closure(3)); \
+    C_word *closure = a; \
+    *(a++)=C_CLOSURE_TYPE|3; \
+    *(a++)=(C_word)SWIG_Chicken_MultiResultBuild; \
+    *(a++)=(C_word)continuation; \
+    *(a++)=val; \
+    continuation=(C_word)closure; \
+  } }
+
+#define SWIG_Chicken_FindCreateProxy(func,obj) \
+  if (C_swig_is_swigpointer(obj)) { \
+    swig_type_info *t = (swig_type_info *) C_block_item(obj, 1); \
+    if (t && t->clientdata &&    ((swig_chicken_clientdata *)t->clientdata)->gc_proxy_create) { \
+      func = CHICKEN_gc_root_ref( ((swig_chicken_clientdata *)t->clientdata)->gc_proxy_create); \
+    } else { \
+      func = C_SCHEME_FALSE; \
+    } \
+  } else { \
+    func = C_SCHEME_FALSE; \
+  }
+
+
+enum {
+  SWIG_BARF1_BAD_ARGUMENT_TYPE /* 1 arg */,
+  SWIG_BARF1_ARGUMENT_NULL /* 1 arg */,
+  SWIG_BARF1_CONTRACT_ASSERT /* 1 arg */,
+};
+
+typedef C_word (*swig_chicken_destructor)(C_word,C_word,C_word,C_word);
+typedef struct swig_chicken_clientdata {
+  void *gc_proxy_create;
+  swig_chicken_destructor destroy;
+} swig_chicken_clientdata;
+  
+static char *
+SWIG_Chicken_MakeString(C_word str) {
+  char *ret;
+  size_t l;
+
+  l = C_header_size(str);
+  ret = (char *) SWIG_malloc( (l + 1) * sizeof(char));
+  if (!ret) return NULL;
+
+  memcpy(ret, C_c_string(str), l);
+  ret[l] = '\0';
+  return ret;
+}
+
+static C_word SWIG_Chicken_LookupSymbol(char *name, C_SYMBOL_TABLE *stable) {
+  C_word *a = C_alloc(C_SIZEOF_STRING (strlen (name)));
+  C_word n = C_string2(&a, name);
+  C_word sym = C_find_symbol(n, stable);
+  if (C_truep(sym)) {
+    return C_symbol_value(sym);
+  } else {
+    return C_SCHEME_FALSE;
+  }
+}
+
+/* Just a helper function.  Do not export it */
+static void SWIG_Chicken_Panic (C_char *) C_noret;
+static void SWIG_Chicken_Panic (C_char *msg)
+{
+  C_word *a = C_alloc (C_SIZEOF_STRING (strlen (msg)));
+  C_word scmmsg = C_string2 (&a, msg);
+  C_halt (scmmsg);
+  exit (5); /* should never get here */
+}
+
+static void
+SWIG_Chicken_Barf(int code, C_char *msg, ...) C_noret;
+static void
+SWIG_Chicken_Barf(int code, C_char *msg, ...)
+{
+  char *errorhook = C_text("\003syserror-hook");
+  C_word *a = C_alloc (C_SIZEOF_STRING (strlen (errorhook)));
+  C_word err = C_intern2 (&a, errorhook);
+  int c = -1;
+  int i, barfval;
+  va_list v;
+
+  
+  C_temporary_stack = C_temporary_stack_bottom;
+  err = C_block_item(err, 0);
+
+  if(C_immediatep (err))
+    SWIG_Chicken_Panic (C_text ("`##sys#error-hook' is not defined"));
+
+  switch (code) {
+  case SWIG_BARF1_BAD_ARGUMENT_TYPE:
+    barfval = C_BAD_ARGUMENT_TYPE_ERROR;
+    c = 1;
+    break;
+  case SWIG_BARF1_ARGUMENT_NULL:
+    barfval = C_BAD_ARGUMENT_TYPE_ERROR;
+    c = 1;
+    break;
+  case SWIG_BARF1_CONTRACT_ASSERT:
+    barfval = C_BAD_ARGUMENT_TYPE_ERROR;
+    c = 1;
+    break;
+  default:
+    SWIG_Chicken_Panic (C_text (msg));
+  };
+
+  if(c > 0 && !C_immediatep (err)) {
+    C_save (C_fix (barfval));
+
+    i = c;
+    if (i) {
+      C_word *b = C_alloc (C_SIZEOF_STRING (strlen (msg)));
+      C_word scmmsg = C_string2 (&b, msg);
+      C_save (scmmsg);
+      i--;
+    }
+
+    va_start (v, msg);
+
+    while(i--)
+      C_save (va_arg (v, C_word));
+
+    va_end (v);
+    C_do_apply (c + 1, err, 
+		C_SCHEME_UNDEFINED);  /* <- no continuation is passed:
+					 '##sys#error-hook' may not
+					 return! */
+  }
+  else if (msg) {
+    SWIG_Chicken_Panic (msg);
+  }
+  else {
+    SWIG_Chicken_Panic (C_text ("unspecified panic"));
+  }
+}
+
+static void SWIG_Chicken_ThrowException(C_word value) C_noret;
+static void SWIG_Chicken_ThrowException(C_word value)
+{
+  char *aborthook = C_text("\003sysabort");
+  C_word *a = C_alloc(C_SIZEOF_STRING(strlen(aborthook)));
+  C_word abort = C_intern2(&a, aborthook);
+
+  abort = C_block_item(abort, 0);
+  if (C_immediatep(abort))
+    SWIG_Chicken_Panic(C_text("`##sys#abort' is not defined"));
+
+  C_save(value);
+  C_do_apply(1, abort, C_SCHEME_UNDEFINED);
+}
+
+static void
+SWIG_Chicken_Finalizer(C_word argc, C_word closure, C_word continuation, C_word s)
+{
+  swig_type_info *type;
+  swig_chicken_clientdata *cdata;
+
+  if (argc == 3 && s != C_SCHEME_FALSE && C_swig_is_swigpointer(s)) {
+    type = (swig_type_info *) C_block_item(s, 1);
+    if (type) {
+      cdata = (swig_chicken_clientdata *) type->clientdata;
+      if (cdata && cdata->destroy) {
+	/* this will not return, but will continue correctly */
+        cdata->destroy(3,closure,continuation,s);
+      }
+    }
+  }
+  C_kontinue(continuation, C_SCHEME_UNDEFINED);
+}
+static C_word finalizer_obj[2] = {(C_word) (C_CLOSURE_TYPE|1), (C_word) SWIG_Chicken_Finalizer};
+
+static C_word
+SWIG_Chicken_NewPointerObj(void *ptr, swig_type_info *type, int owner, C_word **data)
+{
+  swig_chicken_clientdata *cdata = (swig_chicken_clientdata *) type->clientdata;
+
+  if (ptr == NULL)
+    return C_SCHEME_FALSE;
+  else {
+    C_word cptr = C_swigmpointer(data, ptr, type);
+    /* add finalizer to object */
+    #ifndef SWIG_CHICKEN_NO_COLLECTION
+    if (owner)
+      C_do_register_finalizer(cptr, (C_word) finalizer_obj);
+    #endif
+
+    return cptr;
+  }
+}
+
+/* Return 0 if successful. */
+static int
+SWIG_Chicken_ConvertPtr(C_word s, void **result, swig_type_info *type, int flags)
+{
+  swig_cast_info *cast;
+  swig_type_info *from;
+
+  if (s == C_SCHEME_FALSE) {
+    *result = NULL;
+  } else if (C_swig_is_swigpointer(s)) {
+    /* try and convert type */
+    from = (swig_type_info *) C_block_item(s, 1);
+    if (!from) return 1;
+    if (type) {
+      cast = SWIG_TypeCheckStruct(from, type);
+      if (cast) {
+        int newmemory = 0;
+        *result = SWIG_TypeCast(cast, (void *) C_block_item(s, 0), &newmemory);
+        assert(!newmemory); /* newmemory handling not yet implemented */
+      } else {
+        return 1;
+      }
+    } else {
+      *result = (void *) C_block_item(s, 0);
+    }
+
+    /* check if we are disowning this object */
+    if (flags & SWIG_POINTER_DISOWN) {
+      C_do_unregister_finalizer(s);
+    }
+  } else {
+    return 1;
+  }
+
+  return 0;
+}
+
+static SWIGINLINE void *
+SWIG_Chicken_MustGetPtr (C_word s, swig_type_info *type, int argnum, int flags)
+{
+  void *result;
+  char err_msg[256];
+  if (SWIG_Chicken_ConvertPtr(s, &result, type, flags)) {
+    /* type mismatch */
+    snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", argnum, (type->str ? type->str : type->name));
+    SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg);
+  }
+  return result;
+}
+
+static char *chicken_runtimevar_name = "type_pointer" SWIG_TYPE_TABLE_NAME;
+
+static swig_module_info *
+SWIG_Chicken_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+    swig_module_info *ret = 0;
+    C_word sym;
+
+    /* lookup the type pointer... it is stored in it's own symbol table */
+    C_SYMBOL_TABLE *stable = C_find_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION);
+    if (stable != NULL) {
+      sym = SWIG_Chicken_LookupSymbol(chicken_runtimevar_name, stable);
+      if (C_truep(sym) && C_swig_is_ptr(sym)) {
+        ret = (swig_module_info *) C_block_item(sym, 0);
+      }
+    }
+
+    return ret;
+}
+
+static void
+SWIG_Chicken_SetModule(swig_module_info *module) {
+    C_word *a;
+    C_SYMBOL_TABLE *stable;
+    C_word sym;
+    C_word pointer;
+    static C_word *space = 0;
+    
+    /* type pointer is stored in it's own symbol table */
+    stable = C_find_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION);
+    if (stable == NULL) {
+      stable = C_new_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION, 16);
+    }
+
+    if (!space) {
+      space = (C_word *) C_malloc((C_SIZEOF_POINTER + C_SIZEOF_INTERNED_SYMBOL(C_strlen(chicken_runtimevar_name))) * sizeof(C_word));
+    }
+    a = space;
+    pointer = C_mpointer(&a, (void *) module);
+    sym = C_intern_in(&a, C_strlen(chicken_runtimevar_name), chicken_runtimevar_name, stable);
+    C_set_block_item(sym, 0, pointer);
+}
+
+static C_word SWIG_Chicken_MultiResultBuild(C_word num, C_word closure, C_word lst) {
+  C_word cont = C_block_item(closure,1);
+  C_word obj = C_block_item(closure,2);
+  C_word func;
+
+  SWIG_Chicken_FindCreateProxy(func,obj);
+
+  if (C_swig_is_closurep(func)) {
+    ((C_proc4)(void *)C_block_item(func, 0))(4,func,cont,obj,lst);
+  } else {
+    C_word *a = C_alloc(C_SIZEOF_PAIR);
+    C_kontinue(cont,C_pair(&a,obj,lst));
+  }
+  return C_SCHEME_UNDEFINED; /* never reached */
+}
+
+static C_word SWIG_Chicken_ApplyResults(C_word num, C_word closure, C_word result) {
+  C_apply_values(3,C_SCHEME_UNDEFINED,C_block_item(closure,1),result);
+  return C_SCHEME_UNDEFINED; /* never reached */
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/chicken/multi-generic.scm b/share/swig/2.0.11/chicken/multi-generic.scm
new file mode 100644
index 0000000..9d2e31d
--- /dev/null
+++ b/share/swig/2.0.11/chicken/multi-generic.scm
@@ -0,0 +1,152 @@
+;; This file is no longer necessary with Chicken versions above 1.92
+;; 
+;; This file overrides two functions inside TinyCLOS to provide support
+;; for multi-argument generics.  There are many ways of linking this file
+;; into your code... all that needs to happen is this file must be
+;; executed after loading TinyCLOS but before any SWIG modules are loaded
+;;
+;; something like the following
+;; (require 'tinyclos)
+;; (load "multi-generic")
+;; (declare (uses swigmod))
+;;
+;; An alternative to loading this scheme code directly is to add a
+;; (declare (unit multi-generic)) to the top of this file, and then
+;; compile this into the final executable or something.  Or compile
+;; this into an extension.
+
+;; Lastly, to override TinyCLOS method creation, two functions are
+;; overridden: see the end of this file for which two are overridden.
+;; You might want to remove those two lines and then exert more control over
+;; which functions are used when.
+
+;; Comments, bugs, suggestions: send either to chicken-users@nongnu.org or to
+;; Most code copied from TinyCLOS
+
+(define <multi-generic> (make <entity-class>
+			  'name "multi-generic"
+			  'direct-supers (list <generic>)
+			  'direct-slots '()))
+
+(letrec ([applicable?
+          (lambda (c arg)
+            (memq c (class-cpl (class-of arg))))]
+
+         [more-specific?
+          (lambda (c1 c2 arg)
+            (memq c2 (memq c1 (class-cpl (class-of arg)))))]
+
+         [filter-in
+           (lambda (f l)
+             (if (null? l)
+                 '()
+                 (let ([h (##sys#slot l 0)]
+	               [r (##sys#slot l 1)] )
+	           (if (f h)
+	               (cons h (filter-in f r))
+	               (filter-in f r) ) ) ) )])
+
+(add-method compute-apply-generic
+  (make-method (list <multi-generic>)
+    (lambda (call-next-method generic)
+      (lambda args
+		(let ([cam (let ([x (compute-apply-methods generic)]
+				 [y ((compute-methods generic) args)] )
+			     (lambda (args) (x y args)) ) ] )
+		  (cam args) ) ) ) ) )
+
+
+
+(add-method compute-methods
+  (make-method (list <multi-generic>)
+    (lambda (call-next-method generic)
+      (lambda (args)
+	(let ([applicable
+	       (filter-in (lambda (method)
+                            (let check-applicable ([list1 (method-specializers method)]
+                                                   [list2 args])
+                              (cond ((null? list1) #t)
+                                    ((null? list2) #f)
+                                    (else
+                                      (and (applicable? (##sys#slot list1 0) (##sys#slot list2 0))
+                                           (check-applicable (##sys#slot list1 1) (##sys#slot list2 1)))))))
+			  (generic-methods generic) ) ] )
+	  (if (or (null? applicable) (null? (##sys#slot applicable 1))) 
+	      applicable
+	      (let ([cmms (compute-method-more-specific? generic)])
+		(sort applicable (lambda (m1 m2) (cmms m1 m2 args))) ) ) ) ) ) ) )
+
+(add-method compute-method-more-specific?
+  (make-method (list <multi-generic>)
+    (lambda (call-next-method generic)
+      (lambda (m1 m2 args)
+	(let loop ((specls1 (method-specializers m1))
+		   (specls2 (method-specializers m2))
+		   (args args))
+	  (cond-expand
+	   [unsafe
+	    (let ((c1  (##sys#slot specls1 0))
+		  (c2  (##sys#slot specls2 0))
+		  (arg (##sys#slot args 0)))
+	      (if (eq? c1 c2)
+		  (loop (##sys#slot specls1 1)
+			(##sys#slot specls2 1)
+			(##sys#slot args 1))
+		  (more-specific? c1 c2 arg))) ] 
+	   [else
+	    (cond ((and (null? specls1) (null? specls2))
+		   (##sys#error "two methods are equally specific" generic))
+		  ;((or (null? specls1) (null? specls2))
+		  ; (##sys#error "two methods have different number of specializers" generic))
+                  ((null? specls1) #f)
+                  ((null? specls2) #t)
+		  ((null? args)
+		   (##sys#error "fewer arguments than specializers" generic))
+		  (else
+		   (let ((c1  (##sys#slot specls1 0))
+			 (c2  (##sys#slot specls2 0))
+			 (arg (##sys#slot args 0)))
+		     (if (eq? c1 c2)
+			 (loop (##sys#slot specls1 1)
+			       (##sys#slot specls2 1)
+			       (##sys#slot args 1))
+			 (more-specific? c1 c2 arg)))) ) ] ) ) ) ) ) )
+
+) ;; end of letrec
+
+(define multi-add-method
+  (lambda (generic method)
+    (slot-set!
+     generic
+     'methods
+       (let filter-in-method ([methods (slot-ref generic 'methods)])
+         (if (null? methods)
+           (list method)
+           (let ([l1 (length (method-specializers method))]
+		 [l2 (length (method-specializers (##sys#slot methods 0)))])
+             (cond ((> l1 l2)
+                    (cons (##sys#slot methods 0) (filter-in-method (##sys#slot methods 1))))
+                   ((< l1 l2)
+                    (cons method methods))
+                   (else
+                     (let check-method ([ms1 (method-specializers method)]
+                                        [ms2 (method-specializers (##sys#slot methods 0))])
+                       (cond ((and (null? ms1) (null? ms2))
+                              (cons method (##sys#slot methods 1))) ;; skip the method already in the generic
+                             ((eq? (##sys#slot ms1 0) (##sys#slot ms2 0))
+                              (check-method (##sys#slot ms1 1) (##sys#slot ms2 1)))
+                             (else
+                               (cons (##sys#slot methods 0) (filter-in-method (##sys#slot methods 1))))))))))))
+
+    (##sys#setslot (##sys#slot generic (- (##sys#size generic) 2)) 1 (compute-apply-generic generic)) ))
+
+(define (multi-add-global-method val sym specializers proc)
+  (let ((generic (if (procedure? val) val (make <multi-generic> 'name (##sys#symbol->string sym)))))
+    (multi-add-method generic (make-method specializers proc))
+    generic))
+
+;; Might want to remove these, or perhaps do something like
+;; (define old-add-method ##tinyclos#add-method)
+;; and then you can switch between creating multi-generics and TinyCLOS generics.
+(set! ##tinyclos#add-method multi-add-method)
+(set! ##tinyclos#add-global-method multi-add-global-method)
diff --git a/share/swig/2.0.11/chicken/std_string.i b/share/swig/2.0.11/chicken/std_string.i
new file mode 100644
index 0000000..fa77c15
--- /dev/null
+++ b/share/swig/2.0.11/chicken/std_string.i
@@ -0,0 +1,96 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * SWIG typemaps for std::string
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <string>
+%}
+
+namespace std {
+    %naturalvar string;
+  
+
+    %insert(closprefix) %{ (declare (hide <std-string>)) %}
+    %nodefault string;
+    %rename("std-string") string;
+    class string {
+      public:
+	~string() {}
+    };
+    %extend string {
+      char *str;
+    }
+    %{
+      #define std_string_str_get(s) ((char *)((s)->c_str()))
+      #define std_string_str_set(s,v) (s->assign((char *)(v)))
+    %}
+
+    %typemap(typecheck) string = char *;
+    %typemap(typecheck) const string & = char *;
+
+    %typemap(in) string (char * tempptr) {
+      if ($input == C_SCHEME_FALSE) {
+	$1.resize(0);
+      } else { 
+	if (!C_swig_is_string ($input)) {
+	  swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, 
+		     "Argument #$argnum is not a string");
+	}
+	tempptr = SWIG_MakeString($input);
+	$1.assign(tempptr);
+	if (tempptr) SWIG_free(tempptr);
+      }
+    }
+
+    %typemap(in) const string& ($*1_ltype temp, char *tempptr) {
+
+      if ($input == C_SCHEME_FALSE) {
+	temp.resize(0);
+	$1 = &temp;
+      } else { 
+	if (!C_swig_is_string ($input)) {
+	  swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, 
+		     "Argument #$argnum is not a string");
+	}
+	tempptr = SWIG_MakeString($input);
+	temp.assign(tempptr);
+	if (tempptr) SWIG_free(tempptr);
+	$1 = &temp;
+      }
+    }
+
+    %typemap(out) string { 
+      int size = $1.size();
+      C_word *space = C_alloc (C_SIZEOF_STRING (size));
+      $result = C_string (&space, size, (char *) $1.c_str());
+    }
+
+    %typemap(out) const string& { 
+      int size = $1->size();
+      C_word *space = C_alloc (C_SIZEOF_STRING (size));
+      $result = C_string (&space, size, (char *) $1->c_str());
+    }
+
+    %typemap(varin) string {
+      if ($input == C_SCHEME_FALSE) {
+	$1.resize(0);
+      } else { 
+        char *tempptr;
+	if (!C_swig_is_string ($input)) {
+	  swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, 
+		     "Argument #$argnum is not a string");
+   	}
+	tempptr = SWIG_MakeString($input);
+	$1.assign(tempptr);
+	if (tempptr) SWIG_free(tempptr);
+      }
+    }
+
+    %typemap(varout) string { 
+      int size = $1.size();
+      C_word *space = C_alloc (C_SIZEOF_STRING (size));
+      $result = C_string (&space, size, (char *) $1.c_str());
+    }
+}
diff --git a/share/swig/2.0.11/chicken/swigclosprefix.scm b/share/swig/2.0.11/chicken/swigclosprefix.scm
new file mode 100644
index 0000000..e4bd72b
--- /dev/null
+++ b/share/swig/2.0.11/chicken/swigclosprefix.scm
@@ -0,0 +1,31 @@
+(declare (hide swig-initialize))
+
+(define (swig-initialize obj initargs create)
+     (slot-set! obj 'swig-this
+        (if (memq 'swig-this initargs)
+            (cadr initargs)
+            (let ((ret (apply create initargs)))
+              (if (instance? ret)
+                (slot-ref ret 'swig-this)
+                ret)))))
+
+(define-class <swig-metaclass-$module> (<class>) (void))
+
+(define-method (compute-getter-and-setter (class <swig-metaclass-$module>) slot allocator)
+  (if (not (memq ':swig-virtual slot))
+    (call-next-method)
+    (let ((getter (let search-get ((lst slot))
+                    (if (null? lst)
+                      #f
+                      (if (eq? (car lst) ':swig-get)
+                        (cadr lst)
+                        (search-get (cdr lst))))))
+          (setter (let search-set ((lst slot))
+                    (if (null? lst)
+                      #f
+                      (if (eq? (car lst) ':swig-set)
+                        (cadr lst)
+                        (search-set (cdr lst)))))))
+      (values
+        (lambda (o) (getter (slot-ref o 'swig-this)))
+	(lambda (o new) (setter (slot-ref o 'swig-this) new) new)))))
diff --git a/share/swig/2.0.11/chicken/tinyclos-multi-generic.patch b/share/swig/2.0.11/chicken/tinyclos-multi-generic.patch
new file mode 100644
index 0000000..2e58596
--- /dev/null
+++ b/share/swig/2.0.11/chicken/tinyclos-multi-generic.patch
@@ -0,0 +1,150 @@
+# This patch is against chicken 1.92, but it should work just fine
+# with older versions of chicken.  It adds support for mulit-argument
+# generics, that is, generics now correctly handle adding methods
+# with different lengths of specializer lists
+
+# This patch has been committed into the CHICKEN darcs repository,
+# so chicken versions above 1.92 work fine.
+
+# Comments, bugs, suggestions send to chicken-users@nongnu.org
+
+# Patch written by John Lenz <lenz@cs.wisc.edu>
+
+--- tinyclos.scm.old	2005-04-05 01:13:56.000000000 -0500
++++ tinyclos.scm	2005-04-11 16:37:23.746181489 -0500
+@@ -37,8 +37,10 @@
+ 
+ (include "parameters")
+ 
++(cond-expand [(not chicken-compile-shared) (declare (unit tinyclos))]
++	     [else] )
++
+ (declare
+-  (unit tinyclos)
+   (uses extras)
+   (usual-integrations)
+   (fixnum) 
+@@ -234,7 +236,10 @@
+             y = C_block_item(y, 1);
+           }
+         }
+-        return(C_block_item(v, i + 1));
++        if (x == C_SCHEME_END_OF_LIST && y == C_SCHEME_END_OF_LIST)
++          return(C_block_item(v, i + 1));
++        else
++          goto mismatch;
+       }
+       else if(free_index == -1) free_index = i;
+     mismatch:
+@@ -438,7 +443,7 @@
+ (define hash-arg-list
+   (foreign-lambda* unsigned-int ((scheme-object args) (scheme-object svector)) "
+     C_word tag, h, x;
+-    int n, i, j;
++    int n, i, j, len = 0;
+     for(i = 0; args != C_SCHEME_END_OF_LIST; args = C_block_item(args, 1)) {
+       x = C_block_item(args, 0);
+       if(C_immediatep(x)) {
+@@ -481,8 +486,9 @@
+         default: i += 255;
+         }
+       }
++      ++len;
+     }
+-    return(i & (C_METHOD_CACHE_SIZE - 1));") )
++    return((i + len) & (C_METHOD_CACHE_SIZE - 1));") )
+ 
+ 
+ ;
+@@ -868,13 +874,27 @@
+     (##tinyclos#slot-set!
+      generic
+      'methods
+-     (cons method
+-	   (filter-in
+-	    (lambda (m) 
+-	      (let ([ms1 (method-specializers m)]
+-		    [ms2 (method-specializers method)] )
+-		(not (every2 (lambda (x y) (eq? x y)) ms1 ms2) ) ) )
+-	    (##tinyclos#slot-ref generic 'methods))))
++     (let* ([ms1 (method-specializers method)]
++	    [l1 (length ms1)] )
++       (let filter-in-method ([methods (##tinyclos#slot-ref generic 'methods)])
++	 (if (null? methods)
++	     (list method)
++	     (let* ([mm (##sys#slot methods 0)]
++		    [ms2 (method-specializers mm)]
++		    [l2 (length ms2)])
++	       (cond ((> l1 l2)
++		      (cons mm (filter-in-method (##sys#slot methods 1))))
++		     ((< l1 l2)
++		      (cons method methods))
++		     (else
++		      (let check-method ([ms1 ms1]
++					 [ms2 ms2])
++			(cond ((and (null? ms1) (null? ms2))
++			       (cons method (##sys#slot methods 1))) ;; skip the method already in the generic
++			      ((eq? (##sys#slot ms1 0) (##sys#slot ms2 0))
++			       (check-method (##sys#slot ms1 1) (##sys#slot ms2 1)))
++			      (else
++			       (cons mm (filter-in-method (##sys#slot methods 1)))))))))))))
+     (if (memq generic generic-invocation-generics)
+ 	(set! method-cache-tag (vector))
+ 	(%entity-cache-set! generic #f) )
+@@ -925,11 +945,13 @@
+ 				(memq (car args) generic-invocation-generics))
+ 			   (let ([proc 
+ 				  (method-procedure
++				    ; select the first method of one argument
+ 				   (let lp ([lis (generic-methods generic)])
+-				     (let ([tail (##sys#slot lis 1)])
+-				       (if (null? tail)
+-					   (##sys#slot lis 0)
+-					   (lp tail)) ) ) ) ] )
++				     (if (null? lis)
++				       (##sys#error "Unable to find original compute-apply-generic")
++				       (if (= (length (method-specializers (##sys#slot lis 0))) 1)
++					 (##sys#slot lis 0)
++					 (lp (##sys#slot lis 1)))))) ] )
+ 			     (lambda (args) (apply proc #f args)) )
+ 			   (let ([x (compute-apply-methods generic)]
+ 				 [y ((compute-methods generic) args)] )
+@@ -946,9 +968,13 @@
+       (lambda (args)
+ 	(let ([applicable
+ 	       (filter-in (lambda (method)
+-			    (every2 applicable?
+-				   (method-specializers method)
+-				   args))
++                            (let check-applicable ([list1 (method-specializers method)]
++                                                   [list2 args])
++                              (cond ((null? list1) #t)
++                                    ((null? list2) #f)
++                                    (else
++                                      (and (applicable? (##sys#slot list1 0) (##sys#slot list2 0))
++                                           (check-applicable (##sys#slot list1 1) (##sys#slot list2 1)))))))
+ 			  (generic-methods generic) ) ] )
+ 	  (if (or (null? applicable) (null? (##sys#slot applicable 1))) 
+ 	      applicable
+@@ -975,8 +1001,10 @@
+ 	   [else
+ 	    (cond ((and (null? specls1) (null? specls2))
+ 		   (##sys#error "two methods are equally specific" generic))
+-		  ((or (null? specls1) (null? specls2))
+-		   (##sys#error "two methods have different number of specializers" generic))
++		  ;((or (null? specls1) (null? specls2))
++		  ; (##sys#error "two methods have different number of specializers" generic))
++                  ((null? specls1) #f)
++                  ((null? specls2) #t)
+ 		  ((null? args)
+ 		   (##sys#error "fewer arguments than specializers" generic))
+ 		  (else
+@@ -1210,7 +1238,7 @@
+ (define <structure>      (make-primitive-class "structure"))
+ (define <procedure> (make-primitive-class "procedure" <procedure-class>))
+ (define <end-of-file> (make-primitive-class "end-of-file"))
+-(define <environment> (make-primitive-class "environment" <structure>))	; (Benedikt insisted on this)
++(define <environment> (make-primitive-class "environment" <structure>))
+ (define <hash-table> (make-primitive-class "hash-table" <structure>))
+ (define <promise> (make-primitive-class "promise" <structure>))
+ (define <queue> (make-primitive-class "queue" <structure>))
diff --git a/share/swig/2.0.11/chicken/typemaps.i b/share/swig/2.0.11/chicken/typemaps.i
new file mode 100644
index 0000000..fd587fd
--- /dev/null
+++ b/share/swig/2.0.11/chicken/typemaps.i
@@ -0,0 +1,314 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer handling
+ *
+ * These mappings provide support for input/output arguments and
+ * common uses for C/C++ pointers.  INOUT mappings allow for C/C++
+ * pointer variables in addition to input/output arguments.
+ * ----------------------------------------------------------------------------- */
+
+// INPUT typemaps.
+// These remap a C pointer to be an "INPUT" value which is passed by value
+// instead of reference.
+
+/* 
+The following methods can be applied to turn a pointer into a simple
+"input" value.  That is, instead of passing a pointer to an object,
+you would use a real value instead.
+
+         int            *INPUT
+         short          *INPUT
+         long           *INPUT
+	 long long      *INPUT
+         unsigned int   *INPUT
+         unsigned short *INPUT
+         unsigned long  *INPUT
+         unsigned long long *INPUT
+         unsigned char  *INPUT
+         char           *INPUT
+         bool           *INPUT
+         float          *INPUT
+         double         *INPUT
+         
+To use these, suppose you had a C function like this :
+
+        double fadd(double *a, double *b) {
+               return *a+*b;
+        }
+
+You could wrap it with SWIG as follows :
+        
+        %include <typemaps.i>
+        double fadd(double *INPUT, double *INPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INPUT { double *a, double *b };
+        double fadd(double *a, double *b);
+
+*/
+
+// OUTPUT typemaps.   These typemaps are used for parameters that
+// are output only.   The output value is appended to the result as
+// a list element.
+
+/* 
+The following methods can be applied to turn a pointer into an "output"
+value.  When calling a function, no input value would be given for
+a parameter, but an output value would be returned.  In the case of
+multiple output values, they are returned in the form of a Scheme list.
+
+         int            *OUTPUT
+         short          *OUTPUT
+         long           *OUTPUT
+         long long      *OUTPUT
+         unsigned int   *OUTPUT
+         unsigned short *OUTPUT
+         unsigned long  *OUTPUT
+         unsigned long long *OUTPUT
+         unsigned char  *OUTPUT
+         char           *OUTPUT
+         bool           *OUTPUT
+         float          *OUTPUT
+         double         *OUTPUT
+         
+For example, suppose you were trying to wrap the modf() function in the
+C math library which splits x into integral and fractional parts (and
+returns the integer part in one of its parameters).K:
+
+        double modf(double x, double *ip);
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double modf(double x, double *OUTPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *OUTPUT { double *ip };
+        double modf(double x, double *ip);
+
+*/
+
+//----------------------------------------------------------------------
+//
+// T_OUTPUT typemap (and helper function) to return multiple argouts as
+// a tuple instead of a list.
+//
+//----------------------------------------------------------------------
+
+// Simple types
+
+%define INOUT_TYPEMAP(type_, from_scheme, to_scheme, checker, convtype, storage_)
+
+%typemap(in) type_ *INPUT($*1_ltype temp), type_ &INPUT($*1_ltype temp)
+%{  if (!checker ($input)) {
+    swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'");
+  }
+  temp = ($*1_ltype) from_scheme ($input);
+  $1 = &temp; %}
+
+%typemap(typecheck) type_ *INPUT = type_;
+%typemap(typecheck) type_ &INPUT = type_;
+
+%typemap(in, numinputs=0) type_ *OUTPUT($*1_ltype temp), type_ &OUTPUT($*1_ltype temp)
+"  $1 = &temp;"
+
+#if "storage_" == "0"
+
+%typemap(argout) type_ *OUTPUT, type_ &OUTPUT 
+%{ 
+  if ($1 == NULL) {
+    swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Argument #$argnum must be non-null");
+  }
+  SWIG_APPEND_VALUE(to_scheme (convtype (*$1)));
+%}
+
+#else
+
+%typemap(argout) type_ *OUTPUT, type_ &OUTPUT 
+%{
+  {
+    C_word *known_space = C_alloc(storage_);
+    if ($1 == NULL) {
+      swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Variable '$1' must be non-null");
+    }
+    SWIG_APPEND_VALUE(to_scheme (&known_space, convtype (*$1)));
+  }
+%}
+
+#endif
+
+%enddef
+
+INOUT_TYPEMAP(int, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
+INOUT_TYPEMAP(enum SWIGTYPE, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
+INOUT_TYPEMAP(short, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
+INOUT_TYPEMAP(long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(long long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(unsigned int, C_num_to_unsigned_int, C_unsigned_int_to_num, C_swig_is_number, (int), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(unsigned short, C_num_to_unsigned_int, C_fix, C_swig_is_number, (unsigned int), 0);
+INOUT_TYPEMAP(unsigned long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(unsigned long long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(unsigned char, C_character_code, C_make_character, C_swig_is_char, (unsigned int), 0);
+INOUT_TYPEMAP(signed char, C_character_code, C_make_character, C_swig_is_char, (int), 0);
+INOUT_TYPEMAP(char, C_character_code, C_make_character, C_swig_is_char, (char), 0);
+INOUT_TYPEMAP(bool, C_truep, C_mk_bool, C_swig_is_bool, (bool), 0);
+INOUT_TYPEMAP(float, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
+INOUT_TYPEMAP(double, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
+
+// INOUT
+// Mappings for an argument that is both an input and output
+// parameter
+
+/*
+The following methods can be applied to make a function parameter both
+an input and output value.  This combines the behavior of both the
+"INPUT" and "OUTPUT" methods described earlier.  Output values are
+returned in the form of a CHICKEN tuple.  
+
+         int            *INOUT
+         short          *INOUT
+         long           *INOUT
+         long long      *INOUT
+         unsigned int   *INOUT
+         unsigned short *INOUT
+         unsigned long  *INOUT
+         unsigned long long *INOUT
+         unsigned char  *INOUT
+         char           *INOUT
+         bool           *INOUT
+         float          *INOUT
+         double         *INOUT
+         
+For example, suppose you were trying to wrap the following function :
+
+        void neg(double *x) {
+             *x = -(*x);
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        void neg(double *INOUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *x };
+        void neg(double *x);
+
+As well, you can wrap variables with :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *y };
+        extern double *y;
+
+Unlike C, this mapping does not directly modify the input value (since
+this makes no sense in CHICKEN).  Rather, the modified input value shows
+up as the return value of the function.  Thus, to apply this function
+to a CHICKEN variable you might do this :
+
+       x = neg(x)
+
+Note : previous versions of SWIG used the symbol 'BOTH' to mark
+input/output arguments.   This is still supported, but will be slowly
+phased out in future releases.
+
+*/
+
+%typemap(in) int *INOUT = int *INPUT;
+%typemap(in) enum SWIGTYPE *INOUT = enum SWIGTYPE *INPUT;
+%typemap(in) short *INOUT = short *INPUT;
+%typemap(in) long *INOUT = long *INPUT;
+%typemap(in) long long *INOUT = long long *INPUT;
+%typemap(in) unsigned *INOUT = unsigned *INPUT;
+%typemap(in) unsigned short *INOUT = unsigned short *INPUT;
+%typemap(in) unsigned long *INOUT = unsigned long *INPUT;
+%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
+%typemap(in) unsigned char *INOUT = unsigned char *INPUT;
+%typemap(in) char *INOUT = char *INPUT;
+%typemap(in) bool *INOUT = bool *INPUT;
+%typemap(in) float *INOUT = float *INPUT;
+%typemap(in) double *INOUT = double *INPUT;
+
+%typemap(in) int &INOUT = int &INPUT;
+%typemap(in) enum SWIGTYPE &INOUT = enum SWIGTYPE &INPUT;
+%typemap(in) short &INOUT = short &INPUT;
+%typemap(in) long &INOUT = long &INPUT;
+%typemap(in) long long &INOUT = long long &INPUT;
+%typemap(in) unsigned &INOUT = unsigned &INPUT;
+%typemap(in) unsigned short &INOUT = unsigned short &INPUT;
+%typemap(in) unsigned long &INOUT = unsigned long &INPUT;
+%typemap(in) unsigned long long &INOUT = unsigned long long &INPUT;
+%typemap(in) unsigned char &INOUT = unsigned char &INPUT;
+%typemap(in) char &INOUT = char &INPUT;
+%typemap(in) bool &INOUT = bool &INPUT;
+%typemap(in) float &INOUT = float &INPUT;
+%typemap(in) double &INOUT = double &INPUT;
+
+%typemap(argout) int *INOUT = int *OUTPUT;
+%typemap(argout) enum SWIGTYPE *INOUT = enum SWIGTYPE *OUTPUT;
+%typemap(argout) short *INOUT = short *OUTPUT;
+%typemap(argout) long *INOUT = long *OUTPUT;
+%typemap(argout) long long *INOUT = long long *OUTPUT;
+%typemap(argout) unsigned *INOUT = unsigned *OUTPUT;
+%typemap(argout) unsigned short *INOUT = unsigned short *OUTPUT;
+%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
+%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
+%typemap(argout) bool *INOUT = bool *OUTPUT;
+%typemap(argout) float *INOUT = float *OUTPUT;
+%typemap(argout) double *INOUT = double *OUTPUT;
+
+%typemap(argout) int &INOUT = int &OUTPUT;
+%typemap(argout) enum SWIGTYPE &INOUT = enum SWIGTYPE &OUTPUT;
+%typemap(argout) short &INOUT = short &OUTPUT;
+%typemap(argout) long &INOUT = long &OUTPUT;
+%typemap(argout) long long &INOUT = long long &OUTPUT;
+%typemap(argout) unsigned &INOUT = unsigned &OUTPUT;
+%typemap(argout) unsigned short &INOUT = unsigned short &OUTPUT;
+%typemap(argout) unsigned long &INOUT = unsigned long &OUTPUT;
+%typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT;
+%typemap(argout) unsigned char &INOUT = unsigned char &OUTPUT;
+%typemap(argout) char &INOUT = char &OUTPUT;
+%typemap(argout) bool &INOUT = bool &OUTPUT;
+%typemap(argout) float &INOUT = float &OUTPUT;
+%typemap(argout) double &INOUT = double &OUTPUT;
+
+/* Overloading information */
+
+%typemap(typecheck) double *INOUT = double;
+%typemap(typecheck) bool *INOUT = bool;
+%typemap(typecheck) char *INOUT = char;
+%typemap(typecheck) signed char *INOUT = signed char;
+%typemap(typecheck) unsigned char *INOUT = unsigned char;
+%typemap(typecheck) unsigned long *INOUT = unsigned long;
+%typemap(typecheck) unsigned long long *INOUT = unsigned long long;
+%typemap(typecheck) unsigned short *INOUT = unsigned short;
+%typemap(typecheck) unsigned int *INOUT = unsigned int;
+%typemap(typecheck) long *INOUT = long;
+%typemap(typecheck) long long *INOUT = long long;
+%typemap(typecheck) short *INOUT = short;
+%typemap(typecheck) int *INOUT = int;
+%typemap(typecheck) enum SWIGTYPE *INOUT = enum SWIGTYPE;
+%typemap(typecheck) float *INOUT = float;
+
+%typemap(typecheck) double &INOUT = double;
+%typemap(typecheck) bool &INOUT = bool;
+%typemap(typecheck) char &INOUT = char;
+%typemap(typecheck) signed char &INOUT = signed char;
+%typemap(typecheck) unsigned char &INOUT = unsigned char;
+%typemap(typecheck) unsigned long &INOUT = unsigned long;
+%typemap(typecheck) unsigned long long &INOUT = unsigned long long;
+%typemap(typecheck) unsigned short &INOUT = unsigned short;
+%typemap(typecheck) unsigned int &INOUT = unsigned int;
+%typemap(typecheck) long &INOUT = long;
+%typemap(typecheck) long long &INOUT = long long;
+%typemap(typecheck) short &INOUT = short;
+%typemap(typecheck) int &INOUT = int;
+%typemap(typecheck) enum SWIGTYPE &INOUT = enum SWIGTYPE;
+%typemap(typecheck) float &INOUT = float;
diff --git a/share/swig/2.0.11/clisp/clisp.swg b/share/swig/2.0.11/clisp/clisp.swg
new file mode 100644
index 0000000..e1d330c
--- /dev/null
+++ b/share/swig/2.0.11/clisp/clisp.swg
@@ -0,0 +1,32 @@
+/* -----------------------------------------------------------------------------
+ * clisp.swg
+ * ----------------------------------------------------------------------------- */
+
+/* Define a C preprocessor symbol that can be used in interface files
+   to distinguish between the SWIG language modules. */ 
+
+#define SWIG_CLISP
+
+/* Typespecs for basic types. */
+
+%typemap(in) void "NIL";
+
+%typemap(in) char "character";
+%typemap(in) char * "ffi:c-string";
+%typemap(in) unsigned char "ffi:uchar";
+%typemap(in) signed char "ffi:char";
+
+%typemap(in) short "ffi:short";
+%typemap(in) signed short "ffi:short";
+%typemap(in) unsigned short "ffi:ushort";
+
+%typemap(in) int "ffi:int";
+%typemap(in) signed int "ffi:int";
+%typemap(in) unsigned int "ffi:uint";
+
+%typemap(in) long "ffi:long";
+%typemap(in) signed long "ffi:long";
+%typemap(in) unsigned long "ffi:ulong";
+
+%typemap(in) float "SINGLE-FLOAT";
+%typemap(in) double "DOUBLE-FLOAT";
diff --git a/share/swig/2.0.11/cmalloc.i b/share/swig/2.0.11/cmalloc.i
new file mode 100644
index 0000000..9f58bc0
--- /dev/null
+++ b/share/swig/2.0.11/cmalloc.i
@@ -0,0 +1,110 @@
+/* -----------------------------------------------------------------------------
+ * cmalloc.i
+ *
+ * SWIG library file containing macros that can be used to create objects using
+ * the C malloc function.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <stdlib.h>
+%}
+
+/* %malloc(TYPE [, NAME = TYPE])
+   %calloc(TYPE [, NAME = TYPE])
+   %realloc(TYPE [, NAME = TYPE])
+   %free(TYPE [, NAME = TYPE])
+   %allocators(TYPE [,NAME = TYPE])
+
+   Creates functions for allocating/reallocating memory.
+
+   TYPE *malloc_NAME(int nbytes = sizeof(TYPE);
+   TYPE *calloc_NAME(int nobj=1, int size=sizeof(TYPE));
+   TYPE *realloc_NAME(TYPE *ptr, int nbytes);
+   void free_NAME(TYPE *ptr);
+
+*/
+
+%define %malloc(TYPE,NAME...)
+#if #NAME != ""
+%rename(malloc_##NAME) ::malloc(int nbytes);
+#else
+%rename(malloc_##TYPE) ::malloc(int nbytes);
+#endif
+
+#if #TYPE != "void"
+%typemap(default) int nbytes "$1 = (int) sizeof(TYPE);"
+#endif
+TYPE *malloc(int nbytes);
+%typemap(default) int nbytes;
+%enddef
+
+%define %calloc(TYPE,NAME...)
+#if #NAME != ""
+%rename(calloc_##NAME) ::calloc(int nobj, int sz);
+#else
+%rename(calloc_##TYPE) ::calloc(int nobj, int sz);
+#endif
+#if #TYPE != "void"
+%typemap(default) int sz "$1 = (int) sizeof(TYPE);"
+#else
+%typemap(default) int sz "$1 = 1;"
+#endif
+%typemap(default) int nobj "$1 = 1;"
+TYPE *calloc(int nobj, int sz);
+%typemap(default) int sz;
+%typemap(default) int nobj;
+%enddef
+
+%define %realloc(TYPE,NAME...)
+%insert("header") {
+#if #NAME != ""
+TYPE *realloc_##NAME(TYPE *ptr, int nitems)
+#else
+TYPE *realloc_##TYPE(TYPE *ptr, int nitems)
+#endif
+{
+#if #TYPE != "void"
+return (TYPE *) realloc(ptr, nitems*sizeof(TYPE));
+#else
+return (TYPE *) realloc(ptr, nitems);
+#endif
+}
+}
+#if #NAME != ""
+TYPE *realloc_##NAME(TYPE *ptr, int nitems);
+#else
+TYPE *realloc_##TYPE(TYPE *ptr, int nitems);
+#endif
+%enddef
+
+%define %free(TYPE,NAME...)
+#if #NAME != ""
+%rename(free_##NAME) ::free(TYPE *ptr);
+#else
+%rename(free_##TYPE) ::free(TYPE *ptr);
+#endif
+void free(TYPE *ptr);
+%enddef
+
+%define %sizeof(TYPE,NAME...)
+#if #NAME != ""
+%constant int sizeof_##NAME = sizeof(TYPE);
+#else
+%constant int sizeof_##TYPE = sizeof(TYPE);
+#endif
+%enddef
+
+%define %allocators(TYPE,NAME...)
+%malloc(TYPE,NAME)
+%calloc(TYPE,NAME)
+%realloc(TYPE,NAME)
+%free(TYPE,NAME)
+#if #TYPE != "void"
+%sizeof(TYPE,NAME)
+#endif
+%enddef
+
+
+
+
+
diff --git a/share/swig/2.0.11/constraints.i b/share/swig/2.0.11/constraints.i
new file mode 100644
index 0000000..8bc7f91
--- /dev/null
+++ b/share/swig/2.0.11/constraints.i
@@ -0,0 +1,224 @@
+/* -----------------------------------------------------------------------------
+ * constraints.i
+ *
+ * SWIG constraints library.
+ *
+ * SWIG library file containing typemaps for implementing various kinds of 
+ * constraints.  Depends upon the SWIG exception library for generating
+ * errors in a language-independent manner.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef AUTODOC
+%text %{
+%include <constraints.i>
+
+This library provides support for applying constraints to function
+arguments.  Using a constraint, you can restrict arguments to be
+positive numbers, non-NULL pointers, and so on.   The following
+constraints are available :
+
+      Number  POSITIVE        - Positive number (not zero)
+      Number  NEGATIVE        - Negative number (not zero)
+      Number  NONZERO         - Nonzero number
+      Number  NONNEGATIVE     - Positive number (including zero)
+      Number  NONPOSITIVE     - Negative number (including zero)
+      Pointer NONNULL         - Non-NULL pointer
+      Pointer ALIGN8          - 8-byte aligned pointer
+      Pointer ALIGN4          - 4-byte aligned pointer
+      Pointer ALIGN2          - 2-byte aligned pointer
+
+To use the constraints, you need to "apply" them to specific
+function arguments in your code.  This is done using the %apply
+directive.   For example :
+
+  %apply Number NONNEGATIVE { double nonneg };
+  double sqrt(double nonneg);         // Name of argument must match
+  
+  %apply Pointer NONNULL { void *ptr };
+  void *malloc(int POSITIVE);       // May return a NULL pointer
+  void free(void *ptr);             // May not accept a NULL pointer
+
+Any function argument of the type you specify with the %apply directive
+will be checked with the appropriate constraint.   Multiple types may
+be specified as follows :
+
+  %apply Pointer NONNULL { void *, Vector *, List *, double *};
+
+In this case, all of the types listed would be checked for non-NULL 
+pointers.
+
+The common datatypes of int, short, long, unsigned int, unsigned long,
+unsigned short, unsigned char, signed char, float, and double can be
+checked without using the %apply directive by simply using the 
+constraint name as the parameter name. For example :
+
+  double sqrt(double NONNEGATIVE);
+  double log(double POSITIVE);
+
+If you have used typedef to change type-names, you can also do this :
+
+  %apply double { Real };       // Make everything defined for doubles
+                                // work for Reals.
+  Real sqrt(Real NONNEGATIVE);
+  Real log(Real POSITIVE);
+
+%}
+#endif
+
+%include <exception.i>
+
+#ifdef SWIGCSHARP
+// Required attribute for C# exception handling
+#define SWIGCSHARPCANTHROW , canthrow=1
+#else
+#define SWIGCSHARPCANTHROW
+#endif
+
+
+// Positive numbers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                int               POSITIVE,
+                short             POSITIVE,
+                long              POSITIVE,
+                unsigned int      POSITIVE,
+                unsigned short    POSITIVE,
+                unsigned long     POSITIVE,
+                signed char       POSITIVE,
+                unsigned char     POSITIVE,
+                float             POSITIVE,
+                double            POSITIVE,
+                Number            POSITIVE
+{
+  if ($1 <= 0) {
+    SWIG_exception(SWIG_ValueError,"Expected a positive value.");
+  }
+}
+
+// Negative numbers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                int               NEGATIVE,
+                short             NEGATIVE,
+                long              NEGATIVE,
+                unsigned int      NEGATIVE,
+                unsigned short    NEGATIVE,
+                unsigned long     NEGATIVE,
+                signed char       NEGATIVE,
+                unsigned char     NEGATIVE,
+                float             NEGATIVE,
+                double            NEGATIVE,
+                Number            NEGATIVE
+{
+  if ($1 >= 0) {
+    SWIG_exception(SWIG_ValueError,"Expected a negative value.");
+  }
+}
+
+// Nonzero numbers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                int               NONZERO,
+                short             NONZERO,
+                long              NONZERO,
+                unsigned int      NONZERO,
+                unsigned short    NONZERO,
+                unsigned long     NONZERO,
+                signed char       NONZERO,
+                unsigned char     NONZERO,
+                float             NONZERO,
+                double            NONZERO,
+                Number            NONZERO
+{
+  if ($1 == 0) {
+    SWIG_exception(SWIG_ValueError,"Expected a nonzero value.");
+  }
+}
+
+// Nonnegative numbers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                int               NONNEGATIVE,
+                short             NONNEGATIVE,
+                long              NONNEGATIVE,
+                unsigned int      NONNEGATIVE,
+                unsigned short    NONNEGATIVE,
+                unsigned long     NONNEGATIVE,
+                signed char       NONNEGATIVE,
+                unsigned char     NONNEGATIVE,
+                float             NONNEGATIVE,
+                double            NONNEGATIVE,
+                Number            NONNEGATIVE
+{
+  if ($1 < 0) {
+    SWIG_exception(SWIG_ValueError,"Expected a non-negative value.");
+  }
+}
+
+// Nonpositive numbers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                int               NONPOSITIVE,
+                short             NONPOSITIVE,
+                long              NONPOSITIVE,
+                unsigned int      NONPOSITIVE,
+                unsigned short    NONPOSITIVE,
+                unsigned long     NONPOSITIVE,
+                signed char       NONPOSITIVE,
+                unsigned char     NONPOSITIVE,
+                float             NONPOSITIVE,
+                double            NONPOSITIVE,
+                Number            NONPOSITIVE
+{
+  if ($1 > 0) {
+    SWIG_exception(SWIG_ValueError,"Expected a non-positive value.");
+  }
+}
+                
+// Non-NULL pointer
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                void *            NONNULL,
+                Pointer           NONNULL
+{
+  if (!$1) {
+    SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+  }
+}
+
+// Aligned pointers
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                void *            ALIGN8,
+                Pointer           ALIGN8
+{
+   unsigned long long tmp;
+   tmp = (unsigned long long) $1;
+   if (tmp & 7) {
+     SWIG_exception(SWIG_ValueError,"Pointer must be 8-byte aligned.");
+   }
+}
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                void *            ALIGN4,
+                Pointer           ALIGN4
+{
+   unsigned long long tmp;
+   tmp = (unsigned long long) $1;
+   if (tmp & 3) {
+     SWIG_exception(SWIG_ValueError,"Pointer must be 4-byte aligned.");
+   }
+}
+
+%typemap(check SWIGCSHARPCANTHROW) 
+                void *            ALIGN2,
+                Pointer           ALIGN2
+{
+   unsigned long long tmp;
+   tmp = (unsigned long long) $1;
+   if (tmp & 1) {
+     SWIG_exception(SWIG_ValueError,"Pointer must be 2-byte aligned.");
+   }
+}
+
+
diff --git a/share/swig/2.0.11/cpointer.i b/share/swig/2.0.11/cpointer.i
new file mode 100644
index 0000000..881c511
--- /dev/null
+++ b/share/swig/2.0.11/cpointer.i
@@ -0,0 +1,180 @@
+/* -----------------------------------------------------------------------------
+ * cpointer.i
+ *
+ * SWIG library file containing macros that can be used to manipulate simple
+ * pointer objects.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %pointer_class(type,name)
+ *
+ * Places a simple proxy around a simple type like 'int', 'float', or whatever.
+ * The proxy provides this interface:
+ *
+ *       class type {
+ *       public:
+ *           type();
+ *          ~type();
+ *           type value();
+ *           void assign(type value);
+ *       };
+ *         
+ * Example:
+ *
+ *    %pointer_class(int, intp);
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = intp()
+ *    >>> a.assign(10)
+ *    >>> a.value()
+ *    10
+ *    >>> b = intp()
+ *    >>> b.assign(20)
+ *    >>> print add(a,b)
+ *    30
+ *
+ * As a general rule, this macro should not be used on class/structures that
+ * are already defined in the interface.
+ * ----------------------------------------------------------------------------- */
+
+
+%define %pointer_class(TYPE, NAME)
+%{
+typedef TYPE NAME;
+%}
+
+typedef struct {
+} NAME;
+
+%extend NAME {
+#ifdef __cplusplus
+NAME() {
+  return new TYPE();
+}
+~NAME() {
+  if ($self) delete $self;
+}
+#else
+NAME() {
+  return (TYPE *) calloc(1,sizeof(TYPE));
+}
+~NAME() {
+  if ($self) free($self);
+}
+#endif
+}
+
+%extend NAME {
+
+void assign(TYPE value) {
+  *$self = value;
+}
+TYPE value() {
+  return *$self;
+}
+TYPE * cast() {
+  return $self;
+}
+static NAME * frompointer(TYPE *t) {
+  return (NAME *) t;
+}
+
+}
+
+%types(NAME = TYPE);
+
+%enddef
+
+/* ----------------------------------------------------------------------------- 
+ * %pointer_functions(type,name)
+ *
+ * Create functions for allocating/deallocating pointers.   This can be used
+ * if you don't want to create a proxy class or if the pointer is complex.
+ *
+ *    %pointer_functions(int, intp)
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = copy_intp(10)
+ *    >>> intp_value(a)
+ *    10
+ *    >>> b = new_intp()
+ *    >>> intp_assign(b,20)
+ *    >>> print add(a,b)
+ *    30
+ *    >>> delete_intp(a)
+ *    >>> delete_intp(b)
+ * 
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME() { %}
+#ifdef __cplusplus
+%{  return new TYPE(); %}
+#else
+%{  return (TYPE *) calloc(1,sizeof(TYPE)); %}
+#endif
+%{}
+
+static TYPE *copy_##NAME(TYPE value) { %}
+#ifdef __cplusplus
+%{  return new TYPE(value); %}
+#else
+%{  TYPE *obj = (TYPE *) calloc(1,sizeof(TYPE));
+  *obj = value;
+  return obj; %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *obj) { %}
+#ifdef __cplusplus
+%{  if (obj) delete obj; %}
+#else
+%{  if (obj) free(obj); %}
+#endif
+%{}
+
+static void NAME ##_assign(TYPE *obj, TYPE value) {
+  *obj = value;
+}
+
+static TYPE NAME ##_value(TYPE *obj) {
+  return *obj;
+}
+%}
+
+TYPE *new_##NAME();
+TYPE *copy_##NAME(TYPE value);
+void  delete_##NAME(TYPE *obj);
+void  NAME##_assign(TYPE *obj, TYPE value);
+TYPE  NAME##_value(TYPE *obj);
+
+%enddef
+
+/* -----------------------------------------------------------------------------
+ * %pointer_cast(type1,type2,name)
+ *
+ * Generates a pointer casting function.
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_cast(TYPE1,TYPE2,NAME)
+%inline %{
+TYPE2 NAME(TYPE1 x) {
+   return (TYPE2) x;
+}
+%}
+%enddef
+
+
+
+
+
+
+
+
diff --git a/share/swig/2.0.11/csharp/arrays_csharp.i b/share/swig/2.0.11/csharp/arrays_csharp.i
new file mode 100644
index 0000000..513330e
--- /dev/null
+++ b/share/swig/2.0.11/csharp/arrays_csharp.i
@@ -0,0 +1,137 @@
+/* -----------------------------------------------------------------------------
+ * arrays_csharp.i
+ *
+ * This file contains a two approaches to marshaling arrays. The first uses
+ * default p/invoke marshaling and the second uses pinning of the arrays.
+ *
+ * Default marshaling approach
+ * ----------------------------
+ * Array typemaps using default p/invoke marshaling. The data is copied to a separately
+ * allocated buffer when passing over the managed-native boundary.
+ * 
+ * There are separate typemaps for in, out and inout arrays to enable avoiding 
+ * unnecessary copying.
+ * 
+ * Example usage:
+ *
+ *   %include "arrays_csharp.i"
+ *   %apply int INPUT[]  { int* sourceArray }
+ *   %apply int OUTPUT[] { int* targetArray }
+ *   void myArrayCopy( int* sourceArray, int* targetArray, int nitems );
+ *
+ *   %apply int INOUT[] { int* array1, int *array2 }
+ *   void myArraySwap( int* array1, int* array2, int nitems );
+ *
+ * If handling large arrays you should consider using the pinning array typemaps
+ * described next.
+ *
+ * Pinning approach
+ * ----------------
+ * Array typemaps using pinning. These typemaps pin the managed array given
+ * as parameter and pass a pointer to it to the c/c++ side. This is very
+ * efficient as no copying is done (unlike in the default array marshaling),
+ * but it makes garbage collection more difficult. When considering using
+ * these typemaps, think carefully whether you have callbacks that may cause
+ * the control to re-enter the managed side from within the call (and produce
+ * garbage for the gc) or whether other threads may produce enough garbage to 
+ * trigger gc while the call is being executed. In those cases it may be
+ * wiser to use the default marshaling typemaps.
+ * 
+ * Please note that when using fixed arrays, you have to mark your corresponding 
+ * module class method unsafe using 
+ * %csmethodmodifiers "public unsafe"
+ * (the visibility of the method is up to you).
+ *
+ * Example usage:
+ *
+ *   %include "arrays_csharp.i"
+ *   %apply int FIXED[] { int* sourceArray, int *targetArray }
+ *   %csmethodmodifiers myArrayCopy "public unsafe";
+ *   void myArrayCopy( int *sourceArray, int* targetArray, int nitems );
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define CSHARP_ARRAYS( CTYPE, CSTYPE )
+
+// input only arrays
+
+%typemap(ctype)   CTYPE INPUT[] "CTYPE*"
+%typemap(cstype)  CTYPE INPUT[] "CSTYPE[]"
+%typemap(imtype, inattributes="[In, MarshalAs(UnmanagedType.LPArray)]") CTYPE INPUT[] "CSTYPE[]"
+%typemap(csin)    CTYPE INPUT[] "$csinput"
+
+%typemap(in)      CTYPE INPUT[] "$1 = $input;"
+%typemap(freearg) CTYPE INPUT[] ""
+%typemap(argout)  CTYPE INPUT[] ""
+
+// output only arrays
+
+%typemap(ctype)   CTYPE OUTPUT[] "CTYPE*"
+%typemap(cstype)  CTYPE OUTPUT[] "CSTYPE[]"
+%typemap(imtype, inattributes="[Out, MarshalAs(UnmanagedType.LPArray)]") CTYPE OUTPUT[] "CSTYPE[]"
+%typemap(csin)    CTYPE OUTPUT[] "$csinput"
+
+%typemap(in)      CTYPE OUTPUT[] "$1 = $input;"
+%typemap(freearg) CTYPE OUTPUT[] ""
+%typemap(argout)  CTYPE OUTPUT[] ""
+
+// inout arrays
+
+%typemap(ctype)   CTYPE INOUT[] "CTYPE*"
+%typemap(cstype)  CTYPE INOUT[] "CSTYPE[]"
+%typemap(imtype, inattributes="[In, Out, MarshalAs(UnmanagedType.LPArray)]") CTYPE INOUT[] "CSTYPE[]"
+%typemap(csin)    CTYPE INOUT[] "$csinput"
+
+%typemap(in)      CTYPE INOUT[] "$1 = $input;"
+%typemap(freearg) CTYPE INOUT[] ""
+%typemap(argout)  CTYPE INOUT[] ""
+
+%enddef // CSHARP_ARRAYS
+
+CSHARP_ARRAYS(signed char, sbyte)
+CSHARP_ARRAYS(unsigned char, byte)
+CSHARP_ARRAYS(short, short)
+CSHARP_ARRAYS(unsigned short, ushort)
+CSHARP_ARRAYS(int, int)
+CSHARP_ARRAYS(unsigned int, uint)
+// FIXME - on Unix 64 bit, long is 8 bytes but is 4 bytes on Windows 64 bit.
+//         How can this be handled sensibly?
+//         See e.g. http://www.xml.com/ldd/chapter/book/ch10.html
+CSHARP_ARRAYS(long, int)
+CSHARP_ARRAYS(unsigned long, uint)
+CSHARP_ARRAYS(long long, long)
+CSHARP_ARRAYS(unsigned long long, ulong)
+CSHARP_ARRAYS(float, float)
+CSHARP_ARRAYS(double, double)
+
+
+%define CSHARP_ARRAYS_FIXED( CTYPE, CSTYPE )
+
+%typemap(ctype)   CTYPE FIXED[] "CTYPE*"
+%typemap(imtype)  CTYPE FIXED[] "IntPtr"
+%typemap(cstype)  CTYPE FIXED[] "CSTYPE[]"
+%typemap(csin,
+           pre=       "    fixed ( CSTYPE* swig_ptrTo_$csinput = $csinput ) {",
+           terminator="    }") 
+                  CTYPE FIXED[] "(IntPtr)swig_ptrTo_$csinput"
+
+%typemap(in)      CTYPE FIXED[] "$1 = $input;"
+%typemap(freearg) CTYPE FIXED[] ""
+%typemap(argout)  CTYPE FIXED[] ""
+
+
+%enddef // CSHARP_ARRAYS_FIXED
+
+CSHARP_ARRAYS_FIXED(signed char, sbyte)
+CSHARP_ARRAYS_FIXED(unsigned char, byte)
+CSHARP_ARRAYS_FIXED(short, short)
+CSHARP_ARRAYS_FIXED(unsigned short, ushort)
+CSHARP_ARRAYS_FIXED(int, int)
+CSHARP_ARRAYS_FIXED(unsigned int, uint)
+CSHARP_ARRAYS_FIXED(long, int)
+CSHARP_ARRAYS_FIXED(unsigned long, uint)
+CSHARP_ARRAYS_FIXED(long long, long)
+CSHARP_ARRAYS_FIXED(unsigned long long, ulong)
+CSHARP_ARRAYS_FIXED(float, float)
+CSHARP_ARRAYS_FIXED(double, double)
+
diff --git a/share/swig/2.0.11/csharp/boost_intrusive_ptr.i b/share/swig/2.0.11/csharp/boost_intrusive_ptr.i
new file mode 100644
index 0000000..09a1647
--- /dev/null
+++ b/share/swig/2.0.11/csharp/boost_intrusive_ptr.i
@@ -0,0 +1,511 @@
+// Users can provide their own SWIG_INTRUSIVE_PTR_TYPEMAPS or SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP macros before including this file to change the

+// visibility of the constructor and getCPtr method if desired to public if using multiple modules.

+#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS

+#define SWIG_INTRUSIVE_PTR_TYPEMAPS(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(internal, internal, CONST, TYPE)

+#endif

+#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP

+#define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(internal, internal, CONST, TYPE)

+#endif

+

+%include <intrusive_ptr.i>

+

+// Language specific macro implementing all the customisations for handling the smart pointer

+%define SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, CONST, TYPE...)

+

+// %naturalvar is as documented for member variables

+%naturalvar TYPE;

+%naturalvar SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >;

+

+// destructor wrapper customisation

+%feature("unref") TYPE "(void)arg1; delete smartarg1;"

+

+// Typemap customisations...

+

+%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

+  // plain value

+  argp = (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0;

+  if (!argp) {

+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);

+    return $null;

+  }

+  $1 = *argp; 

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter") CONST TYPE %{ 

+  //plain value(out)

+  $1_ltype* resultp = new $1_ltype(($1_ltype &)$1);

+  intrusive_ptr_add_ref(resultp);

+  *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(resultp, SWIG_intrusive_deleter< CONST TYPE >()); 

+%}

+

+%typemap(in, canthrow=1) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

+  // plain pointer

+  smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input;

+  $1 = (TYPE *)(smartarg ? smartarg->get() : 0); 

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") CONST TYPE * %{

+  //plain pointer(out)

+  #if ($owner)

+  if ($1) {

+    intrusive_ptr_add_ref($1);

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1, SWIG_intrusive_deleter< CONST TYPE >());  

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  }

+  #else

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;

+  #endif

+%}

+

+%typemap(in, canthrow=1) CONST TYPE & (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

+  // plain reference

+  $1 = ($1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);

+  if(!$1) {

+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type reference is null", 0);

+    return $null;

+  } 

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") CONST TYPE & %{ 

+  //plain reference(out)

+  #if ($owner)

+  if ($1) {

+    intrusive_ptr_add_ref($1);

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1, SWIG_intrusive_deleter< CONST TYPE >());  

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  } 

+  #else

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;

+  #endif

+%}

+

+%typemap(in) TYPE *CONST& ($*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{ 

+  // plain pointer by reference

+  temp = ($*1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);

+  $1 = &temp; 

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") TYPE *CONST& %{ 

+  // plain pointer by reference(out)

+  #if ($owner)

+  if (*$1) {

+    intrusive_ptr_add_ref(*$1);

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1, SWIG_intrusive_deleter< CONST TYPE >());  

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  } 

+  #else

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_0);

+  #endif

+%}

+

+%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * smartarg) %{ 

+  // intrusive_ptr by value

+  smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input;

+  if (smartarg) {

+    $1 = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true); 

+  }

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > %{ 

+  if ($1) {

+    intrusive_ptr_add_ref($1.get());

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1.get(), SWIG_intrusive_deleter< CONST TYPE >());

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0; 

+  }

+%}

+

+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast ($&1_type smartarg) %{

+  // shared_ptr by value

+  smartarg = *($&1_ltype*)&$input; 

+  if (smartarg) $1 = *smartarg; 

+%}

+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > ANY_TYPE_SWIGSharedPtrUpcast %{ 

+  *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; 

+%}

+

+%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & ($*1_ltype tempnull, $*1_ltype temp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * smartarg) %{ 

+  // intrusive_ptr by reference

+  if ( $input ) {

+    smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input; 

+    temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);

+    $1 = &temp;

+  } else {

+    $1 = &tempnull;

+  }

+%}

+%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & %{

+  delete &($1);

+  if ($self) {

+    SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * temp = new SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(*$input);

+    $1 = *temp;

+  }

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & %{ 

+  if (*$1) {

+    intrusive_ptr_add_ref($1->get());

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1->get(), SWIG_intrusive_deleter< CONST TYPE >());

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  }

+%} 

+

+%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * ($*1_ltype tempnull, $*1_ltype temp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * smartarg) %{ 

+  // intrusive_ptr by pointer

+  if ( $input ) {

+    smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input; 

+    temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);

+    $1 = &temp; 

+  } else {

+    $1 = &tempnull;

+  }

+%}

+%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * %{

+  delete $1;

+  if ($self) $1 = new SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(*$input);

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * %{ 

+  if ($1 && *$1) {

+    intrusive_ptr_add_ref($1->get());

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1->get(), SWIG_intrusive_deleter< CONST TYPE >());

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  }

+  if ($owner) delete $1; 

+%}

+

+%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& (SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > temp, $*1_ltype tempp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * smartarg) %{ 

+  // intrusive_ptr by pointer reference

+  smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input;

+  if ($input) {

+    temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);

+  }

+  tempp = &temp;

+  $1 = &tempp;

+%}

+%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& %{

+  if ($self) $1 = *$input;

+%}

+%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& %{ 

+  if (*$1 && **$1) {

+    intrusive_ptr_add_ref((*$1)->get());

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >((*$1)->get(), SWIG_intrusive_deleter< CONST TYPE >());

+  } else {

+    *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;

+  }

+%} 

+

+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug

+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{

+#error "typemaps for $1_type not available"

+%}

+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{

+#error "typemaps for $1_type not available"

+%}

+

+

+%typemap (ctype)    SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,

+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "void *"

+%typemap (imtype, out="IntPtr")  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >, 

+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "HandleRef"

+%typemap (cstype) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,

+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,

+                  SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "$typemap(cstype, TYPE)"

+%typemap(csin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,

+                 SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,

+                 SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,

+                 SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,

+                 SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "$typemap(cstype, TYPE).getCPtr($csinput)"

+

+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret; 

+  }

+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret;

+  }

+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret; 

+  }

+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret; 

+  }

+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret; 

+  }

+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > %{

+    get {

+      $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode

+      return ret;

+    } %}

+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >& %{

+    get {

+      $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode

+      return ret;

+    } %}

+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >* %{

+    get {

+      $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode

+      return ret;

+    } %}

+

+

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE {

+    $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode

+    return ret;

+  }

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE & {

+    $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode

+    return ret;

+  }

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE * {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret;

+  }

+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {

+    IntPtr cPtr = $imcall;

+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode

+    return ret;

+  }

+

+// Base proxy classes

+%typemap(csbody) TYPE %{

+  private HandleRef swigCPtr;

+  private bool swigCMemOwnBase;

+

+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {

+    swigCMemOwnBase = cMemoryOwn;

+    swigCPtr = new HandleRef(this, cPtr);

+  }

+

+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {

+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;

+  }

+%}

+

+// Derived proxy classes

+%typemap(csbody_derived) TYPE %{

+  private HandleRef swigCPtr;

+  private bool swigCMemOwnDerived;

+

+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {

+    swigCMemOwnDerived = cMemoryOwn;

+    swigCPtr = new HandleRef(this, cPtr);

+  }

+

+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {

+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;

+  }

+%}

+

+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {

+    lock(this) {

+      if (swigCPtr.Handle != IntPtr.Zero) {

+        if (swigCMemOwnBase) {

+          swigCMemOwnBase = false;

+          $imcall;

+        }

+        swigCPtr = new HandleRef(null, IntPtr.Zero);

+      }

+      GC.SuppressFinalize(this);

+    }

+  }

+

+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {

+    lock(this) {

+      if (swigCPtr.Handle != IntPtr.Zero) {

+        if (swigCMemOwnDerived) {

+          swigCMemOwnDerived = false;

+          $imcall;

+        }

+        swigCPtr = new HandleRef(null, IntPtr.Zero);

+      }

+      GC.SuppressFinalize(this);

+      base.Dispose();

+    }

+  }

+

+// CONST version needed ???? also for C#

+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "HandleRef"

+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "HandleRef"

+

+

+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;

+%template() SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >;

+%enddef

+

+

+/////////////////////////////////////////////////////////////////////

+

+

+%include <shared_ptr.i>

+

+%define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, CONST, TYPE...)

+

+%naturalvar TYPE;

+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;

+

+// destructor mods

+%feature("unref") TYPE "(void)arg1; delete smartarg1;"

+

+

+// plain value

+%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0) %{

+  argp = (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0;

+  if (!argp) {

+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);

+    return $null;

+  }

+  $1 = *argp; %}

+%typemap(out) CONST TYPE 

+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}

+

+// plain pointer

+%typemap(in) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

+  smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input;

+  $1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}

+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{

+  *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;

+%}

+

+// plain reference

+%typemap(in, canthrow=1) CONST TYPE & %{

+  $1 = ($1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);

+  if (!$1) {

+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type reference is null", 0);

+    return $null;

+  } %}

+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &

+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}

+

+// plain pointer by reference

+%typemap(in) TYPE *CONST& ($*1_ltype temp = 0)

+%{ temp = ($*1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);

+   $1 = &temp; %}

+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST&

+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}

+

+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast ($&1_type smartarg) %{

+  // shared_ptr by value

+  smartarg = *($&1_ltype*)&$input; 

+  if (smartarg) $1 = *smartarg; 

+%}

+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > ANY_TYPE_SWIGSharedPtrUpcast %{ 

+  *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; 

+%}

+

+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug

+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{

+#error "typemaps for $1_type not available"

+%}

+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{

+#error "typemaps for $1_type not available"

+%}

+

+

+%typemap (ctype)    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "void *"

+%typemap (imtype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "void *"

+%typemap (cstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(cstype, TYPE)"

+%typemap (csin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(cstype, TYPE).getCPtr($csinput)"

+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {

+    IntPtr cPtr = $imcall;

+    return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);

+  }

+

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE {

+    return new $typemap(cstype, TYPE)($imcall, true);

+  }

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE & {

+    return new $typemap(cstype, TYPE)($imcall, true);

+  }

+%typemap(csout, excode=SWIGEXCODE) CONST TYPE * {

+    IntPtr cPtr = $imcall;

+    return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);

+  }

+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {

+    IntPtr cPtr = $imcall;

+    return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);

+  }

+

+// Base proxy classes

+%typemap(csbody) TYPE %{

+  private HandleRef swigCPtr;

+  private bool swigCMemOwnBase;

+

+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {

+    swigCMemOwnBase = cMemoryOwn;

+    swigCPtr = new HandleRef(this, cPtr);

+  }

+

+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {

+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;

+  }

+%}

+

+// Derived proxy classes

+%typemap(csbody_derived) TYPE %{

+  private HandleRef swigCPtr;

+  private bool swigCMemOwnDerived;

+

+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {

+    swigCMemOwnDerived = cMemoryOwn;

+    swigCPtr = new HandleRef(this, cPtr);

+  }

+

+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {

+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;

+  }

+%}

+

+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {

+    lock(this) {

+      if (swigCPtr.Handle != IntPtr.Zero) {

+        if (swigCMemOwnBase) {

+          swigCMemOwnBase = false;

+          $imcall;

+        }

+        swigCPtr = new HandleRef(null, IntPtr.Zero);

+      }

+      GC.SuppressFinalize(this);

+    }

+  }

+

+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {

+    lock(this) {

+      if (swigCPtr.Handle != IntPtr.Zero) {

+        if (swigCMemOwnDerived) {

+          swigCMemOwnDerived = false;

+          $imcall;

+        }

+        swigCPtr = new HandleRef(null, IntPtr.Zero);

+      }

+      GC.SuppressFinalize(this);

+      base.Dispose();

+    }

+  }

+

+

+// CONST version needed ???? also for C#

+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "HandleRef"

+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "HandleRef"

+

+

+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;

+%enddef

+

diff --git a/share/swig/2.0.11/csharp/boost_shared_ptr.i b/share/swig/2.0.11/csharp/boost_shared_ptr.i
new file mode 100644
index 0000000..5e6f664
--- /dev/null
+++ b/share/swig/2.0.11/csharp/boost_shared_ptr.i
@@ -0,0 +1,238 @@
+// Users can provide their own SWIG_SHARED_PTR_TYPEMAPS macro before including this file to change the
+// visibility of the constructor and getCPtr method if desired to public if using multiple modules.
+#ifndef SWIG_SHARED_PTR_TYPEMAPS
+#define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...) SWIG_SHARED_PTR_TYPEMAPS_IMPLEMENTATION(internal, internal, CONST, TYPE)
+#endif
+
+%include <shared_ptr.i>
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS_IMPLEMENTATION(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor mods
+%feature("unref") TYPE 
+//"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ( (*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\") )) << \"]\" << endl << flush; }\n"
+                               "(void)arg1; delete smartarg1;"
+
+// Typemap customisations...
+
+// plain value
+%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0) %{
+  argp = ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0;
+  if (!argp) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);
+    return $null;
+  }
+  $1 = *argp; %}
+%typemap(out) CONST TYPE 
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+
+// plain pointer
+%typemap(in, canthrow=1) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
+  smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input;
+  $1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{
+  $result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+%}
+
+// plain reference
+%typemap(in, canthrow=1) CONST TYPE & %{
+  $1 = ($1_ltype)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+  if (!$1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type reference is null", 0);
+    return $null;
+  } %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// plain pointer by reference
+%typemap(in) TYPE *CONST& ($*1_ltype temp = 0)
+%{ temp = (TYPE *)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+   $1 = &temp; %}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST&
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ if ($input) $1 = *($&1_ltype)$input; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ $result = $1 ? new $1_ltype($1) : 0; %}
+
+// shared_ptr by reference
+%typemap(in, canthrow=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &
+%{ $result = *$1 ? new $*1_ltype(*$1) : 0; %} 
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out, fragment="SWIG_null_deleter") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
+%{ $result = ($1 && *$1) ? new $*1_ltype(*($1_ltype)$1) : 0;
+   if ($owner) delete $1; %}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempnull, $*1_ltype temp = 0)
+%{ temp = $input ? *($1_ltype)&$input : &tempnull;
+   $1 = &temp; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *&
+%{ *($1_ltype)&$result = (*$1 && **$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0; %} 
+
+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+
+
+%typemap (ctype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >, 
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "void *"
+%typemap (imtype, out="IntPtr") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >, 
+                                SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                                SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                                SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "HandleRef"
+%typemap (cstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >, 
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(cstype, TYPE)"
+
+%typemap(csin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >, 
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(cstype, TYPE).getCPtr($csinput)"
+
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+
+
+%typemap(csout, excode=SWIGEXCODE) CONST TYPE {
+    $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) CONST TYPE & {
+    $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) CONST TYPE * {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {
+    IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) CONST TYPE & %{
+    get {
+      $csclassname ret = new $csclassname($imcall, true);$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) CONST TYPE * %{
+    get {
+      IntPtr cPtr = $imcall;
+      $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, true);$excode
+      return ret;
+    } %}
+
+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+    get {
+      IntPtr cPtr = $imcall;
+      $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+    get {
+      IntPtr cPtr = $imcall;
+      $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+      return ret;
+    } %}
+
+
+// Proxy classes (base classes, ie, not derived classes)
+%typemap(csbody) TYPE %{
+  private HandleRef swigCPtr;
+  private bool swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private HandleRef swigCPtr;
+  private bool swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwnBase) {
+          swigCMemOwnBase = false;
+          $imcall;
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwnDerived) {
+          swigCMemOwnDerived = false;
+          $imcall;
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/2.0.11/csharp/csharp.swg b/share/swig/2.0.11/csharp/csharp.swg
new file mode 100644
index 0000000..c0b896e
--- /dev/null
+++ b/share/swig/2.0.11/csharp/csharp.swg
@@ -0,0 +1,1017 @@
+/* -----------------------------------------------------------------------------
+ * csharp.swg
+ *
+ * C# typemaps
+ * ----------------------------------------------------------------------------- */
+
+%include <csharphead.swg>
+
+/* The ctype, imtype and cstype typemaps work together and so there should be one of each. 
+ * The ctype typemap contains the PInvoke type used in the PInvoke (C/C++) code. 
+ * The imtype typemap contains the C# type used in the intermediary class. 
+ * The cstype typemap contains the C# type used in the C# proxy classes, type wrapper classes and module class. */
+
+
+/* Fragments */
+%fragment("SWIG_PackData", "header") {
+/* Pack binary data into a string */
+SWIGINTERN char * SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  register const unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+}
+
+%fragment("SWIG_UnPackData", "header") {
+/* Unpack binary data from a string */
+SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else 
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else 
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+}
+
+/* Primitive types */
+%typemap(ctype) bool,               const bool &               "unsigned int"
+%typemap(ctype) char,               const char &               "char"
+%typemap(ctype) signed char,        const signed char &        "signed char"
+%typemap(ctype) unsigned char,      const unsigned char &      "unsigned char"
+%typemap(ctype) short,              const short &              "short"
+%typemap(ctype) unsigned short,     const unsigned short &     "unsigned short"
+%typemap(ctype) int,                const int &                "int"
+%typemap(ctype) unsigned int,       const unsigned int &       "unsigned int"
+%typemap(ctype) long,               const long &               "long"
+%typemap(ctype) unsigned long,      const unsigned long &      "unsigned long"
+%typemap(ctype) long long,          const long long &          "long long"
+%typemap(ctype) unsigned long long, const unsigned long long & "unsigned long long"
+%typemap(ctype) float,              const float &              "float"
+%typemap(ctype) double,             const double &             "double"
+%typemap(ctype) void                                           "void"
+
+%typemap(imtype) bool,               const bool &               "bool"
+%typemap(imtype) char,               const char &               "char"
+%typemap(imtype) signed char,        const signed char &        "sbyte"
+%typemap(imtype) unsigned char,      const unsigned char &      "byte"
+%typemap(imtype) short,              const short &              "short"
+%typemap(imtype) unsigned short,     const unsigned short &     "ushort"
+%typemap(imtype) int,                const int &                "int"
+%typemap(imtype) unsigned int,       const unsigned int &       "uint"
+%typemap(imtype) long,               const long &               "int"
+%typemap(imtype) unsigned long,      const unsigned long &      "uint"
+%typemap(imtype) long long,          const long long &          "long"
+%typemap(imtype) unsigned long long, const unsigned long long & "ulong"
+%typemap(imtype) float,              const float &              "float"
+%typemap(imtype) double,             const double &             "double"
+%typemap(imtype) void                                           "void"
+
+%typemap(cstype) bool,               const bool &               "bool"
+%typemap(cstype) char,               const char &               "char"
+%typemap(cstype) signed char,        const signed char &        "sbyte"
+%typemap(cstype) unsigned char,      const unsigned char &      "byte"
+%typemap(cstype) short,              const short &              "short"
+%typemap(cstype) unsigned short,     const unsigned short &     "ushort"
+%typemap(cstype) int,                const int &                "int"
+%typemap(cstype) unsigned int,       const unsigned int &       "uint"
+%typemap(cstype) long,               const long &               "int"
+%typemap(cstype) unsigned long,      const unsigned long &      "uint"
+%typemap(cstype) long long,          const long long &          "long"
+%typemap(cstype) unsigned long long, const unsigned long long & "ulong"
+%typemap(cstype) float,              const float &              "float"
+%typemap(cstype) double,             const double &             "double"
+%typemap(cstype) void                                           "void"
+
+%typemap(ctype) char *, char *&, char[ANY], char[]   "char *"
+%typemap(imtype) char *, char *&, char[ANY], char[]   "string"
+%typemap(cstype) char *, char *&, char[ANY], char[]   "string"
+
+/* Non primitive types */
+%typemap(ctype) SWIGTYPE "void *"
+%typemap(imtype, out="IntPtr") SWIGTYPE "HandleRef"
+%typemap(cstype) SWIGTYPE "$&csclassname"
+
+%typemap(ctype) SWIGTYPE [] "void *"
+%typemap(imtype, out="IntPtr") SWIGTYPE [] "HandleRef"
+%typemap(cstype) SWIGTYPE [] "$csclassname"
+
+%typemap(ctype) SWIGTYPE * "void *"
+%typemap(imtype, out="IntPtr") SWIGTYPE * "HandleRef"
+%typemap(cstype) SWIGTYPE * "$csclassname"
+
+%typemap(ctype) SWIGTYPE & "void *"
+%typemap(imtype, out="IntPtr") SWIGTYPE & "HandleRef"
+%typemap(cstype) SWIGTYPE & "$csclassname"
+
+/* pointer to a class member */
+%typemap(ctype) SWIGTYPE (CLASS::*) "char *"
+%typemap(imtype) SWIGTYPE (CLASS::*) "string"
+%typemap(cstype) SWIGTYPE (CLASS::*) "$csclassname"
+
+/* The following are the in and out typemaps. These are the PInvoke code generating typemaps for converting from C# to C and visa versa. */
+
+/* primitive types */
+%typemap(in) bool
+%{ $1 = $input ? true : false; %}
+
+%typemap(directorout) bool
+%{ $result = $input ? true : false; %}
+
+%typemap(csdirectorin) bool "$iminput"
+%typemap(csdirectorout) bool "$cscall"
+
+%typemap(in) char, 
+             signed char, 
+             unsigned char, 
+             short, 
+             unsigned short, 
+             int, 
+             unsigned int, 
+             long, 
+             unsigned long, 
+             long long, 
+             unsigned long long, 
+             float, 
+             double
+%{ $1 = ($1_ltype)$input; %}
+
+%typemap(directorout) char, 
+             signed char, 
+             unsigned char, 
+             short, 
+             unsigned short, 
+             int, 
+             unsigned int, 
+             long, 
+             unsigned long, 
+             long long, 
+             unsigned long long, 
+             float, 
+             double
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorin) bool               "$input = $1;"
+%typemap(directorin) char               "$input = $1;"
+%typemap(directorin) signed char        "$input = $1;"
+%typemap(directorin) unsigned char      "$input = $1;"
+%typemap(directorin) short              "$input = $1;"
+%typemap(directorin) unsigned short     "$input = $1;"
+%typemap(directorin) int                "$input = $1;"
+%typemap(directorin) unsigned int       "$input = $1;"
+%typemap(directorin) long               "$input = $1;"
+%typemap(directorin) unsigned long      "$input = $1;"
+%typemap(directorin) long long          "$input = $1;"
+%typemap(directorin) unsigned long long "$input = $1;"
+%typemap(directorin) float              "$input = $1;"
+%typemap(directorin) double             "$input = $1;"
+
+%typemap(csdirectorin) char, 
+                       signed char, 
+                       unsigned char, 
+                       short, 
+                       unsigned short, 
+                       int, 
+                       unsigned int, 
+                       long, 
+                       unsigned long, 
+                       long long, 
+                       unsigned long long, 
+                       float, 
+                       double
+  "$iminput"
+
+%typemap(csdirectorout) char, 
+                        signed char, 
+                        unsigned char, 
+                        short, 
+                        unsigned short, 
+                        int, 
+                        unsigned int, 
+                        long, 
+                        unsigned long, 
+                        long long, 
+                        unsigned long long, 
+                        float, 
+                        double
+  "$cscall"
+
+%typemap(out) bool               %{ $result = $1; %}
+%typemap(out) char               %{ $result = $1; %}
+%typemap(out) signed char        %{ $result = $1; %}
+%typemap(out) unsigned char      %{ $result = $1; %}
+%typemap(out) short              %{ $result = $1; %}
+%typemap(out) unsigned short     %{ $result = $1; %}
+%typemap(out) int                %{ $result = $1; %}
+%typemap(out) unsigned int       %{ $result = $1; %}
+%typemap(out) long               %{ $result = $1; %}
+%typemap(out) unsigned long      %{ $result = (unsigned long)$1; %}
+%typemap(out) long long          %{ $result = $1; %}
+%typemap(out) unsigned long long %{ $result = $1; %}
+%typemap(out) float              %{ $result = $1; %}
+%typemap(out) double             %{ $result = $1; %}
+
+/* char * - treat as String */
+%typemap(in) char * %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char * %{ $result = SWIG_csharp_string_callback((const char *)$1); %}
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char * %{ $input = SWIG_csharp_string_callback((const char *)$1); %}
+%typemap(csdirectorin) char * "$iminput"
+%typemap(csdirectorout) char * "$cscall"
+
+/* char *& - treat as String */
+%typemap(in) char *& ($*1_ltype temp = 0) %{ 
+  temp = ($*1_ltype)$input;
+  $1 = &temp;
+%}
+%typemap(out) char *& %{ if ($1) $result = SWIG_csharp_string_callback((const char *)*$1); %}
+
+%typemap(out, null="") void ""
+%typemap(csdirectorin) void "$iminput"
+%typemap(csdirectorout) void "$cscall"
+%typemap(directorin) void ""
+
+/* primitive types by const reference */
+%typemap(in) const bool & ($*1_ltype temp)
+%{ temp = $input ? true : false; 
+   $1 = &temp; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const bool &
+%{ static $*1_ltype temp;
+   temp = $input ? true : false; 
+   $result = &temp; %}
+
+%typemap(csdirectorin) const bool & "$iminput"
+%typemap(csdirectorout) const bool & "$cscall"
+
+%typemap(in) const char & ($*1_ltype temp), 
+             const signed char & ($*1_ltype temp), 
+             const unsigned char & ($*1_ltype temp), 
+             const short & ($*1_ltype temp), 
+             const unsigned short & ($*1_ltype temp), 
+             const int & ($*1_ltype temp), 
+             const unsigned int & ($*1_ltype temp), 
+             const long & ($*1_ltype temp), 
+             const unsigned long & ($*1_ltype temp), 
+             const long long & ($*1_ltype temp), 
+             const unsigned long long & ($*1_ltype temp), 
+             const float & ($*1_ltype temp), 
+             const double & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const char &,
+             const signed char &,
+             const unsigned char &,
+             const short &,
+             const unsigned short &,
+             const int &,
+             const unsigned int &,
+             const long &,
+             const unsigned long &,
+             const long long &,
+             const unsigned long long &,
+             const float &,
+             const double &
+%{ static $*1_ltype temp;
+   temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+
+%typemap(directorin) const bool &           "$input = $1;"
+%typemap(directorin) const char &           "$input = $1;"
+%typemap(directorin) const signed char &    "$input = $1;"
+%typemap(directorin) const unsigned char &  "$input = $1;"
+%typemap(directorin) const short &          "$input = $1;"
+%typemap(directorin) const unsigned short & "$input = $1;"
+%typemap(directorin) const int &            "$input = $1;"
+%typemap(directorin) const unsigned int &   "$input = $1;"
+%typemap(directorin) const long &           "$input = $1;"
+%typemap(directorin) const unsigned long &  "$input = $1;"
+%typemap(directorin) const long long &      "$input = $1;"
+%typemap(directorin) const unsigned long long & "$input = $1;"
+%typemap(directorin) const float &          "$input = $1;"
+%typemap(directorin) const double &         "$input = $1;"
+
+%typemap(csdirectorin) const char & ($*1_ltype temp), 
+                       const signed char & ($*1_ltype temp), 
+                       const unsigned char & ($*1_ltype temp), 
+                       const short & ($*1_ltype temp), 
+                       const unsigned short & ($*1_ltype temp), 
+                       const int & ($*1_ltype temp), 
+                       const unsigned int & ($*1_ltype temp), 
+                       const long & ($*1_ltype temp), 
+                       const unsigned long & ($*1_ltype temp), 
+                       const long long & ($*1_ltype temp), 
+                       const unsigned long long & ($*1_ltype temp), 
+                       const float & ($*1_ltype temp), 
+                       const double & ($*1_ltype temp)
+  "$iminput"
+
+%typemap(csdirectorout) const char & ($*1_ltype temp), 
+                        const signed char & ($*1_ltype temp), 
+                        const unsigned char & ($*1_ltype temp), 
+                        const short & ($*1_ltype temp), 
+                        const unsigned short & ($*1_ltype temp), 
+                        const int & ($*1_ltype temp), 
+                        const unsigned int & ($*1_ltype temp), 
+                        const long & ($*1_ltype temp), 
+                        const unsigned long & ($*1_ltype temp), 
+                        const long long & ($*1_ltype temp), 
+                        const unsigned long long & ($*1_ltype temp), 
+                        const float & ($*1_ltype temp), 
+                        const double & ($*1_ltype temp)
+  "$cscall"
+
+
+%typemap(out) const bool &               %{ $result = *$1; %}
+%typemap(out) const char &               %{ $result = *$1; %}
+%typemap(out) const signed char &        %{ $result = *$1; %}
+%typemap(out) const unsigned char &      %{ $result = *$1; %}
+%typemap(out) const short &              %{ $result = *$1; %}
+%typemap(out) const unsigned short &     %{ $result = *$1; %}
+%typemap(out) const int &                %{ $result = *$1; %}
+%typemap(out) const unsigned int &       %{ $result = *$1; %}
+%typemap(out) const long &               %{ $result = *$1; %}
+%typemap(out) const unsigned long &      %{ $result = (unsigned long)*$1; %}
+%typemap(out) const long long &          %{ $result = *$1; %}
+%typemap(out) const unsigned long long & %{ $result = *$1; %}
+%typemap(out) const float &              %{ $result = *$1; %}
+%typemap(out) const double &             %{ $result = *$1; %}
+
+/* Default handling. Object passed by value. Convert to a pointer */
+%typemap(in, canthrow=1) SWIGTYPE ($&1_type argp)
+%{ argp = ($&1_ltype)$input; 
+   if (!argp) {
+     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);
+     return $null;
+   }
+   $1 = *argp; %}
+
+%typemap(directorout) SWIGTYPE
+%{ if (!$input) {
+     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type $1_type", 0);
+     return $null;
+   }
+   $result = *($&1_ltype)$input; %}
+
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+%{ $result = new $1_ltype((const $1_ltype &)$1); %}
+#else
+{
+  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
+  memmove($1ptr, &$1, sizeof($1_type));
+  $result = $1ptr;
+}
+#endif
+
+%typemap(directorin) SWIGTYPE 
+%{ $input = (void *)&$1; %}
+%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, false)"
+%typemap(csdirectorout) SWIGTYPE "$&csclassname.getCPtr($cscall).Handle"
+
+/* Generic pointers and references */
+%typemap(in) SWIGTYPE * %{ $1 = ($1_ltype)$input; %}
+%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) %{ 
+  SWIG_UnpackData($input, (void *)&$1, sizeof($1));
+%}
+%typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
+  if (!$1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type type is null", 0);
+    return $null;
+  } %}
+%typemap(out) SWIGTYPE * %{ $result = (void *)$1; %} 
+%typemap(out, fragment="SWIG_PackData") SWIGTYPE (CLASS::*) %{
+  char buf[128];
+  char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
+  *data = '\0';
+  $result = SWIG_csharp_string_callback(buf);
+%}
+%typemap(out) SWIGTYPE & %{ $result = (void *)$1; %} 
+
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE *
+%{ $result = ($1_ltype)$input; %}
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE (CLASS::*)
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorin) SWIGTYPE *
+%{ $input = (void *) $1; %}
+%typemap(directorin) SWIGTYPE (CLASS::*)
+%{ $input = (void *) $1; %}
+
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
+%{ if (!$input) {
+     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type $1_type", 0);
+     return $null;
+   }
+   $result = ($1_ltype)$input; %}
+%typemap(directorin) SWIGTYPE &
+%{ $input = ($1_ltype) &$1; %}
+
+%typemap(csdirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*) "($iminput == IntPtr.Zero) ? null : new $csclassname($iminput, false)"
+%typemap(csdirectorin) SWIGTYPE & "new $csclassname($iminput, false)"
+%typemap(csdirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "$csclassname.getCPtr($cscall).Handle"
+
+/* Default array handling */
+%typemap(in) SWIGTYPE [] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) SWIGTYPE [] %{ $result = $1; %} 
+
+/* char arrays - treat as String */
+%typemap(in) char[ANY], char[] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char[ANY], char[] %{ $result = SWIG_csharp_string_callback((const char *)$1); %}
+
+%typemap(directorout) char[ANY], char[] %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char[ANY], char[] %{ $input = SWIG_csharp_string_callback((const char *)$1); %}
+
+%typemap(csdirectorin) char[ANY], char[] "$iminput"
+%typemap(csdirectorout) char[ANY], char[] "$cscall"
+
+
+/* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions 
+ * that cannot be overloaded in C# as more than one C++ type maps to a single C# type */
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR)
+    char, 
+    const char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8)
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT8)
+    unsigned char, 
+    const unsigned char & 
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16)
+    short, 
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT16)
+    unsigned short, 
+    const unsigned short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32)
+    int, 
+    long, 
+    const int &, 
+    const long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT32)
+    unsigned int, 
+    unsigned long, 
+    const unsigned int &, 
+    const unsigned long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64)
+    long long, 
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT64)
+    unsigned long long,
+    const unsigned long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT)
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+    double,
+    const double &
+    ""
+
+%typecheck(SWIG_TYPECHECK_STRING)
+    char *,
+    char *&,
+    char[ANY],
+    char[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+    SWIGTYPE, 
+    SWIGTYPE *, 
+    SWIGTYPE &, 
+    SWIGTYPE *const&, 
+    SWIGTYPE [],
+    SWIGTYPE (CLASS::*)
+    ""
+
+/* Exception handling */
+
+%typemap(throws, canthrow=1) int, 
+                 long, 
+                 short, 
+                 unsigned int, 
+                 unsigned long, 
+                 unsigned short
+%{ char error_msg[256];
+   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, error_msg);
+   return $null; %}
+
+%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY]
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(throws, canthrow=1) char *
+%{ SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1);
+   return $null; %}
+
+
+/* Typemaps for code generation in proxy classes and C# type wrapper classes */
+
+/* The csin typemap is used for converting function parameter types from the type 
+ * used in the proxy, module or type wrapper class to the type used in the PInvoke class. */
+%typemap(csin)   bool,               const bool &,
+                 char,               const char &,
+                 signed char,        const signed char &,
+                 unsigned char,      const unsigned char &,
+                 short,              const short &,
+                 unsigned short,     const unsigned short &,
+                 int,                const int &,
+                 unsigned int,       const unsigned int &,
+                 long,               const long &,
+                 unsigned long,      const unsigned long &,
+                 long long,          const long long &,
+                 unsigned long long, const unsigned long long &,
+                 float,              const float &,
+                 double,             const double &
+    "$csinput"
+%typemap(csin) char *, char *&, char[ANY], char[] "$csinput"
+%typemap(csin) SWIGTYPE "$&csclassname.getCPtr($csinput)"
+%typemap(csin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$csclassname.getCPtr($csinput)"
+%typemap(csin) SWIGTYPE (CLASS::*) "$csclassname.getCMemberPtr($csinput)"
+
+/* The csout typemap is used for converting function return types from the return type
+ * used in the PInvoke class to the type returned by the proxy, module or type wrapper class.
+ * The $excode special variable is replaced by the excode typemap attribute code if the
+ * method can throw any exceptions from unmanaged code, otherwise replaced by nothing. */
+
+// Macro used by the $excode special variable
+%define SWIGEXCODE "\n    if ($imclassname.SWIGPendingException.Pending) throw $imclassname.SWIGPendingException.Retrieve();" %enddef
+%define SWIGEXCODE2 "\n      if ($imclassname.SWIGPendingException.Pending) throw $imclassname.SWIGPendingException.Retrieve();" %enddef
+
+%typemap(csout, excode=SWIGEXCODE) bool,               const bool &               {
+    bool ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) char,               const char &               {
+    char ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) signed char,        const signed char &        {
+    sbyte ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) unsigned char,      const unsigned char &      {
+    byte ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) short,              const short &              {
+    short ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) unsigned short,     const unsigned short &     {
+    ushort ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) int,                const int &                {
+    int ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) unsigned int,       const unsigned int &       {
+    uint ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) long,               const long &               {
+    int ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) unsigned long,      const unsigned long &      {
+    uint ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) long long,          const long long &          {
+    long ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) unsigned long long, const unsigned long long & {
+    ulong ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) float,              const float &              {
+    float ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) double,             const double &             {
+    double ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) char *, char *&, char[ANY], char[] {
+    string ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) void {
+    $imcall;$excode
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE {
+    $&csclassname ret = new $&csclassname($imcall, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE & {
+    $csclassname ret = new $csclassname($imcall, $owner);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *, SWIGTYPE [] {
+    IntPtr cPtr = $imcall;
+    $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE (CLASS::*) {
+    string cMemberPtr = $imcall;
+    $csclassname ret = (cMemberPtr == null) ? null : new $csclassname(cMemberPtr, $owner);$excode
+    return ret;
+  }
+
+
+/* Properties */
+%typemap(csvarin, excode=SWIGEXCODE2) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+    set {
+      $imcall;$excode
+    } %}
+
+%typemap(csvarin, excode=SWIGEXCODE2) char *, char *&, char[ANY], char[] %{
+    set {
+      $imcall;$excode
+    } %}
+
+%typemap(csvarout, excode=SWIGEXCODE2) bool,               const bool &               %{
+    get {
+      bool ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) char,               const char &               %{
+    get {
+      char ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) signed char,        const signed char &        %{
+    get {
+      sbyte ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) unsigned char,      const unsigned char &      %{
+    get {
+      byte ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) short,              const short &              %{
+    get {
+      short ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) unsigned short,     const unsigned short &     %{
+    get {
+      ushort ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) int,                const int &                %{
+    get {
+      int ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) unsigned int,       const unsigned int &       %{
+    get {
+      uint ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) long,               const long &               %{
+    get {
+      int ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) unsigned long,      const unsigned long &      %{
+    get {
+      uint ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) long long,          const long long &          %{
+    get {
+      long ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) unsigned long long, const unsigned long long & %{
+    get {
+      ulong ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) float,              const float &              %{
+    get {
+      float ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) double,             const double &             %{
+    get {
+      double ret = $imcall;$excode
+      return ret;
+    } %}
+
+
+%typemap(csvarout, excode=SWIGEXCODE2) char *, char *&, char[ANY], char[] %{
+    get {
+      string ret = $imcall;$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) void %{
+    get {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE %{
+    get {
+      $&csclassname ret = new $&csclassname($imcall, true);$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE & %{
+    get {
+      $csclassname ret = new $csclassname($imcall, $owner);$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE *, SWIGTYPE [] %{
+    get {
+      IntPtr cPtr = $imcall;
+      $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
+      return ret;
+    } %}
+
+%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE (CLASS::*) %{
+    get {
+      string cMemberPtr = $imcall;
+      $csclassname ret = (cMemberPtr == null) ? null : new $csclassname(cMemberPtr, $owner);$excode
+      return ret;
+    } %}
+
+/* Pointer reference typemaps */
+%typemap(ctype) SWIGTYPE *const& "void *"
+%typemap(imtype, out="IntPtr") SWIGTYPE *const& "HandleRef"
+%typemap(cstype) SWIGTYPE *const& "$*csclassname"
+%typemap(csin) SWIGTYPE *const& "$*csclassname.getCPtr($csinput)"
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *const& {
+    IntPtr cPtr = $imcall;
+    $*csclassname ret = (cPtr == IntPtr.Zero) ? null : new $*csclassname(cPtr, $owner);$excode
+    return ret;
+  }
+%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
+%{ temp = ($*1_ltype)$input;
+   $1 = ($1_ltype)&temp; %}
+%typemap(out) SWIGTYPE *const&
+%{ $result = (void *)*$1; %} 
+
+/* Marshal C/C++ pointer to IntPtr */
+%typemap(ctype) void *VOID_INT_PTR "void *"
+%typemap(imtype) void *VOID_INT_PTR "IntPtr"
+%typemap(cstype) void *VOID_INT_PTR "IntPtr"
+%typemap(in) void *VOID_INT_PTR %{ $1 = ($1_ltype)$input; %}
+%typemap(out) void *VOID_INT_PTR %{ $result = (void *)$1; %} 
+%typemap(csin) void *VOID_INT_PTR "$csinput"
+%typemap(csout, excode=SWIGEXCODE) void *VOID_INT_PTR {
+    IntPtr ret = $imcall;$excode
+    return ret;
+  }
+
+
+/* Typemaps used for the generation of proxy and type wrapper class code */
+%typemap(csbase)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csclassmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public class"
+%typemap(cscode)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csimports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "\nusing System;\nusing System.Runtime.InteropServices;\n"
+%typemap(csinterfaces)                SWIGTYPE "IDisposable"
+%typemap(csinterfaces)                          SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csinterfaces_derived)        SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+
+
+// csbody typemaps... these are in macros so that the visibility of the methods can be easily changed by users.
+
+%define SWIG_CSBODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
+// Proxy classes (base classes, ie, not derived classes)
+%typemap(csbody) TYPE %{
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private HandleRef swigCPtr;
+
+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGUpcast(cPtr), cMemoryOwn) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+%enddef
+
+%define SWIG_CSBODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
+// Typewrapper classes
+%typemap(csbody) TYPE *, TYPE &, TYPE [] %{
+  private HandleRef swigCPtr;
+
+  PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  DEFAULTCTOR_VISIBILITY $csclassname() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+%typemap(csbody) TYPE (CLASS::*) %{
+  private string swigCMemberPtr;
+
+  PTRCTOR_VISIBILITY $csclassname(string cMemberPtr, bool futureUse) {
+    swigCMemberPtr = cMemberPtr;
+  }
+
+  DEFAULTCTOR_VISIBILITY $csclassname() {
+    swigCMemberPtr = null;
+  }
+
+  CPTR_VISIBILITY static string getCMemberPtr($csclassname obj) {
+    return obj.swigCMemberPtr;
+  }
+%}
+%enddef
+
+/* Set the default csbody typemaps to use internal visibility.
+   Use the macros to change to public if using multiple modules. */
+SWIG_CSBODY_PROXY(internal, internal, SWIGTYPE)
+SWIG_CSBODY_TYPEWRAPPER(internal, protected, internal, SWIGTYPE)
+
+%typemap(csfinalize) SWIGTYPE %{
+  ~$csclassname() {
+    Dispose();
+  }
+%}
+
+%typemap(csconstruct, excode=SWIGEXCODE,directorconnect="\n    SwigDirectorConnect();") SWIGTYPE %{: this($imcall, true) {$excode$directorconnect
+  }
+%}
+
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          $imcall;
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          $imcall;
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+%typemap(directordisconnect, methodname="swigDirectorDisconnect") SWIGTYPE %{
+  protected void $methodname() {
+    swigCMemOwn = false;
+    $imcall;
+  }
+%}
+
+/* C# specific directives */
+#define %csconst(flag)              %feature("cs:const","flag")
+#define %csconstvalue(value)        %feature("cs:constvalue",value)
+#define %csenum(wrapapproach)       %feature("cs:enum","wrapapproach")
+#define %csmethodmodifiers          %feature("cs:methodmodifiers")
+#define %csnothrowexception         %feature("except")
+#define %csattributes               %feature("cs:attributes")
+
+%pragma(csharp) imclassclassmodifiers="class"
+%pragma(csharp) moduleclassmodifiers="public class"
+
+%pragma(csharp) moduleimports=%{
+using System;
+using System.Runtime.InteropServices;
+%}
+
+%pragma(csharp) imclassimports=%{
+using System;
+using System.Runtime.InteropServices;
+%}
+
+/* Some ANSI C typemaps */
+
+%apply unsigned long { size_t };
+%apply const unsigned long & { const size_t & };
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* csharp keywords */
+%include <csharpkw.swg>
+
+// Default enum handling
+%include <enums.swg>
+
+// For vararg handling in macros, from swigmacros.swg
+#define %arg(X...) X
+
+/*
+// Alternative char * typemaps.
+%pragma(csharp) imclasscode=%{
+  public class SWIGStringMarshal : IDisposable {
+    public readonly HandleRef swigCPtr;
+    public SWIGStringMarshal(string str) {
+      swigCPtr = new HandleRef(this, System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
+    }
+    public virtual void Dispose() {
+      System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
+      GC.SuppressFinalize(this);
+    }
+  }
+%}
+
+%typemap(imtype, out="IntPtr") char *, char[ANY], char[]   "HandleRef"
+%typemap(out) char *, char[ANY], char[] %{ $result = $1; %}
+%typemap(csin) char *, char[ANY], char[] "new $imclassname.SWIGStringMarshal($csinput).swigCPtr"
+%typemap(csout, excode=SWIGEXCODE) char *, char[ANY], char[] {
+    string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
+    return ret;
+  }
+%typemap(csvarin, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
+    set {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
+    get {
+      string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
+      return ret;
+    } %}
+*/
+
diff --git a/share/swig/2.0.11/csharp/csharphead.swg b/share/swig/2.0.11/csharp/csharphead.swg
new file mode 100644
index 0000000..a1c56a4
--- /dev/null
+++ b/share/swig/2.0.11/csharp/csharphead.swg
@@ -0,0 +1,334 @@
+/* -----------------------------------------------------------------------------
+ * csharphead.swg
+ *
+ * Support code for exceptions if the SWIG_CSHARP_NO_EXCEPTION_HELPER is not defined
+ * Support code for strings if the SWIG_CSHARP_NO_STRING_HELPER is not defined
+ * ----------------------------------------------------------------------------- */
+
+%insert(runtime) %{
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+%}
+
+#if !defined(SWIG_CSHARP_NO_EXCEPTION_HELPER)
+%insert(runtime) %{
+/* Support for throwing C# exceptions from C/C++. There are two types: 
+ * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
+typedef enum {
+  SWIG_CSharpApplicationException,
+  SWIG_CSharpArithmeticException,
+  SWIG_CSharpDivideByZeroException,
+  SWIG_CSharpIndexOutOfRangeException,
+  SWIG_CSharpInvalidCastException,
+  SWIG_CSharpInvalidOperationException,
+  SWIG_CSharpIOException,
+  SWIG_CSharpNullReferenceException,
+  SWIG_CSharpOutOfMemoryException,
+  SWIG_CSharpOverflowException,
+  SWIG_CSharpSystemException
+} SWIG_CSharpExceptionCodes;
+
+typedef enum {
+  SWIG_CSharpArgumentException,
+  SWIG_CSharpArgumentNullException,
+  SWIG_CSharpArgumentOutOfRangeException
+} SWIG_CSharpExceptionArgumentCodes;
+
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
+
+typedef struct {
+  SWIG_CSharpExceptionCodes code;
+  SWIG_CSharpExceptionCallback_t callback;
+} SWIG_CSharpException_t;
+
+typedef struct {
+  SWIG_CSharpExceptionArgumentCodes code;
+  SWIG_CSharpExceptionArgumentCallback_t callback;
+} SWIG_CSharpExceptionArgument_t;
+
+static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
+  { SWIG_CSharpApplicationException, NULL },
+  { SWIG_CSharpArithmeticException, NULL },
+  { SWIG_CSharpDivideByZeroException, NULL },
+  { SWIG_CSharpIndexOutOfRangeException, NULL },
+  { SWIG_CSharpInvalidCastException, NULL },
+  { SWIG_CSharpInvalidOperationException, NULL },
+  { SWIG_CSharpIOException, NULL },
+  { SWIG_CSharpNullReferenceException, NULL },
+  { SWIG_CSharpOutOfMemoryException, NULL },
+  { SWIG_CSharpOverflowException, NULL },
+  { SWIG_CSharpSystemException, NULL }
+};
+
+static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
+  { SWIG_CSharpArgumentException, NULL },
+  { SWIG_CSharpArgumentNullException, NULL },
+  { SWIG_CSharpArgumentOutOfRangeException, NULL }
+};
+
+static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
+  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
+  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
+    callback = SWIG_csharp_exceptions[code].callback;
+  }
+  callback(msg);
+}
+
+static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
+  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
+  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
+    callback = SWIG_csharp_exceptions_argument[code].callback;
+  }
+  callback(msg, param_name);
+}
+%}
+
+%insert(runtime) %{
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_$module(
+                                                SWIG_CSharpExceptionCallback_t applicationCallback,
+                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
+                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
+                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
+                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
+                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
+                                                SWIG_CSharpExceptionCallback_t ioCallback,
+                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
+                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
+                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
+                                                SWIG_CSharpExceptionCallback_t systemCallback) {
+  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
+}
+
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_$module(
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
+}
+%}
+
+%pragma(csharp) imclasscode=%{
+  protected class SWIGExceptionHelper {
+
+    public delegate void ExceptionDelegate(string message);
+    public delegate void ExceptionArgumentDelegate(string message, string paramName);
+
+    static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException);
+    static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException);
+    static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException);
+    static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException);
+    static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException);
+    static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException);
+    static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException);
+    static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException);
+    static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException);
+    static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException);
+    static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException);
+
+    static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException);
+    static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException);
+    static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException);
+
+    [DllImport("$dllimport", EntryPoint="SWIGRegisterExceptionCallbacks_$module")]
+    public static extern void SWIGRegisterExceptionCallbacks_$module(
+                                ExceptionDelegate applicationDelegate,
+                                ExceptionDelegate arithmeticDelegate,
+                                ExceptionDelegate divideByZeroDelegate, 
+                                ExceptionDelegate indexOutOfRangeDelegate, 
+                                ExceptionDelegate invalidCastDelegate,
+                                ExceptionDelegate invalidOperationDelegate,
+                                ExceptionDelegate ioDelegate,
+                                ExceptionDelegate nullReferenceDelegate,
+                                ExceptionDelegate outOfMemoryDelegate, 
+                                ExceptionDelegate overflowDelegate, 
+                                ExceptionDelegate systemExceptionDelegate);
+
+    [DllImport("$dllimport", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_$module")]
+    public static extern void SWIGRegisterExceptionCallbacksArgument_$module(
+                                ExceptionArgumentDelegate argumentDelegate,
+                                ExceptionArgumentDelegate argumentNullDelegate,
+                                ExceptionArgumentDelegate argumentOutOfRangeDelegate);
+
+    static void SetPendingApplicationException(string message) {
+      SWIGPendingException.Set(new System.ApplicationException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingArithmeticException(string message) {
+      SWIGPendingException.Set(new System.ArithmeticException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingDivideByZeroException(string message) {
+      SWIGPendingException.Set(new System.DivideByZeroException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingIndexOutOfRangeException(string message) {
+      SWIGPendingException.Set(new System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingInvalidCastException(string message) {
+      SWIGPendingException.Set(new System.InvalidCastException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingInvalidOperationException(string message) {
+      SWIGPendingException.Set(new System.InvalidOperationException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingIOException(string message) {
+      SWIGPendingException.Set(new System.IO.IOException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingNullReferenceException(string message) {
+      SWIGPendingException.Set(new System.NullReferenceException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingOutOfMemoryException(string message) {
+      SWIGPendingException.Set(new System.OutOfMemoryException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingOverflowException(string message) {
+      SWIGPendingException.Set(new System.OverflowException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingSystemException(string message) {
+      SWIGPendingException.Set(new System.SystemException(message, SWIGPendingException.Retrieve()));
+    }
+
+    static void SetPendingArgumentException(string message, string paramName) {
+      SWIGPendingException.Set(new System.ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingArgumentNullException(string message, string paramName) {
+      Exception e = SWIGPendingException.Retrieve();
+      if (e != null) message = message + " Inner Exception: " + e.Message;
+      SWIGPendingException.Set(new System.ArgumentNullException(paramName, message));
+    }
+    static void SetPendingArgumentOutOfRangeException(string message, string paramName) {
+      Exception e = SWIGPendingException.Retrieve();
+      if (e != null) message = message + " Inner Exception: " + e.Message;
+      SWIGPendingException.Set(new System.ArgumentOutOfRangeException(paramName, message));
+    }
+
+    static SWIGExceptionHelper() {
+      SWIGRegisterExceptionCallbacks_$module(
+                                applicationDelegate,
+                                arithmeticDelegate,
+                                divideByZeroDelegate,
+                                indexOutOfRangeDelegate,
+                                invalidCastDelegate,
+                                invalidOperationDelegate,
+                                ioDelegate,
+                                nullReferenceDelegate,
+                                outOfMemoryDelegate,
+                                overflowDelegate,
+                                systemDelegate);
+
+      SWIGRegisterExceptionCallbacksArgument_$module(
+                                argumentDelegate,
+                                argumentNullDelegate,
+                                argumentOutOfRangeDelegate);
+    }
+  }
+
+  protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper();
+
+  public class SWIGPendingException {
+    [ThreadStatic]
+    private static Exception pendingException = null;
+    private static int numExceptionsPending = 0;
+
+    public static bool Pending {
+      get {
+        bool pending = false;
+        if (numExceptionsPending > 0)
+          if (pendingException != null)
+            pending = true;
+        return pending;
+      } 
+    }
+
+    public static void Set(Exception e) {
+      if (pendingException != null)
+        throw new ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e);
+      pendingException = e;
+      lock(typeof($imclassname)) {
+        numExceptionsPending++;
+      }
+    }
+
+    public static Exception Retrieve() {
+      Exception e = null;
+      if (numExceptionsPending > 0) {
+        if (pendingException != null) {
+          e = pendingException;
+          pendingException = null;
+          lock(typeof($imclassname)) {
+            numExceptionsPending--;
+          }
+        }
+      }
+      return e;
+    }
+  }
+%}
+#endif // SWIG_CSHARP_NO_EXCEPTION_HELPER
+
+#if !defined(SWIG_CSHARP_NO_STRING_HELPER)
+%insert(runtime) %{
+/* Callback for returning strings to C# without leaking memory */
+typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
+static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
+%}
+
+%pragma(csharp) imclasscode=%{
+  protected class SWIGStringHelper {
+
+    public delegate string SWIGStringDelegate(string message);
+    static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString);
+
+    [DllImport("$dllimport", EntryPoint="SWIGRegisterStringCallback_$module")]
+    public static extern void SWIGRegisterStringCallback_$module(SWIGStringDelegate stringDelegate);
+
+    static string CreateString(string cString) {
+      return cString;
+    }
+
+    static SWIGStringHelper() {
+      SWIGRegisterStringCallback_$module(stringDelegate);
+    }
+  }
+
+  static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper();
+%}
+
+%insert(runtime) %{
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_$module(SWIG_CSharpStringHelperCallback callback) {
+  SWIG_csharp_string_callback = callback;
+}
+%}
+#endif // SWIG_CSHARP_NO_STRING_HELPER
+
+#if !defined(SWIG_CSHARP_NO_IMCLASS_STATIC_CONSTRUCTOR)
+// Ensure the class is not marked beforefieldinit
+%pragma(csharp) imclasscode=%{
+  static $imclassname() {
+  }
+%}
+#endif
+
+%insert(runtime) %{
+/* Contract support */
+
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
+%}
diff --git a/share/swig/2.0.11/csharp/csharpkw.swg b/share/swig/2.0.11/csharp/csharpkw.swg
new file mode 100644
index 0000000..9a6d979
--- /dev/null
+++ b/share/swig/2.0.11/csharp/csharpkw.swg
@@ -0,0 +1,94 @@
+#ifndef CSHARP_CSHARPKW_SWG_
+#define CSHARP_CSHARPKW_SWG_
+
+/* Warnings for C# keywords */
+#define CSHARPKW(x) %keywordwarn("'" `x` "' is a C# keyword, renaming to '_" `x` "'",rename="_%s")  `x`
+
+/*
+   from
+   http://www.jaggersoft.com/csharp_grammar.html#1.7%20Keywords
+
+*/
+
+CSHARPKW(abstract);
+CSHARPKW(as);
+CSHARPKW(base);
+CSHARPKW(bool);
+CSHARPKW(break);
+CSHARPKW(byte);
+CSHARPKW(case);
+CSHARPKW(catch);
+CSHARPKW(char);
+CSHARPKW(checked);
+CSHARPKW(class);
+CSHARPKW(const);
+CSHARPKW(continue);
+CSHARPKW(decimal);
+CSHARPKW(default);
+CSHARPKW(delegate);
+CSHARPKW(do);
+CSHARPKW(double);
+CSHARPKW(else);
+CSHARPKW(enum);
+CSHARPKW(event);
+CSHARPKW(explicit);
+CSHARPKW(extern);
+CSHARPKW(false);
+CSHARPKW(finally);
+CSHARPKW(fixed);
+CSHARPKW(float);
+CSHARPKW(for);
+CSHARPKW(foreach);
+CSHARPKW(goto);
+CSHARPKW(if);
+CSHARPKW(implicit);
+CSHARPKW(in);
+CSHARPKW(int);
+CSHARPKW(interface);
+CSHARPKW(internal);
+CSHARPKW(is);
+CSHARPKW(lock);
+CSHARPKW(long);
+CSHARPKW(namespace);
+CSHARPKW(new);
+CSHARPKW(null);
+CSHARPKW(object);
+CSHARPKW(operator);
+CSHARPKW(out);
+CSHARPKW(override);
+CSHARPKW(params);
+CSHARPKW(private);
+CSHARPKW(protected);
+CSHARPKW(public);
+CSHARPKW(readonly);
+CSHARPKW(ref);
+CSHARPKW(return);
+CSHARPKW(sbyte);
+CSHARPKW(sealed);
+CSHARPKW(short);
+CSHARPKW(sizeof);
+CSHARPKW(stackalloc);
+CSHARPKW(static);
+CSHARPKW(struct);
+CSHARPKW(string);
+CSHARPKW(switch);
+CSHARPKW(this);
+CSHARPKW(throw);
+CSHARPKW(true);
+CSHARPKW(try);
+CSHARPKW(typeof);
+CSHARPKW(uint);
+CSHARPKW(ulong);
+CSHARPKW(unchecked);
+CSHARPKW(unsafe);
+CSHARPKW(ushort);
+CSHARPKW(using);
+CSHARPKW(virtual);
+CSHARPKW(void);
+CSHARPKW(volatile);
+CSHARPKW(while);
+
+
+#undef CSHARPKW
+
+#endif //CSHARP_CSHARPKW_SWG_
diff --git a/share/swig/2.0.11/csharp/director.swg b/share/swig/2.0.11/csharp/director.swg
new file mode 100644
index 0000000..7768d8c
--- /dev/null
+++ b/share/swig/2.0.11/csharp/director.swg
@@ -0,0 +1,47 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that C# proxy 
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+
+namespace Swig {
+  /* Director base class - not currently used in C# directors */
+  class Director {
+  };
+
+  /* Base class for director exceptions */
+  class DirectorException {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const char* msg) : swig_msg(msg) {
+    }
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+    const std::string& what() const {
+      return swig_msg;
+    }
+    virtual ~DirectorException() {
+    }
+  };
+
+  /* Pure virtual method exception */
+  class DirectorPureVirtualException : public Swig::DirectorException {
+  public:
+    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
+#endif /* __cplusplus */
+
+
diff --git a/share/swig/2.0.11/csharp/enums.swg b/share/swig/2.0.11/csharp/enums.swg
new file mode 100644
index 0000000..70e483f
--- /dev/null
+++ b/share/swig/2.0.11/csharp/enums.swg
@@ -0,0 +1,86 @@
+/* -----------------------------------------------------------------------------
+ * enums.swg
+ *
+ * Include this file in order for C/C++ enums to be wrapped by proper C# enums.
+ * Note that the PINVOKE layer handles the enum as an int.
+ * ----------------------------------------------------------------------------- */
+
+// const enum SWIGTYPE & typemaps
+%typemap(ctype) const enum SWIGTYPE & "int"
+%typemap(imtype) const enum SWIGTYPE & "int"
+%typemap(cstype) const enum SWIGTYPE & "$*csclassname"
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(csdirectorin) const enum SWIGTYPE & "($*csclassname)$iminput"
+%typemap(csdirectorout) const enum SWIGTYPE & "(int)$cscall"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(throws, canthrow=1) const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) const enum SWIGTYPE & "(int)$csinput"
+%typemap(csout, excode=SWIGEXCODE) const enum SWIGTYPE & {
+    $*csclassname ret = ($*csclassname)$imcall;$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) const enum SWIGTYPE & %{
+    get {
+      $*csclassname ret = ($*csclassname)$imcall;$excode
+      return ret;
+    } %}
+
+
+// enum SWIGTYPE typemaps
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "$csclassname"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(csdirectorin) enum SWIGTYPE "($csclassname)$iminput"
+%typemap(csdirectorout) enum SWIGTYPE "(int)$cscall"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(throws, canthrow=1) enum SWIGTYPE
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) enum SWIGTYPE "(int)$csinput"
+%typemap(csout, excode=SWIGEXCODE) enum SWIGTYPE {
+    $csclassname ret = ($csclassname)$imcall;$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) enum SWIGTYPE %{
+    get {
+      $csclassname ret = ($csclassname)$imcall;$excode
+      return ret;
+    } %}
+
+%typemap(csbase)           enum SWIGTYPE ""
+%typemap(csclassmodifiers) enum SWIGTYPE "public enum"
+%typemap(cscode)           enum SWIGTYPE ""
+%typemap(csimports)        enum SWIGTYPE ""
+%typemap(csinterfaces)     enum SWIGTYPE ""
+
+%typemap(csbody) enum SWIGTYPE ""
+
+%csenum(proper);
+
diff --git a/share/swig/2.0.11/csharp/enumsimple.swg b/share/swig/2.0.11/csharp/enumsimple.swg
new file mode 100644
index 0000000..a193e75
--- /dev/null
+++ b/share/swig/2.0.11/csharp/enumsimple.swg
@@ -0,0 +1,88 @@
+/* -----------------------------------------------------------------------------
+ * enumsimple.swg
+ *
+ * This file provides backwards compatible enum wrapping. SWIG versions 1.3.21
+ * and earlier wrapped global enums with constant integers in the module
+ * class. Enums declared within a C++ class were wrapped by constant integers
+ * in the C# proxy class.
+ * ----------------------------------------------------------------------------- */
+
+// const enum SWIGTYPE & typemaps
+%typemap(ctype) const enum SWIGTYPE & "int"
+%typemap(imtype) const enum SWIGTYPE & "int"
+%typemap(cstype) const enum SWIGTYPE & "int"
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(csdirectorin) const enum SWIGTYPE & "$iminput"
+%typemap(csdirectorout) const enum SWIGTYPE & "$cscall"
+
+%typecheck(SWIG_TYPECHECK_INT32) const enum SWIGTYPE & ""
+
+%typemap(throws, canthrow=1) const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) const enum SWIGTYPE & "$csinput"
+%typemap(csout, excode=SWIGEXCODE) const enum SWIGTYPE & {
+    int ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) const enum SWIGTYPE & %{
+    get {
+      int ret = $imcall;$excode
+      return ret;
+    } %}
+
+
+// enum SWIGTYPE typemaps
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "int"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(csdirectorin) enum SWIGTYPE "$iminput"
+%typemap(csdirectorout) enum SWIGTYPE "$cscall"
+
+%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
+
+%typemap(throws, canthrow=1) enum SWIGTYPE
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) enum SWIGTYPE "$csinput"
+%typemap(csout, excode=SWIGEXCODE) enum SWIGTYPE {
+    int ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) enum SWIGTYPE %{
+    get {
+      int ret = $imcall;$excode
+      return ret;
+    } %}
+
+%typemap(csbase)           enum SWIGTYPE ""
+%typemap(csclassmodifiers) enum SWIGTYPE ""
+%typemap(cscode)           enum SWIGTYPE ""
+%typemap(csimports)        enum SWIGTYPE ""
+%typemap(csinterfaces)     enum SWIGTYPE ""
+
+%typemap(csbody) enum SWIGTYPE ""
+
+%csenum(simple);
+
diff --git a/share/swig/2.0.11/csharp/enumtypesafe.swg b/share/swig/2.0.11/csharp/enumtypesafe.swg
new file mode 100644
index 0000000..ed483f0
--- /dev/null
+++ b/share/swig/2.0.11/csharp/enumtypesafe.swg
@@ -0,0 +1,130 @@
+/* -----------------------------------------------------------------------------
+ * enumtypesafe.swg
+ *
+ * Include this file in order for C/C++ enums to be wrapped by the so called
+ * typesafe enum pattern. Each enum has an equivalent C# class named after the
+ * enum and each enum item is a static instance of this class.
+ * ----------------------------------------------------------------------------- */
+
+// const enum SWIGTYPE & typemaps
+%typemap(ctype) const enum SWIGTYPE & "int"
+%typemap(imtype) const enum SWIGTYPE & "int"
+%typemap(cstype) const enum SWIGTYPE & "$*csclassname"
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(csdirectorin) const enum SWIGTYPE & "$*csclassname.swigToEnum($iminput)"
+%typemap(csdirectorout) const enum SWIGTYPE & "$cscall.swigValue"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(throws, canthrow=1) const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) const enum SWIGTYPE & "$csinput.swigValue"
+%typemap(csout, excode=SWIGEXCODE) const enum SWIGTYPE & {
+    $*csclassname ret = $*csclassname.swigToEnum($imcall);$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) const enum SWIGTYPE & %{
+    get {
+      $*csclassname ret = $*csclassname.swigToEnum($imcall);$excode
+      return ret;
+    } %}
+
+
+// enum SWIGTYPE typemaps
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "$csclassname"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(csdirectorin) enum SWIGTYPE "$csclassname.swigToEnum($iminput)"
+%typemap(csdirectorout) enum SWIGTYPE "$cscall.swigValue"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(throws, canthrow=1) enum SWIGTYPE
+%{ (void)$1;
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(csin) enum SWIGTYPE "$csinput.swigValue"
+%typemap(csout, excode=SWIGEXCODE) enum SWIGTYPE {
+    $csclassname ret = $csclassname.swigToEnum($imcall);$excode
+    return ret;
+  }
+
+%typemap(csvarout, excode=SWIGEXCODE2) enum SWIGTYPE %{
+    get {
+      $csclassname ret = $csclassname.swigToEnum($imcall);$excode
+      return ret;
+    } %}
+
+%typemap(csbase)           enum SWIGTYPE ""
+%typemap(csclassmodifiers) enum SWIGTYPE "public sealed class"
+%typemap(cscode)           enum SWIGTYPE ""
+%typemap(csimports)        enum SWIGTYPE ""
+%typemap(csinterfaces)     enum SWIGTYPE ""
+
+/*
+ * The swigToEnum method is used to find the C# enum from a C++ enum integer value. The default one here takes 
+ * advantage of the fact that most enums do not have initial values specified, so the lookup is fast. If initial
+ * values are specified then a lengthy linear search through all possible enums might occur. Specific typemaps could be
+ * written to possibly optimise this lookup by taking advantage of characteristics peculiar to the targeted enum.
+ * The special variable, $enumvalues, is replaced with a comma separated list of all the enum values.
+ */
+%typemap(csbody) enum SWIGTYPE %{
+  public readonly int swigValue;
+
+  public static $csclassname swigToEnum(int swigValue) {
+    if (swigValue < swigValues.Length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
+      return swigValues[swigValue];
+    for (int i = 0; i < swigValues.Length; i++)
+      if (swigValues[i].swigValue == swigValue)
+        return swigValues[i];
+    throw new System.ArgumentOutOfRangeException("No enum $csclassname with value " + swigValue);
+  }
+
+  public override string ToString() {
+    return swigName;
+  }
+
+  private $csclassname(string swigName) {
+    this.swigName = swigName;
+    this.swigValue = swigNext++;
+  }
+
+  private $csclassname(string swigName, int swigValue) {
+    this.swigName = swigName;
+    this.swigValue = swigValue;
+    swigNext = swigValue+1;
+  }
+
+  private $csclassname(string swigName, $csclassname swigEnum) {
+    this.swigName = swigName;
+    this.swigValue = swigEnum.swigValue;
+    swigNext = this.swigValue+1;
+  }
+
+  private static $csclassname[] swigValues = { $enumvalues };
+  private static int swigNext = 0;
+  private readonly string swigName;
+%}
+
+%csenum(typesafe);
+
diff --git a/share/swig/2.0.11/csharp/std_common.i b/share/swig/2.0.11/csharp/std_common.i
new file mode 100644
index 0000000..cee11e8
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_common.i
@@ -0,0 +1,5 @@
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
+
diff --git a/share/swig/2.0.11/csharp/std_deque.i b/share/swig/2.0.11/csharp/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/2.0.11/csharp/std_except.i b/share/swig/2.0.11/csharp/std_except.i
new file mode 100644
index 0000000..27eb84b
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_except.i
@@ -0,0 +1,30 @@
+/* -----------------------------------------------------------------------------
+ * std_except.i
+ *
+ * Typemaps used by the STL wrappers that throw exceptions. These typemaps are
+ * used when methods are declared with an STL exception specification, such as
+ *   size_t at() const throw (std::out_of_range);
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <stdexcept>
+%}
+
+namespace std 
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws, canthrow=1) std::bad_exception     "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::domain_error      "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::exception         "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::invalid_argument  "SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, $1.what(), \"\");\n return $null;"
+%typemap(throws, canthrow=1) std::length_error      "SWIG_CSharpSetPendingException(SWIG_CSharpIndexOutOfRangeException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::logic_error       "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::out_of_range      "SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::overflow_error    "SWIG_CSharpSetPendingException(SWIG_CSharpOverflowException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::range_error       "SWIG_CSharpSetPendingException(SWIG_CSharpIndexOutOfRangeException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::runtime_error     "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::underflow_error   "SWIG_CSharpSetPendingException(SWIG_CSharpOverflowException, $1.what());\n return $null;"
+
diff --git a/share/swig/2.0.11/csharp/std_map.i b/share/swig/2.0.11/csharp/std_map.i
new file mode 100644
index 0000000..acd1906
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_map.i
@@ -0,0 +1,312 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map< K, T, C >
+ *
+ * The C# wrapper is made to look and feel like a C# System.Collections.Generic.IDictionary<>.
+ * 
+ * Using this wrapper is fairly simple. For example, to create a map from integers to doubles use:
+ *
+ *   %include <std_map.i>
+ *   %template(MapIntDouble) std::map<int, double>
+ *
+ * Notes:
+ * 1) For .NET 1 compatibility, define SWIG_DOTNET_1 when compiling the C# code. In this case 
+ *    the C# wrapper has only basic functionality.
+ * 2) IEnumerable<> is implemented in the proxy class which is useful for using LINQ with 
+ *    C++ std::map wrappers.
+ *
+ * Warning: heavy macro usage in this file. Use swig -E to get a sane view on the real file contents!
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+/* K is the C++ key type, T is the C++ value type */
+%define SWIG_STD_MAP_INTERNAL(K, T, C)
+
+%typemap(csinterfaces) std::map< K, T, C > "IDisposable \n#if !SWIG_DOTNET_1\n    , System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n#endif\n";
+%typemap(cscode) std::map<K, T, C > %{
+
+  public $typemap(cstype, T) this[$typemap(cstype, K) key] {
+    get {
+      return getitem(key);
+    }
+
+    set {
+      setitem(key, value);
+    }
+  }
+
+  public bool TryGetValue($typemap(cstype, K) key, out $typemap(cstype, T) value) {
+    if (this.ContainsKey(key)) {
+      value = this[key];
+      return true;
+    }
+    value = default($typemap(cstype, T));
+    return false;
+  }
+
+  public int Count {
+    get {
+      return (int)size();
+    }
+  }
+
+  public bool IsReadOnly {
+    get { 
+      return false; 
+    }
+  }
+
+#if !SWIG_DOTNET_1
+
+  public System.Collections.Generic.ICollection<$typemap(cstype, K)> Keys {
+    get {
+      System.Collections.Generic.ICollection<$typemap(cstype, K)> keys = new System.Collections.Generic.List<$typemap(cstype, K)>();
+      int size = this.Count;
+      if (size > 0) {
+        IntPtr iter = create_iterator_begin();
+        for (int i = 0; i < size; i++) {
+          keys.Add(get_next_key(iter));
+        }
+        destroy_iterator(iter);
+      }
+      return keys;
+    }
+  }
+
+  public System.Collections.Generic.ICollection<$typemap(cstype, T)> Values {
+    get {
+      System.Collections.Generic.ICollection<$typemap(cstype, T)> vals = new System.Collections.Generic.List<$typemap(cstype, T)>();
+      foreach (System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> pair in this) {
+        vals.Add(pair.Value);
+      }
+      return vals;
+    }
+  }
+  
+  public void Add(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+    Add(item.Key, item.Value);
+  }
+
+  public bool Remove(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+    if (Contains(item)) {
+      return Remove(item.Key);
+    } else {
+      return false;
+    }
+  }
+
+  public bool Contains(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+    if (this[item.Key] == item.Value) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public void CopyTo(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array) {
+    CopyTo(array, 0);
+  }
+
+  public void CopyTo(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array, int arrayIndex) {
+    if (array == null)
+      throw new ArgumentNullException("array");
+    if (arrayIndex < 0)
+      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+    if (array.Rank > 1)
+      throw new ArgumentException("Multi dimensional array.", "array");
+    if (arrayIndex+this.Count > array.Length)
+      throw new ArgumentException("Number of elements to copy is too large.");
+
+    System.Collections.Generic.IList<$typemap(cstype, K)> keyList = new System.Collections.Generic.List<$typemap(cstype, K)>(this.Keys);
+    for (int i = 0; i < keyList.Count; i++) {
+      $typemap(cstype, K) currentKey = keyList[i];
+      array.SetValue(new System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, this[currentKey]), arrayIndex+i);
+    }
+  }
+
+  System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>>.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  public $csclassnameEnumerator GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  // Type-safe enumerator
+  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
+  /// whenever the collection is modified. This has been done for changes in the size of the
+  /// collection but not when one of the elements of the collection is modified as it is a bit
+  /// tricky to detect unmanaged code that modifies the collection under our feet.
+  public sealed class $csclassnameEnumerator : System.Collections.IEnumerator, 
+      System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>>
+  {
+    private $csclassname collectionRef;
+    private System.Collections.Generic.IList<$typemap(cstype, K)> keyCollection;
+    private int currentIndex;
+    private object currentObject;
+    private int currentSize;
+
+    public $csclassnameEnumerator($csclassname collection) {
+      collectionRef = collection;
+      keyCollection = new System.Collections.Generic.List<$typemap(cstype, K)>(collection.Keys);
+      currentIndex = -1;
+      currentObject = null;
+      currentSize = collectionRef.Count;
+    }
+
+    // Type-safe iterator Current
+    public System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> Current {
+      get {
+        if (currentIndex == -1)
+          throw new InvalidOperationException("Enumeration not started.");
+        if (currentIndex > currentSize - 1)
+          throw new InvalidOperationException("Enumeration finished.");
+        if (currentObject == null)
+          throw new InvalidOperationException("Collection modified.");
+        return (System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>)currentObject;
+      }
+    }
+
+    // Type-unsafe IEnumerator.Current
+    object System.Collections.IEnumerator.Current {
+      get {
+        return Current;
+      }
+    }
+
+    public bool MoveNext() {
+      int size = collectionRef.Count;
+      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
+      if (moveOkay) {
+        currentIndex++;
+        $typemap(cstype, K) currentKey = keyCollection[currentIndex];
+        currentObject = new System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, collectionRef[currentKey]);
+      } else {
+        currentObject = null;
+      }
+      return moveOkay;
+    }
+
+    public void Reset() {
+      currentIndex = -1;
+      currentObject = null;
+      if (collectionRef.Count != currentSize) {
+        throw new InvalidOperationException("Collection modified.");
+      }
+    }
+
+    public void Dispose() {
+      currentIndex = -1;
+      currentObject = null;
+    }
+  }
+#endif
+  
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef K key_type;
+    typedef T mapped_type;
+
+    map();
+    map(const map< K, T, C > &other);
+    size_type size() const;
+    bool empty() const;
+    %rename(Clear) clear;
+    void clear();
+    %extend {
+      const mapped_type& getitem(const key_type& key) throw (std::out_of_range) {
+        std::map< K, T, C >::iterator iter = $self->find(key);
+        if (iter != $self->end())
+          return iter->second;
+        else
+          throw std::out_of_range("key not found");
+      }
+
+      void setitem(const key_type& key, const mapped_type& x) {
+        (*$self)[key] = x;
+      }
+
+      bool ContainsKey(const key_type& key) {
+        std::map< K, T, C >::iterator iter = $self->find(key);
+        return iter != $self->end();
+      }
+
+      void Add(const key_type& key, const mapped_type& val) throw (std::out_of_range) {
+        std::map< K, T, C >::iterator iter = $self->find(key);
+        if (iter != $self->end())
+          throw std::out_of_range("key already exists");
+        $self->insert(std::pair< K, T >(key, val));
+      }
+
+      bool Remove(const key_type& key) {
+        std::map< K, T, C >::iterator iter = $self->find(key);
+        if (iter != $self->end()) {
+          $self->erase(iter);
+          return true;
+        }                
+        return false;
+      }
+
+      // create_iterator_begin(), get_next_key() and destroy_iterator work together to provide a collection of keys to C#
+      %apply void *VOID_INT_PTR { std::map< K, T, C >::iterator *create_iterator_begin }
+      %apply void *VOID_INT_PTR { std::map< K, T, C >::iterator *swigiterator }
+
+      std::map< K, T, C >::iterator *create_iterator_begin() {
+        return new std::map< K, T, C >::iterator($self->begin());
+      }
+
+      const key_type& get_next_key(std::map< K, T, C >::iterator *swigiterator) {
+        std::map< K, T, C >::iterator iter = *swigiterator;
+        (*swigiterator)++;
+        return (*iter).first;
+      }
+
+      void destroy_iterator(std::map< K, T, C >::iterator *swigiterator) {
+        delete swigiterator;
+      }
+    }
+
+
+%enddef
+
+%csmethodmodifiers std::map::size "private"
+%csmethodmodifiers std::map::getitem "private"
+%csmethodmodifiers std::map::setitem "private"
+%csmethodmodifiers std::map::create_iterator_begin "private"
+%csmethodmodifiers std::map::get_next_key "private"
+%csmethodmodifiers std::map::destroy_iterator "private"
+
+// Default implementation
+namespace std {   
+  template<class K, class T, class C = std::less<K> > class map {
+    SWIG_STD_MAP_INTERNAL(K, T, C)
+  };
+}
+ 
+
+// Legacy macros (deprecated)
+%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
+#warning "specialize_std_map_on_key ignored - macro is deprecated and no longer necessary"
+%enddef
+
+%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
+#warning "specialize_std_map_on_value ignored - macro is deprecated and no longer necessary"
+%enddef
+
+%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
+#warning "specialize_std_map_on_both ignored - macro is deprecated and no longer necessary"
+%enddef
+
diff --git a/share/swig/2.0.11/csharp/std_pair.i b/share/swig/2.0.11/csharp/std_pair.i
new file mode 100644
index 0000000..0712ad7
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_pair.i
@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// ------------------------------------------------------------------------
+// std::pair
+// ------------------------------------------------------------------------
+
+%{
+#include <utility>
+%}
+
+namespace std {
+
+  template<class T, class U> struct pair {
+
+    pair();
+    pair(T t, U u);
+    pair(const pair& p);
+
+    template <class U1, class U2> pair(const pair<U1, U2> &p);
+
+    T first;
+    U second;
+  };
+
+  // add specializations here
+
+}
diff --git a/share/swig/2.0.11/csharp/std_shared_ptr.i b/share/swig/2.0.11/csharp/std_shared_ptr.i
new file mode 100644
index 0000000..df87367
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_shared_ptr.i
@@ -0,0 +1,2 @@
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>
diff --git a/share/swig/2.0.11/csharp/std_string.i b/share/swig/2.0.11/csharp/std_string.i
new file mode 100644
index 0000000..5f8fa44
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_string.i
@@ -0,0 +1,111 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * Typemaps for std::string and const std::string&
+ * These are mapped to a C# String and are passed around by value.
+ *
+ * To use non-const std::string references use the following %apply.  Note 
+ * that they are passed by value.
+ * %apply const std::string & {std::string &};
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+%naturalvar string;
+
+class string;
+
+// string
+%typemap(ctype) string "char *"
+%typemap(imtype) string "string"
+%typemap(cstype) string "string"
+
+%typemap(csdirectorin) string "$iminput"
+%typemap(csdirectorout) string "$cscall"
+
+%typemap(in, canthrow=1) string 
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return $null;
+   }
+   $1.assign($input); %}
+%typemap(out) string %{ $result = SWIG_csharp_string_callback($1.c_str()); %}
+
+%typemap(directorout, canthrow=1) string 
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return $null;
+   }
+   $result.assign($input); %}
+
+%typemap(directorin) string %{ $input = SWIG_csharp_string_callback($1.c_str()); %}
+
+%typemap(csin) string "$csinput"
+%typemap(csout, excode=SWIGEXCODE) string {
+    string ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(typecheck) string = char *;
+
+%typemap(throws, canthrow=1) string
+%{ SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.c_str());
+   return $null; %}
+
+// const string &
+%typemap(ctype) const string & "char *"
+%typemap(imtype) const string & "string"
+%typemap(cstype) const string & "string"
+
+%typemap(csdirectorin) const string & "$iminput"
+%typemap(csdirectorout) const string & "$cscall"
+
+%typemap(in, canthrow=1) const string &
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return $null;
+   }
+   $*1_ltype $1_str($input);
+   $1 = &$1_str; %}
+%typemap(out) const string & %{ $result = SWIG_csharp_string_callback($1->c_str()); %}
+
+%typemap(csin) const string & "$csinput"
+%typemap(csout, excode=SWIGEXCODE) const string & {
+    string ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(directorout, canthrow=1, warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return $null;
+   }
+   /* possible thread/reentrant code problem */
+   static $*1_ltype $1_str;
+   $1_str = $input;
+   $result = &$1_str; %}
+
+%typemap(directorin) const string & %{ $input = SWIG_csharp_string_callback($1.c_str()); %}
+
+%typemap(csvarin, excode=SWIGEXCODE2) const string & %{
+    set {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) const string & %{
+    get {
+      string ret = $imcall;$excode
+      return ret;
+    } %}
+
+%typemap(typecheck) const string & = char *;
+
+%typemap(throws, canthrow=1) const string &
+%{ SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.c_str());
+   return $null; %}
+
+}
+
diff --git a/share/swig/2.0.11/csharp/std_vector.i b/share/swig/2.0.11/csharp/std_vector.i
new file mode 100644
index 0000000..5a21ad3
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_vector.i
@@ -0,0 +1,421 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector<T>
+ * C# implementation
+ * The C# wrapper is made to look and feel like a C# System.Collections.Generic.List<> collection.
+ * For .NET 1 compatibility, define SWIG_DOTNET_1 when compiling the C# code; then the C# wrapper is 
+ * made to look and feel like a typesafe C# System.Collections.ArrayList.
+ *
+ * Note that IEnumerable<> is implemented in the proxy class which is useful for using LINQ with 
+ * C++ std::vector wrappers. The IList<> interface is also implemented to provide enhanced functionality
+ * whenever we are confident that the required C++ operator== is available. This is the case for when 
+ * T is a primitive type or a pointer. If T does define an operator==, then use the SWIG_STD_VECTOR_ENHANCED
+ * macro to obtain this enhanced functionality, for example:
+ *
+ *   SWIG_STD_VECTOR_ENHANCED(SomeNamespace::Klass)
+ *   %template(VectKlass) std::vector<SomeNamespace::Klass>;
+ *
+ * Warning: heavy macro usage in this file. Use swig -E to get a sane view on the real file contents!
+ * ----------------------------------------------------------------------------- */
+
+// Warning: Use the typemaps here in the expectation that the macros they are in will change name.
+
+
+%include <std_common.i>
+
+// MACRO for use within the std::vector class body
+%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CSINTERFACE, CONST_REFERENCE, CTYPE...)
+%typemap(csinterfaces) std::vector< CTYPE > "IDisposable, System.Collections.IEnumerable\n#if !SWIG_DOTNET_1\n    , System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n#endif\n";
+%typemap(cscode) std::vector< CTYPE > %{
+  public $csclassname(System.Collections.ICollection c) : this() {
+    if (c == null)
+      throw new ArgumentNullException("c");
+    foreach ($typemap(cstype, CTYPE) element in c) {
+      this.Add(element);
+    }
+  }
+
+  public bool IsFixedSize {
+    get {
+      return false;
+    }
+  }
+
+  public bool IsReadOnly {
+    get {
+      return false;
+    }
+  }
+
+  public $typemap(cstype, CTYPE) this[int index]  {
+    get {
+      return getitem(index);
+    }
+    set {
+      setitem(index, value);
+    }
+  }
+
+  public int Capacity {
+    get {
+      return (int)capacity();
+    }
+    set {
+      if (value < size())
+        throw new ArgumentOutOfRangeException("Capacity");
+      reserve((uint)value);
+    }
+  }
+
+  public int Count {
+    get {
+      return (int)size();
+    }
+  }
+
+  public bool IsSynchronized {
+    get {
+      return false;
+    }
+  }
+
+#if SWIG_DOTNET_1
+  public void CopyTo(System.Array array)
+#else
+  public void CopyTo($typemap(cstype, CTYPE)[] array)
+#endif
+  {
+    CopyTo(0, array, 0, this.Count);
+  }
+
+#if SWIG_DOTNET_1
+  public void CopyTo(System.Array array, int arrayIndex)
+#else
+  public void CopyTo($typemap(cstype, CTYPE)[] array, int arrayIndex)
+#endif
+  {
+    CopyTo(0, array, arrayIndex, this.Count);
+  }
+
+#if SWIG_DOTNET_1
+  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
+#else
+  public void CopyTo(int index, $typemap(cstype, CTYPE)[] array, int arrayIndex, int count)
+#endif
+  {
+    if (array == null)
+      throw new ArgumentNullException("array");
+    if (index < 0)
+      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
+    if (arrayIndex < 0)
+      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+    if (count < 0)
+      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
+    if (array.Rank > 1)
+      throw new ArgumentException("Multi dimensional array.", "array");
+    if (index+count > this.Count || arrayIndex+count > array.Length)
+      throw new ArgumentException("Number of elements to copy is too large.");
+    for (int i=0; i<count; i++)
+      array.SetValue(getitemcopy(index+i), arrayIndex+i);
+  }
+
+#if !SWIG_DOTNET_1
+  System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)> System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)>.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+#endif
+
+  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  public $csclassnameEnumerator GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  // Type-safe enumerator
+  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
+  /// whenever the collection is modified. This has been done for changes in the size of the
+  /// collection but not when one of the elements of the collection is modified as it is a bit
+  /// tricky to detect unmanaged code that modifies the collection under our feet.
+  public sealed class $csclassnameEnumerator : System.Collections.IEnumerator
+#if !SWIG_DOTNET_1
+    , System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)>
+#endif
+  {
+    private $csclassname collectionRef;
+    private int currentIndex;
+    private object currentObject;
+    private int currentSize;
+
+    public $csclassnameEnumerator($csclassname collection) {
+      collectionRef = collection;
+      currentIndex = -1;
+      currentObject = null;
+      currentSize = collectionRef.Count;
+    }
+
+    // Type-safe iterator Current
+    public $typemap(cstype, CTYPE) Current {
+      get {
+        if (currentIndex == -1)
+          throw new InvalidOperationException("Enumeration not started.");
+        if (currentIndex > currentSize - 1)
+          throw new InvalidOperationException("Enumeration finished.");
+        if (currentObject == null)
+          throw new InvalidOperationException("Collection modified.");
+        return ($typemap(cstype, CTYPE))currentObject;
+      }
+    }
+
+    // Type-unsafe IEnumerator.Current
+    object System.Collections.IEnumerator.Current {
+      get {
+        return Current;
+      }
+    }
+
+    public bool MoveNext() {
+      int size = collectionRef.Count;
+      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
+      if (moveOkay) {
+        currentIndex++;
+        currentObject = collectionRef[currentIndex];
+      } else {
+        currentObject = null;
+      }
+      return moveOkay;
+    }
+
+    public void Reset() {
+      currentIndex = -1;
+      currentObject = null;
+      if (collectionRef.Count != currentSize) {
+        throw new InvalidOperationException("Collection modified.");
+      }
+    }
+
+#if !SWIG_DOTNET_1
+    public void Dispose() {
+        currentIndex = -1;
+        currentObject = null;
+    }
+#endif
+  }
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef CTYPE value_type;
+    typedef CONST_REFERENCE const_reference;
+    %rename(Clear) clear;
+    void clear();
+    %rename(Add) push_back;
+    void push_back(CTYPE const& x);
+    size_type size() const;
+    size_type capacity() const;
+    void reserve(size_type n);
+    %newobject GetRange(int index, int count);
+    %newobject Repeat(CTYPE const& value, int count);
+    vector();
+    vector(const vector &other);
+    %extend {
+      vector(int capacity) throw (std::out_of_range) {
+        std::vector< CTYPE >* pv = 0;
+        if (capacity >= 0) {
+          pv = new std::vector< CTYPE >();
+          pv->reserve(capacity);
+       } else {
+          throw std::out_of_range("capacity");
+       }
+       return pv;
+      }
+      CTYPE getitemcopy(int index) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size())
+          return (*$self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+      const_reference getitem(int index) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size())
+          return (*$self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+      void setitem(int index, CTYPE const& val) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size())
+          (*$self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+      // Takes a deep copy of the elements unlike ArrayList.AddRange
+      void AddRange(const std::vector< CTYPE >& values) {
+        $self->insert($self->end(), values.begin(), values.end());
+      }
+      // Takes a deep copy of the elements unlike ArrayList.GetRange
+      std::vector< CTYPE > *GetRange(int index, int count) throw (std::out_of_range, std::invalid_argument) {
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)$self->size()+1 || index+count > (int)$self->size())
+          throw std::invalid_argument("invalid range");
+        return new std::vector< CTYPE >($self->begin()+index, $self->begin()+index+count);
+      }
+      void Insert(int index, CTYPE const& x) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size()+1)
+          $self->insert($self->begin()+index, x);
+        else
+          throw std::out_of_range("index");
+      }
+      // Takes a deep copy of the elements unlike ArrayList.InsertRange
+      void InsertRange(int index, const std::vector< CTYPE >& values) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size()+1)
+          $self->insert($self->begin()+index, values.begin(), values.end());
+        else
+          throw std::out_of_range("index");
+      }
+      void RemoveAt(int index) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size())
+          $self->erase($self->begin() + index);
+        else
+          throw std::out_of_range("index");
+      }
+      void RemoveRange(int index, int count) throw (std::out_of_range, std::invalid_argument) {
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)$self->size()+1 || index+count > (int)$self->size())
+          throw std::invalid_argument("invalid range");
+        $self->erase($self->begin()+index, $self->begin()+index+count);
+      }
+      static std::vector< CTYPE > *Repeat(CTYPE const& value, int count) throw (std::out_of_range) {
+        if (count < 0)
+          throw std::out_of_range("count");
+        return new std::vector< CTYPE >(count, value);
+      }
+      void Reverse() {
+        std::reverse($self->begin(), $self->end());
+      }
+      void Reverse(int index, int count) throw (std::out_of_range, std::invalid_argument) {
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)$self->size()+1 || index+count > (int)$self->size())
+          throw std::invalid_argument("invalid range");
+        std::reverse($self->begin()+index, $self->begin()+index+count);
+      }
+      // Takes a deep copy of the elements unlike ArrayList.SetRange
+      void SetRange(int index, const std::vector< CTYPE >& values) throw (std::out_of_range) {
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (index+values.size() > $self->size())
+          throw std::out_of_range("index");
+        std::copy(values.begin(), values.end(), $self->begin()+index);
+      }
+    }
+%enddef
+
+// Extra methods added to the collection class if operator== is defined for the class being wrapped
+// The class will then implement IList<>, which adds extra functionality
+%define SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE...)
+    %extend {
+      bool Contains(CTYPE const& value) {
+        return std::find($self->begin(), $self->end(), value) != $self->end();
+      }
+      int IndexOf(CTYPE const& value) {
+        int index = -1;
+        std::vector< CTYPE >::iterator it = std::find($self->begin(), $self->end(), value);
+        if (it != $self->end())
+          index = (int)(it - $self->begin());
+        return index;
+      }
+      int LastIndexOf(CTYPE const& value) {
+        int index = -1;
+        std::vector< CTYPE >::reverse_iterator rit = std::find($self->rbegin(), $self->rend(), value);
+        if (rit != $self->rend())
+          index = (int)($self->rend() - 1 - rit);
+        return index;
+      }
+      bool Remove(CTYPE const& value) {
+        std::vector< CTYPE >::iterator it = std::find($self->begin(), $self->end(), value);
+        if (it != $self->end()) {
+          $self->erase(it);
+	  return true;
+        }
+        return false;
+      }
+    }
+%enddef
+
+// Macros for std::vector class specializations/enhancements
+%define SWIG_STD_VECTOR_ENHANCED(CTYPE...)
+namespace std {
+  template<> class vector< CTYPE > {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(IList, %arg(CTYPE const&), %arg(CTYPE))
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE)
+  };
+}
+%enddef
+
+// Legacy macros
+%define SWIG_STD_VECTOR_SPECIALIZE(CSTYPE, CTYPE...)
+#warning SWIG_STD_VECTOR_SPECIALIZE macro deprecated, please see csharp/std_vector.i and switch to SWIG_STD_VECTOR_ENHANCED
+SWIG_STD_VECTOR_ENHANCED(CTYPE)
+%enddef
+
+%define SWIG_STD_VECTOR_SPECIALIZE_MINIMUM(CSTYPE, CTYPE...)
+#warning SWIG_STD_VECTOR_SPECIALIZE_MINIMUM macro deprecated, it is no longer required
+%enddef
+
+%{
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+%csmethodmodifiers std::vector::getitemcopy "private"
+%csmethodmodifiers std::vector::getitem "private"
+%csmethodmodifiers std::vector::setitem "private"
+%csmethodmodifiers std::vector::size "private"
+%csmethodmodifiers std::vector::capacity "private"
+%csmethodmodifiers std::vector::reserve "private"
+
+namespace std {
+  // primary (unspecialized) class template for std::vector
+  // does not require operator== to be defined
+  template<class T> class vector {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(IEnumerable, T const&, T)
+  };
+  // specialization for pointers
+  template<class T> class vector<T *> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(IList, T *const&, T *)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(T *)
+  };
+  // bool is specialized in the C++ standard - const_reference in particular
+  template<> class vector<bool> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(IList, bool, bool)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(bool)
+  };
+}
+
+// template specializations for std::vector
+// these provide extra collections methods as operator== is defined
+SWIG_STD_VECTOR_ENHANCED(char)
+SWIG_STD_VECTOR_ENHANCED(signed char)
+SWIG_STD_VECTOR_ENHANCED(unsigned char)
+SWIG_STD_VECTOR_ENHANCED(short)
+SWIG_STD_VECTOR_ENHANCED(unsigned short)
+SWIG_STD_VECTOR_ENHANCED(int)
+SWIG_STD_VECTOR_ENHANCED(unsigned int)
+SWIG_STD_VECTOR_ENHANCED(long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long)
+SWIG_STD_VECTOR_ENHANCED(long long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long long)
+SWIG_STD_VECTOR_ENHANCED(float)
+SWIG_STD_VECTOR_ENHANCED(double)
+SWIG_STD_VECTOR_ENHANCED(std::string) // also requires a %include <std_string.i>
+
diff --git a/share/swig/2.0.11/csharp/std_wstring.i b/share/swig/2.0.11/csharp/std_wstring.i
new file mode 100644
index 0000000..9142d36
--- /dev/null
+++ b/share/swig/2.0.11/csharp/std_wstring.i
@@ -0,0 +1,114 @@
+/* -----------------------------------------------------------------------------
+ * std_wstring.i
+ *
+ * Typemaps for std::wstring and const std::wstring&
+ * These are mapped to a C# String and are passed around by value.
+ *
+ * To use non-const std::wstring references use the following %apply.  Note 
+ * that they are passed by value.
+ * %apply const std::wstring & {std::wstring &};
+ * ----------------------------------------------------------------------------- */
+
+%include <wchar.i>
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+%naturalvar wstring;
+
+class wstring;
+
+// wstring
+%typemap(ctype, out="void *") wstring "wchar_t *"
+%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]") wstring "string"
+%typemap(cstype) wstring "string"
+%typemap(csdirectorin) wstring "$iminput"
+%typemap(csdirectorout) wstring "$cscall"
+
+%typemap(in, canthrow=1) wstring 
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
+    return $null;
+   }
+   $1.assign($input); %}
+%typemap(out) wstring %{ $result = SWIG_csharp_wstring_callback($1.c_str()); %}
+
+%typemap(directorout, canthrow=1) wstring 
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
+    return $null;
+   }
+   $result.assign($input); %}
+
+%typemap(directorin) wstring %{ $input = SWIG_csharp_wstring_callback($1.c_str()); %}
+
+%typemap(csin) wstring "$csinput"
+%typemap(csout, excode=SWIGEXCODE) wstring {
+    string ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(typecheck) wstring = wchar_t *;
+
+%typemap(throws, canthrow=1) wstring
+%{ std::string message($1.begin(), $1.end());
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, message.c_str());
+   return $null; %}
+
+// const wstring &
+%typemap(ctype, out="void *") const wstring & "wchar_t *"
+%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]") const wstring & "string"  
+%typemap(cstype) const wstring & "string"
+
+%typemap(csdirectorin) const wstring & "$iminput"
+%typemap(csdirectorout) const wstring & "$cscall"
+
+%typemap(in, canthrow=1) const wstring &
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
+    return $null;
+   }
+   std::wstring $1_str($input);
+   $1 = &$1_str; %}
+%typemap(out) const wstring & %{ $result = SWIG_csharp_wstring_callback($1->c_str()); %}
+
+%typemap(csin) const wstring & "$csinput"
+%typemap(csout, excode=SWIGEXCODE) const wstring & {
+    string ret = $imcall;$excode
+    return ret;
+  }
+
+%typemap(directorout, canthrow=1, warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const wstring &
+%{ if (!$input) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
+    return $null;
+   }
+   /* possible thread/reentrant code problem */
+   static std::wstring $1_str;
+   $1_str = $input;
+   $result = &$1_str; %}
+
+%typemap(directorin) const wstring & %{ $input = SWIG_csharp_wstring_callback($1.c_str()); %}
+
+%typemap(csvarin, excode=SWIGEXCODE2) const wstring & %{
+    set {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) const wstring & %{
+    get {
+      string ret = $imcall;$excode
+      return ret;
+    } %}
+
+%typemap(typecheck) const wstring & = wchar_t *;
+
+%typemap(throws, canthrow=1) const wstring &
+%{ std::string message($1.begin(), $1.end());
+   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, message.c_str());
+   return $null; %}
+
+}
+
diff --git a/share/swig/2.0.11/csharp/stl.i b/share/swig/2.0.11/csharp/stl.i
new file mode 100644
index 0000000..9d2e91e
--- /dev/null
+++ b/share/swig/2.0.11/csharp/stl.i
@@ -0,0 +1,12 @@
+/* -----------------------------------------------------------------------------
+ * stl.i
+ *
+ * Initial STL definition. extended as needed in each language
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
+
diff --git a/share/swig/2.0.11/csharp/typemaps.i b/share/swig/2.0.11/csharp/typemaps.i
new file mode 100644
index 0000000..79f5596
--- /dev/null
+++ b/share/swig/2.0.11/csharp/typemaps.i
@@ -0,0 +1,253 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer and reference handling typemap library
+ *
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers and C++ references.
+ * ----------------------------------------------------------------------------- */
+
+/*
+INPUT typemaps
+--------------
+
+These typemaps are used for pointer/reference parameters that are input only
+and are mapped to a C# input parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a simple
+input value.  That is, instead of passing a pointer or reference to an object,
+you would use a real value instead.
+
+        bool               *INPUT, bool               &INPUT
+        signed char        *INPUT, signed char        &INPUT
+        unsigned char      *INPUT, unsigned char      &INPUT
+        short              *INPUT, short              &INPUT
+        unsigned short     *INPUT, unsigned short     &INPUT
+        int                *INPUT, int                &INPUT
+        unsigned int       *INPUT, unsigned int       &INPUT
+        long               *INPUT, long               &INPUT
+        unsigned long      *INPUT, unsigned long      &INPUT
+        long long          *INPUT, long long          &INPUT
+        unsigned long long *INPUT, unsigned long long &INPUT
+        float              *INPUT, float              &INPUT
+        double             *INPUT, double             &INPUT
+         
+To use these, suppose you had a C function like this :
+
+        double fadd(double *a, double *b) {
+               return *a+*b;
+        }
+
+You could wrap it with SWIG as follows :
+        
+        %include <typemaps.i>
+        double fadd(double *INPUT, double *INPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INPUT { double *a, double *b };
+        double fadd(double *a, double *b);
+
+In C# you could then use it like this:
+        double answer = modulename.fadd(10.0, 20.0);
+*/
+
+%define INPUT_TYPEMAP(TYPE, CTYPE, CSTYPE)
+%typemap(ctype, out="void *") TYPE *INPUT, TYPE &INPUT "CTYPE"
+%typemap(imtype, out="IntPtr") TYPE *INPUT, TYPE &INPUT "CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *INPUT, TYPE &INPUT "CSTYPE"
+%typemap(csin) TYPE *INPUT, TYPE &INPUT "$csinput"
+
+%typemap(in) TYPE *INPUT, TYPE &INPUT
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(typecheck) TYPE *INPUT = TYPE;
+%typemap(typecheck) TYPE &INPUT = TYPE;
+%enddef
+
+INPUT_TYPEMAP(bool,               unsigned int,         bool)
+//INPUT_TYPEMAP(char,               char,                 char)
+INPUT_TYPEMAP(signed char,        signed char,          sbyte)
+INPUT_TYPEMAP(unsigned char,      unsigned char,        byte)
+INPUT_TYPEMAP(short,              short,                short)
+INPUT_TYPEMAP(unsigned short,     unsigned short,       ushort)
+INPUT_TYPEMAP(int,                int,                  int)
+INPUT_TYPEMAP(unsigned int,       unsigned int,         uint)
+INPUT_TYPEMAP(long,               long,                 int)
+INPUT_TYPEMAP(unsigned long,      unsigned long,        uint)
+INPUT_TYPEMAP(long long,          long long,            long)
+INPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong)
+INPUT_TYPEMAP(float,              float,                float)
+INPUT_TYPEMAP(double,             double,               double)
+
+#undef INPUT_TYPEMAP
+
+/*
+OUTPUT typemaps
+---------------
+
+These typemaps are used for pointer/reference parameters that are output only and
+are mapped to a C# output parameter.
+
+The following typemaps can be applied to turn a pointer or reference into an "output"
+value.  When calling a function, no input value would be given for
+a parameter, but an output value would be returned. In C#, the 'out' keyword is
+used when passing the parameter to a function that takes an output parameter.
+
+        bool               *OUTPUT, bool               &OUTPUT
+        signed char        *OUTPUT, signed char        &OUTPUT
+        unsigned char      *OUTPUT, unsigned char      &OUTPUT
+        short              *OUTPUT, short              &OUTPUT
+        unsigned short     *OUTPUT, unsigned short     &OUTPUT
+        int                *OUTPUT, int                &OUTPUT
+        unsigned int       *OUTPUT, unsigned int       &OUTPUT
+        long               *OUTPUT, long               &OUTPUT
+        unsigned long      *OUTPUT, unsigned long      &OUTPUT
+        long long          *OUTPUT, long long          &OUTPUT
+        unsigned long long *OUTPUT, unsigned long long &OUTPUT
+        float              *OUTPUT, float              &OUTPUT
+        double             *OUTPUT, double             &OUTPUT
+         
+For example, suppose you were trying to wrap the modf() function in the
+C math library which splits x into integral and fractional parts (and
+returns the integer part in one of its parameters):
+
+        double modf(double x, double *ip);
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double modf(double x, double *OUTPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *OUTPUT { double *ip };
+        double modf(double x, double *ip);
+
+The C# output of the function would be the function return value and the 
+value returned in the second output parameter. In C# you would use it like this:
+
+    double dptr;
+    double fraction = modulename.modf(5, out dptr);
+*/
+
+%define OUTPUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"
+%typemap(imtype, out="IntPtr") TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
+%typemap(csin) TYPE *OUTPUT, TYPE &OUTPUT "out $csinput"
+
+%typemap(in) TYPE *OUTPUT, TYPE &OUTPUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *OUTPUT, TYPE &OUTPUT ""
+%enddef
+
+OUTPUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//OUTPUT_TYPEMAP(char,               char,                 char,     CHAR_PTR)
+OUTPUT_TYPEMAP(signed char,        signed char,          sbyte,    INT8_PTR)
+OUTPUT_TYPEMAP(unsigned char,      unsigned char,        byte,     UINT8_PTR)
+OUTPUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+OUTPUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+OUTPUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+OUTPUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+OUTPUT_TYPEMAP(long,               long,                 int,      INT32_PTR)
+OUTPUT_TYPEMAP(unsigned long,      unsigned long,        uint,     UINT32_PTR)
+OUTPUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+OUTPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+OUTPUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+OUTPUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+#undef OUTPUT_TYPEMAP
+
+%typemap(in) bool *OUTPUT, bool &OUTPUT
+%{ *$input = 0; 
+   $1 = ($1_ltype)$input; %}
+
+
+/*
+INOUT typemaps
+--------------
+
+These typemaps are for pointer/reference parameters that are both input and
+output and are mapped to a C# reference parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a
+reference parameters, that is the parameter is both an input and an output.
+In C#, the 'ref' keyword is used for reference parameters.
+
+        bool               *INOUT, bool               &INOUT
+        signed char        *INOUT, signed char        &INOUT
+        unsigned char      *INOUT, unsigned char      &INOUT
+        short              *INOUT, short              &INOUT
+        unsigned short     *INOUT, unsigned short     &INOUT
+        int                *INOUT, int                &INOUT
+        unsigned int       *INOUT, unsigned int       &INOUT
+        long               *INOUT, long               &INOUT
+        unsigned long      *INOUT, unsigned long      &INOUT
+        long long          *INOUT, long long          &INOUT
+        unsigned long long *INOUT, unsigned long long &INOUT
+        float              *INOUT, float              &INOUT
+        double             *INOUT, double             &INOUT
+         
+For example, suppose you were trying to wrap the following function :
+
+        void neg(double *x) {
+             *x = -(*x);
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        void neg(double *INOUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *x };
+        void neg(double *x);
+
+The C# output of the function would be the new value returned by the 
+reference parameter. In C# you would use it like this:
+
+
+       double x = 5.0;
+       neg(ref x);
+
+The implementation of the OUTPUT and INOUT typemaps is different to the scripting
+languages in that the scripting languages will return the output value as part 
+of the function return value.
+
+*/
+
+%define INOUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *INOUT, TYPE &INOUT "CTYPE *"
+%typemap(imtype, out="IntPtr") TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
+%typemap(csin) TYPE *INOUT, TYPE &INOUT "ref $csinput"
+
+%typemap(in) TYPE *INOUT, TYPE &INOUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *INOUT, TYPE &INOUT ""
+%enddef
+
+INOUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//INOUT_TYPEMAP(char,               char,                 char,     CHAR_PTR)
+INOUT_TYPEMAP(signed char,        signed char,          sbyte,    INT8_PTR)
+INOUT_TYPEMAP(unsigned char,      unsigned char,        byte,     UINT8_PTR)
+INOUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+INOUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+INOUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+INOUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+INOUT_TYPEMAP(long,               long,                 int,      INT32_PTR)
+INOUT_TYPEMAP(unsigned long,      unsigned long,        uint,     UINT32_PTR)
+INOUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+INOUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+INOUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+INOUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+#undef INOUT_TYPEMAP
+
diff --git a/share/swig/2.0.11/csharp/wchar.i b/share/swig/2.0.11/csharp/wchar.i
new file mode 100644
index 0000000..1d95edd
--- /dev/null
+++ b/share/swig/2.0.11/csharp/wchar.i
@@ -0,0 +1,102 @@
+/* -----------------------------------------------------------------------------
+ * wchar.i
+ *
+ * Typemaps for the wchar_t type
+ * These are mapped to a C# String and are passed around by value.
+ *
+ * Support code for wide strings can be turned off by defining SWIG_CSHARP_NO_WSTRING_HELPER
+ *
+ * ----------------------------------------------------------------------------- */
+
+#if !defined(SWIG_CSHARP_NO_WSTRING_HELPER)
+#if !defined(SWIG_CSHARP_WSTRING_HELPER_)
+#define SWIG_CSHARP_WSTRING_HELPER_
+%insert(runtime) %{
+/* Callback for returning strings to C# without leaking memory */
+typedef void * (SWIGSTDCALL* SWIG_CSharpWStringHelperCallback)(const wchar_t *);
+static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_callback = NULL;
+%}
+
+%pragma(csharp) imclasscode=%{
+  protected class SWIGWStringHelper {
+
+    public delegate string SWIGWStringDelegate(IntPtr message);
+    static SWIGWStringDelegate wstringDelegate = new SWIGWStringDelegate(CreateWString);
+
+    [DllImport("$dllimport", EntryPoint="SWIGRegisterWStringCallback_$module")]
+    public static extern void SWIGRegisterWStringCallback_$module(SWIGWStringDelegate wstringDelegate);
+
+    static string CreateWString([MarshalAs(UnmanagedType.LPWStr)]IntPtr cString) {
+      return System.Runtime.InteropServices.Marshal.PtrToStringUni(cString);
+    }
+
+    static SWIGWStringHelper() {
+      SWIGRegisterWStringCallback_$module(wstringDelegate);
+    }
+  }
+
+  static protected SWIGWStringHelper swigWStringHelper = new SWIGWStringHelper();
+%}
+
+%insert(runtime) %{
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_$module(SWIG_CSharpWStringHelperCallback callback) {
+  SWIG_csharp_wstring_callback = callback;
+}
+%}
+#endif // SWIG_CSHARP_WSTRING_HELPER_
+#endif // SWIG_CSHARP_NO_WSTRING_HELPER
+
+
+// wchar_t
+%typemap(ctype) wchar_t "wchar_t"
+%typemap(imtype) wchar_t "char"
+%typemap(cstype) wchar_t "char"
+
+%typemap(csin) wchar_t "$csinput"
+%typemap(csout, excode=SWIGEXCODE) wchar_t {
+    char ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csvarin, excode=SWIGEXCODE2) wchar_t %{
+    set {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) wchar_t %{
+    get {
+      char ret = $imcall;$excode
+      return ret;
+    } %}
+
+%typemap(in) wchar_t %{ $1 = ($1_ltype)$input; %}
+%typemap(out) wchar_t %{ $result = (wchar_t)$1; %}
+
+%typemap(typecheck) wchar_t = char;
+
+// wchar_t *
+%typemap(ctype) wchar_t * "wchar_t *"
+%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]", out="IntPtr" ) wchar_t * "string"
+%typemap(cstype) wchar_t * "string"
+
+%typemap(csin) wchar_t * "$csinput"
+%typemap(csout, excode=SWIGEXCODE) wchar_t * {
+    string ret = System.Runtime.InteropServices.Marshal.PtrToStringUni($imcall);$excode
+    return ret;
+  }
+%typemap(csvarin, excode=SWIGEXCODE2) wchar_t * %{
+    set {
+      $imcall;$excode
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) wchar_t * %{
+    get {
+      string ret = $imcall;$excode
+      return ret;
+    } %}
+
+%typemap(in) wchar_t * %{ $1 = ($1_ltype)$input; %}
+%typemap(out) wchar_t * %{ $result = (wchar_t *)$1; %}
+
+%typemap(typecheck) wchar_t * = char *;
+
diff --git a/share/swig/2.0.11/cstring.i b/share/swig/2.0.11/cstring.i
new file mode 100644
index 0000000..6829f75
--- /dev/null
+++ b/share/swig/2.0.11/cstring.i
@@ -0,0 +1,12 @@
+/* -----------------------------------------------------------------------------
+ * cstring.i
+ * ----------------------------------------------------------------------------- */
+
+%echo "cstring.i not implemented for this target"
+#define SWIG_CSTRING_UNIMPL
+
+/* old name keep for compatibility */
+#define _CSTRING_UNIMPL 
+
+
+
diff --git a/share/swig/2.0.11/cwstring.i b/share/swig/2.0.11/cwstring.i
new file mode 100644
index 0000000..f0631d3
--- /dev/null
+++ b/share/swig/2.0.11/cwstring.i
@@ -0,0 +1,11 @@
+/* -----------------------------------------------------------------------------
+ * cwstring.i
+ * ----------------------------------------------------------------------------- */
+
+%echo "cwstring.i not implemented for this target"
+#define SWIG_CWSTRING_UNIMPL
+
+
+
+
+
diff --git a/share/swig/2.0.11/d/boost_shared_ptr.i b/share/swig/2.0.11/d/boost_shared_ptr.i
new file mode 100644
index 0000000..bfa2aa6
--- /dev/null
+++ b/share/swig/2.0.11/d/boost_shared_ptr.i
@@ -0,0 +1,201 @@
+%include <shared_ptr.i>
+
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor mods
+%feature("unref") TYPE
+//"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ((*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\"))) << \"]\" << endl << flush; }\n"
+                               "(void)arg1; delete smartarg1;"
+
+
+// plain value
+%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0) %{
+  argp = ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0;
+  if (!argp) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Attempt to dereference null $1_type");
+    return $null;
+  }
+  $1 = *argp; %}
+%typemap(out) CONST TYPE
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+
+// plain pointer
+%typemap(in, canthrow=1) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
+  smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input;
+  $1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{
+  $result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+%}
+
+// plain reference
+%typemap(in, canthrow=1) CONST TYPE & %{
+  $1 = ($1_ltype)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+  if (!$1) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type reference is null");
+    return $null;
+  } %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// plain pointer by reference
+%typemap(in) TYPE *CONST& ($*1_ltype temp = 0)
+%{ temp = (TYPE *)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+   $1 = &temp; %}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST&
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ if ($input) $1 = *($&1_ltype)$input; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ $result = $1 ? new $1_ltype($1) : 0; %}
+
+// shared_ptr by reference
+%typemap(in, canthrow=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &
+%{ $result = *$1 ? new $*1_ltype(*$1) : 0; %}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out, fragment="SWIG_null_deleter") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
+%{ $result = ($1 && *$1) ? new $*1_ltype(*($1_ltype)$1) : 0;
+   if ($owner) delete $1; %}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempnull, $*1_ltype temp = 0)
+%{ temp = $input ? *($1_ltype)&$input : &tempnull;
+   $1 = &temp; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *&
+%{ *($1_ltype)&$result = (*$1 && **$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0; %}
+
+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+
+
+%typemap (ctype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "void *"
+%typemap (imtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "void*"
+%typemap (dtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(dtype, TYPE)"
+
+%typemap(din) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(dtype, TYPE).swigGetCPtr($dinput)"
+
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE {
+  auto ret = new $typemap(dtype, TYPE)($imcall, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE & {
+  auto ret = new $typemap(dtype, TYPE)($imcall, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE * {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) TYPE *CONST& {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+// For shared pointers, both the derived and the base class have to »own« their
+// pointer; otherwise the reference count is not decreased properly on destruction.
+%typemap(dbody) SWIGTYPE %{
+private void* swigCPtr;
+private bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+%}
+
+%typemap(dbody_derived) SWIGTYPE %{
+private void* swigCPtr;
+private bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  super($imdmodule.$dclazznameSmartPtrUpcast(cObject), ownCObject);
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+%}
+
+%typemap(ddispose, methodname="dispose", methodmodifiers="public") TYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+    }
+  }
+}
+
+%typemap(ddispose_derived, methodname="dispose", methodmodifiers="public") TYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+      super.dispose();
+    }
+  }
+}
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
diff --git a/share/swig/2.0.11/d/carrays.i b/share/swig/2.0.11/d/carrays.i
new file mode 100644
index 0000000..37b59c8
--- /dev/null
+++ b/share/swig/2.0.11/d/carrays.i
@@ -0,0 +1,111 @@
+/* -----------------------------------------------------------------------------
+ * carrays.i
+ *
+ * D-specific version of ../carrays.i.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %array_functions(TYPE,NAME)
+ *
+ * Generates functions for creating and accessing elements of a C array
+ * (as pointers).  Creates the following functions:
+ *
+ *        TYPE *new_NAME(int nelements)
+ *        void delete_NAME(TYPE *);
+ *        TYPE NAME_getitem(TYPE *, int index);
+ *        void NAME_setitem(TYPE *, int index, TYPE value);
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %array_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME(int nelements) { %}
+#ifdef __cplusplus
+%{  return new TYPE[nelements]; %}
+#else
+%{  return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *ary) { %}
+#ifdef __cplusplus
+%{  delete [] ary; %}
+#else
+%{  free(ary); %}
+#endif
+%{}
+
+static TYPE NAME##_getitem(TYPE *ary, int index) {
+    return ary[index];
+}
+static void NAME##_setitem(TYPE *ary, int index, TYPE value) {
+    ary[index] = value;
+}
+%}
+
+TYPE *new_##NAME(int nelements);
+void delete_##NAME(TYPE *ary);
+TYPE NAME##_getitem(TYPE *ary, int index);
+void NAME##_setitem(TYPE *ary, int index, TYPE value);
+
+%enddef
+
+
+/* -----------------------------------------------------------------------------
+ * %array_class(TYPE,NAME)
+ *
+ * Generates a class wrapper around a C array.  The class has the following
+ * interface:
+ *
+ *          struct NAME {
+ *              NAME(int nelements);
+ *             ~NAME();
+ *              TYPE getitem(int index);
+ *              void setitem(int index, TYPE value);
+ *              TYPE * ptr();
+ *              static NAME *frompointer(TYPE *t);
+  *         }
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %array_class(TYPE,NAME)
+%{
+typedef TYPE NAME;
+%}
+
+typedef struct {} NAME;
+
+%extend NAME {
+#ifdef __cplusplus
+  NAME(int nelements) {
+    return new TYPE[nelements];
+  }
+  ~NAME() {
+    delete [] self;
+  }
+#else
+  NAME(int nelements) {
+    return (TYPE *) calloc(nelements,sizeof(TYPE));
+  }
+  ~NAME() {
+    free(self);
+  }
+#endif
+
+  TYPE getitem(int index) {
+    return self[index];
+  }
+  void setitem(int index, TYPE value) {
+    self[index] = value;
+  }
+  TYPE * ptr() {
+    return self;
+  }
+  static NAME *frompointer(TYPE *t) {
+    return (NAME *) t;
+  }
+};
+
+%types(NAME = TYPE);
+
+%enddef
diff --git a/share/swig/2.0.11/d/cpointer.i b/share/swig/2.0.11/d/cpointer.i
new file mode 100644
index 0000000..75e610f
--- /dev/null
+++ b/share/swig/2.0.11/d/cpointer.i
@@ -0,0 +1,171 @@
+/* -----------------------------------------------------------------------------
+ * cpointer.i
+ *
+ * D-specific version of ../cpointer.i.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %pointer_class(type,name)
+ *
+ * Places a simple proxy around a simple type like 'int', 'float', or whatever.
+ * The proxy provides this interface:
+ *
+ *       class type {
+ *       public:
+ *           type();
+ *          ~type();
+ *           type value();
+ *           void assign(type value);
+ *       };
+ *
+ * Example:
+ *
+ *    %pointer_class(int, intp);
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = intp()
+ *    >>> a.assign(10)
+ *    >>> a.value()
+ *    10
+ *    >>> b = intp()
+ *    >>> b.assign(20)
+ *    >>> print add(a,b)
+ *    30
+ *
+ * As a general rule, this macro should not be used on class/structures that
+ * are already defined in the interface.
+ * ----------------------------------------------------------------------------- */
+
+
+%define %pointer_class(TYPE, NAME)
+%{
+typedef TYPE NAME;
+%}
+
+typedef struct {
+} NAME;
+
+%extend NAME {
+#ifdef __cplusplus
+NAME() {
+  return new TYPE();
+}
+~NAME() {
+  if (self) delete self;
+}
+#else
+NAME() {
+  return (TYPE *) calloc(1,sizeof(TYPE));
+}
+~NAME() {
+  if (self) free(self);
+}
+#endif
+}
+
+%extend NAME {
+
+void assign(TYPE value) {
+  *self = value;
+}
+TYPE value() {
+  return *self;
+}
+TYPE * ptr() {
+  return self;
+}
+static NAME * frompointer(TYPE *t) {
+  return (NAME *) t;
+}
+
+}
+
+%types(NAME = TYPE);
+
+%enddef
+
+/* -----------------------------------------------------------------------------
+ * %pointer_functions(type,name)
+ *
+ * Create functions for allocating/deallocating pointers.   This can be used
+ * if you don't want to create a proxy class or if the pointer is complex.
+ *
+ *    %pointer_functions(int, intp)
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = copy_intp(10)
+ *    >>> intp_value(a)
+ *    10
+ *    >>> b = new_intp()
+ *    >>> intp_assign(b,20)
+ *    >>> print add(a,b)
+ *    30
+ *    >>> delete_intp(a)
+ *    >>> delete_intp(b)
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME() { %}
+#ifdef __cplusplus
+%{  return new TYPE(); %}
+#else
+%{  return (TYPE *) calloc(1,sizeof(TYPE)); %}
+#endif
+%{}
+
+static TYPE *copy_##NAME(TYPE value) { %}
+#ifdef __cplusplus
+%{  return new TYPE(value); %}
+#else
+%{  TYPE *self = (TYPE *) calloc(1,sizeof(TYPE));
+  *self = value;
+  return self; %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *self) { %}
+#ifdef __cplusplus
+%{  if (self) delete self; %}
+#else
+%{  if (self) free(self); %}
+#endif
+%{}
+
+static void NAME ##_assign(TYPE *self, TYPE value) {
+  *self = value;
+}
+
+static TYPE NAME ##_value(TYPE *self) {
+  return *self;
+}
+%}
+
+TYPE *new_##NAME();
+TYPE *copy_##NAME(TYPE value);
+void  delete_##NAME(TYPE *self);
+void  NAME##_assign(TYPE *self, TYPE value);
+TYPE  NAME##_value(TYPE *self);
+
+%enddef
+
+/* -----------------------------------------------------------------------------
+ * %pointer_cast(type1,type2,name)
+ *
+ * Generates a pointer casting function.
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_cast(TYPE1,TYPE2,NAME)
+%inline %{
+TYPE2 NAME(TYPE1 x) {
+   return (TYPE2) x;
+}
+%}
+%enddef
diff --git a/share/swig/2.0.11/d/d.swg b/share/swig/2.0.11/d/d.swg
new file mode 100644
index 0000000..f5bb459
--- /dev/null
+++ b/share/swig/2.0.11/d/d.swg
@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * d.swg
+ *
+ * Main library file for the D language module. See the D chapter in the SWIG
+ * manual for explanation on the typemaps, pragmas, etc. used.
+ * ----------------------------------------------------------------------------- */
+
+// Typemaps for exception handling.
+%include <dexception.swg>
+
+// Typemaps for primitive types.
+%include <dprimitives.swg>
+
+// Typemaps for non-primitive types (C/C++ classes and structs).
+%include <dswigtype.swg>
+
+// Typemaps for enumeration types.
+%include <denums.swg>
+
+// Typemaps for member function pointers.
+%include <dmemberfunctionpointers.swg>
+
+// Typemaps for wrapping pointers to/arrays of C chars as D strings.
+%include <dstrings.swg>
+
+// Typemaps for handling void function return types and empty parameter lists.
+%include <dvoid.swg>
+
+// Typemaps containing D code used when generating D proxy classes.
+%include <dclassgen.swg>
+
+// Mapping of C++ operator overloading methods to D.
+%include <doperators.swg>
+
+// Helper code string and exception handling.
+%include <dhead.swg>
+
+// Wrapper loader code for dynamically linking the C wrapper library from the D
+// wrapper module.
+%include <wrapperloader.swg>
+
+// List of all reserved D keywords.
+%include <dkw.swg>
+
+// D-specific directives.
+%include <ddirectives.swg>
diff --git a/share/swig/2.0.11/d/dclassgen.swg b/share/swig/2.0.11/d/dclassgen.swg
new file mode 100644
index 0000000..ceaf507
--- /dev/null
+++ b/share/swig/2.0.11/d/dclassgen.swg
@@ -0,0 +1,142 @@
+/* -----------------------------------------------------------------------------
+ * dclassgen.swg
+ *
+ * Typemaps containing D code used when generating D proxy classes.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(dbase)               SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dclassmodifiers)     SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "class"
+%typemap(dcode)               SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dimports)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dinterfaces)         SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dinterfaces_derived) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+
+// See <denums.swg>.
+%typemap(dclassmodifiers) enum SWIGTYPE "enum"
+%typemap(dcode) enum SWIGTYPE ""
+
+
+/*
+ * Proxy classes.
+ */
+
+%typemap(dconstructor, excode=SWIGEXCODE,directorconnect="\n  swigDirectorConnect();") SWIGTYPE {
+  this($imcall, true);$excode$directorconnect
+}
+
+%typemap(ddestructor) SWIGTYPE %{
+~this() {
+  dispose();
+}
+%}
+
+// We do not use »override« attribute for generated dispose() methods to stay
+// somewhat compatible to Phobos and older Tango versions where Object.dispose()
+// does not exist.
+%typemap(ddispose, methodname="dispose", methodmodifiers="public") SWIGTYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+    }
+  }
+}
+
+%typemap(ddispose_derived, methodname="dispose", methodmodifiers="public") SWIGTYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+      super.dispose();
+    }
+  }
+}
+
+
+// Unfortunately, the »package« visibility attribute does not work in D when the
+// module in question is in the root package (happens if no -package is specified
+// at the SWIG command line), so we are stuck with public visibility for
+// swigGetCPtr().
+%typemap(dbody) SWIGTYPE %{
+private void* swigCPtr;
+protected bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+%typemap(dbody_derived) SWIGTYPE %{
+private void* swigCPtr;
+
+public this(void* cObject, bool ownCObject) {
+  super($imdmodule.$dclazznameUpcast(cObject), ownCObject);
+  swigCPtr = cObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+/*
+ * Type wrapper classes.
+ */
+
+%typemap(dbody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] %{
+private void* swigCPtr;
+
+public this(void* cObject, bool futureUse) {
+  swigCPtr = cObject;
+}
+
+protected this() {
+  swigCPtr = null;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+/*
+ * Member function pointer wrapper classes (see <dmemberfunctionpointers.swg>).
+ */
+
+%typemap(dbody) SWIGTYPE (CLASS::*) %{
+private char* swigCPtr;
+
+public this(char* cMemberPtr, bool futureUse) {
+  swigCPtr = cMemberPtr;
+}
+
+protected this() {
+  swigCPtr = null;
+}
+
+package static char* swigGetCMemberPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
diff --git a/share/swig/2.0.11/d/ddirectives.swg b/share/swig/2.0.11/d/ddirectives.swg
new file mode 100644
index 0000000..6972a0c
--- /dev/null
+++ b/share/swig/2.0.11/d/ddirectives.swg
@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * ddirectives.swg
+ *
+ * D-specifiv directives.
+ * ----------------------------------------------------------------------------- */
+
+#define %dmanifestconst             %feature("d:manifestconst")
+#define %dconstvalue(value)         %feature("d:constvalue",value)
+#define %dmethodmodifiers           %feature("d:methodmodifiers")
+#define %dnothrowexception          %feature("except")
diff --git a/share/swig/2.0.11/d/denums.swg b/share/swig/2.0.11/d/denums.swg
new file mode 100644
index 0000000..5917da9
--- /dev/null
+++ b/share/swig/2.0.11/d/denums.swg
@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------------
+ * denums.swg
+ *
+ * Typemaps for enumerations.
+ * ----------------------------------------------------------------------------- */
+
+
+/*
+ * Typemaps for enumeration types.
+ */
+
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(dtype, cprimitive="1") enum SWIGTYPE "$dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(ddirectorin) enum SWIGTYPE "cast($dclassname)$winput"
+%typemap(ddirectorout) enum SWIGTYPE "cast(int)$dcall"
+
+%typemap(din) enum SWIGTYPE "cast(int)$dinput"
+%typemap(dout, excode=SWIGEXCODE) enum SWIGTYPE {
+  $dclassname ret = cast($dclassname)$imcall;$excode
+  return ret;
+}
+
+
+/*
+ * Typemaps for (const) references to enumeration types.
+ */
+
+%typemap(ctype) const enum SWIGTYPE & "int"
+%typemap(imtype) const enum SWIGTYPE & "int"
+%typemap(dtype) const enum SWIGTYPE & "$*dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input;
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+
+%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input;
+   $result = &temp; %}
+
+%typemap(ddirectorin) const enum SWIGTYPE & "cast($*dclassname)$winput"
+%typemap(ddirectorout) const enum SWIGTYPE & "cast(int)$dcall"
+
+%typemap(din) const enum SWIGTYPE & "cast(int)$dinput"
+%typemap(dout, excode=SWIGEXCODE) const enum SWIGTYPE & {
+  $*dclassname ret = cast($*dclassname)$imcall;$excode
+  return ret;
+}
diff --git a/share/swig/2.0.11/d/dexception.swg b/share/swig/2.0.11/d/dexception.swg
new file mode 100644
index 0000000..1aadbaa
--- /dev/null
+++ b/share/swig/2.0.11/d/dexception.swg
@@ -0,0 +1,30 @@
+/* -----------------------------------------------------------------------------
+ * dexception.swg
+ *
+ * Typemaps used for propagating C++ exceptions to D.
+ * ----------------------------------------------------------------------------- */
+
+// Code which is inserted into the dout typemaps and class constructors via
+// excode if exceptions can be thrown.
+%define SWIGEXCODE "\n  if ($imdmodule.SwigPendingException.isPending) throw $imdmodule.SwigPendingException.retrieve();" %enddef
+
+%typemap(throws, canthrow=1) int,
+                 long,
+                 short,
+                 unsigned int,
+                 unsigned long,
+                 unsigned short
+%{ char error_msg[256];
+   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
+   SWIG_DSetPendingException(SWIG_DException, error_msg);
+   return $null; %}
+
+%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY],
+  enum SWIGTYPE, const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_DSetPendingException(SWIG_DException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(throws, canthrow=1) char *
+%{ SWIG_DSetPendingException(SWIG_DException, $1);
+   return $null; %}
diff --git a/share/swig/2.0.11/d/dhead.swg b/share/swig/2.0.11/d/dhead.swg
new file mode 100644
index 0000000..7a2f4fd
--- /dev/null
+++ b/share/swig/2.0.11/d/dhead.swg
@@ -0,0 +1,344 @@
+/* -----------------------------------------------------------------------------
+ * dhead.swg
+ *
+ * Support code for exceptions if the SWIG_D_NO_EXCEPTION_HELPER is not defined
+ * Support code for strings if the SWIG_D_NO_STRING_HELPER is not defined
+ *
+ * Support code for function pointers. ----------------------------------------------------------------------------- */
+
+%insert(runtime) %{
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* Contract support. */
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_DSetPendingException(SWIG_DException, msg); return nullreturn; } else
+%}
+
+
+/*
+ * Exception support code.
+ */
+
+#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+%insert(runtime) %{
+// Support for throwing D exceptions from C/C++.
+typedef enum {
+  SWIG_DException = 0,
+  SWIG_DIllegalArgumentException,
+  SWIG_DIllegalElementException,
+  SWIG_DIOException,
+  SWIG_DNoSuchElementException,
+} SWIG_DExceptionCodes;
+
+typedef void (* SWIG_DExceptionCallback_t)(const char *);
+
+typedef struct {
+  SWIG_DExceptionCodes code;
+  SWIG_DExceptionCallback_t callback;
+} SWIG_DException_t;
+
+static SWIG_DException_t SWIG_d_exceptions[] = {
+  { SWIG_DException, NULL },
+  { SWIG_DIllegalArgumentException, NULL },
+  { SWIG_DIllegalElementException, NULL },
+  { SWIG_DIOException, NULL },
+  { SWIG_DNoSuchElementException, NULL }
+};
+
+static void SWIGUNUSED SWIG_DSetPendingException(SWIG_DExceptionCodes code, const char *msg) {
+  if ((size_t)code < sizeof(SWIG_d_exceptions)/sizeof(SWIG_DException_t)) {
+    SWIG_d_exceptions[code].callback(msg);
+  } else {
+    SWIG_d_exceptions[SWIG_DException].callback(msg);
+  }
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGRegisterExceptionCallbacks_$module(
+  SWIG_DExceptionCallback_t exceptionCallback,
+  SWIG_DExceptionCallback_t illegalArgumentCallback,
+  SWIG_DExceptionCallback_t illegalElementCallback,
+  SWIG_DExceptionCallback_t ioCallback,
+  SWIG_DExceptionCallback_t noSuchElementCallback) {
+  SWIG_d_exceptions[SWIG_DException].callback = exceptionCallback;
+  SWIG_d_exceptions[SWIG_DIllegalArgumentException].callback = illegalArgumentCallback;
+  SWIG_d_exceptions[SWIG_DIllegalElementException].callback = illegalElementCallback;
+  SWIG_d_exceptions[SWIG_DIOException].callback = ioCallback;
+  SWIG_d_exceptions[SWIG_DNoSuchElementException].callback = noSuchElementCallback;
+}
+%}
+
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmoduleimports=%{
+// Exception throwing support currently requires Tango, but there is no reason
+// why it could not support Phobos.
+static import tango.core.Exception;
+static import tango.core.Thread;
+static import tango.stdc.stringz;
+%}
+
+%pragma(d) imdmodulecode=%{
+private class SwigExceptionHelper {
+  static this() {
+    swigRegisterExceptionCallbacks$module(
+      &setException,
+      &setIllegalArgumentException,
+      &setIllegalElementException,
+      &setIOException,
+      &setNoSuchElementException);
+  }
+
+  static void setException(char* message) {
+    auto exception = new object.Exception(tango.stdc.stringz.fromStringz(message).dup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+
+  static void setIllegalArgumentException(char* message) {
+    auto exception = new tango.core.Exception.IllegalArgumentException(tango.stdc.stringz.fromStringz(message).dup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+
+  static void setIllegalElementException(char* message) {
+    auto exception = new tango.core.Exception.IllegalElementException(tango.stdc.stringz.fromStringz(message).dup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+
+  static void setIOException(char* message) {
+    auto exception = new tango.core.Exception.IOException(tango.stdc.stringz.fromStringz(message).dup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+
+  static void setNoSuchElementException(char* message) {
+    auto exception = new tango.core.Exception.NoSuchElementException(tango.stdc.stringz.fromStringz(message).dup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+}
+
+package class SwigPendingException {
+public:
+  static this() {
+    m_sPendingCount = 0;
+    m_sPendingException = new ThreadLocalData(null);
+  }
+
+  static bool isPending() {
+    bool pending = false;
+    if (m_sPendingCount > 0) {
+      if (m_sPendingException.val !is null) {
+        pending = true;
+      }
+    }
+    return pending;
+  }
+
+  static void set(object.Exception e) {
+    if (m_sPendingException.val !is null) {
+      throw new object.Exception("FATAL: An earlier pending exception from C/C++ code " ~
+        "was missed and thus not thrown (" ~ m_sPendingException.val.classinfo.name ~
+        ": " ~ m_sPendingException.val.msg ~ ")!", e);
+    }
+
+    m_sPendingException.val = e;
+    synchronized {
+      ++m_sPendingCount;
+    }
+  }
+
+  static object.Exception retrieve() {
+    object.Exception e = null;
+    if (m_sPendingCount > 0) {
+      if (m_sPendingException.val !is null) {
+        e = m_sPendingException.val;
+        m_sPendingException.val = null;
+        synchronized {
+          --m_sPendingCount;
+        }
+      }
+    }
+    return e;
+  }
+
+private:
+  // The pending exception counter is stored thread-global.
+  static int m_sPendingCount;
+
+  // The reference to the pending exception (if any) is stored thread-local.
+  alias tango.core.Thread.ThreadLocal!(object.Exception) ThreadLocalData;
+  static ThreadLocalData m_sPendingException;
+}
+alias void function(char* message) SwigExceptionCallback;
+%}
+#else
+%pragma(d) imdmoduleimports=%{
+static import std.conv;
+%}
+
+%pragma(d) imdmodulecode=%{
+private class SwigExceptionHelper {
+  static this() {
+	// The D1/Tango version maps C++ exceptions to multiple exception types.
+    swigRegisterExceptionCallbacks$module(
+      &setException,
+      &setException,
+      &setException,
+      &setException,
+      &setException
+    );
+  }
+
+  static void setException(const char* message) {
+    auto exception = new object.Exception(std.conv.to!string(message).idup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+}
+
+package struct SwigPendingException {
+public:
+  static this() {
+    m_sPendingCount = 0;
+    m_sPendingException = null;
+  }
+
+  static bool isPending() {
+    bool pending = false;
+    if (m_sPendingCount > 0) {
+      if (m_sPendingException !is null) {
+        pending = true;
+      }
+    }
+    return pending;
+  }
+
+  static void set(object.Exception e) {
+    if (m_sPendingException !is null) {
+      throw new object.Exception("FATAL: An earlier pending exception from C/C++ code " ~
+        "was missed and thus not thrown (" ~ m_sPendingException.classinfo.name ~
+        ": " ~ m_sPendingException.msg ~ ")!", e);
+    }
+
+    m_sPendingException = e;
+    synchronized {
+      ++m_sPendingCount;
+    }
+  }
+
+  static object.Exception retrieve() {
+    object.Exception e = null;
+    if (m_sPendingCount > 0) {
+      if (m_sPendingException !is null) {
+        e = m_sPendingException;
+        m_sPendingException = null;
+        synchronized {
+          --m_sPendingCount;
+        }
+      }
+    }
+    return e;
+  }
+
+private:
+  // The pending exception counter is stored thread-global.
+  static shared int m_sPendingCount;
+
+  // The reference to the pending exception (if any) is stored thread-local.
+  static object.Exception m_sPendingException;
+}
+alias void function(const char* message) SwigExceptionCallback;
+%}
+#endif
+// Callback registering function in wrapperloader.swg.
+#endif // SWIG_D_NO_EXCEPTION_HELPER
+
+
+/*
+ * String support code.
+ */
+
+#if !defined(SWIG_D_NO_STRING_HELPER)
+%insert(runtime) %{
+// Callback for returning strings to D without leaking memory.
+typedef char * (* SWIG_DStringHelperCallback)(const char *);
+static SWIG_DStringHelperCallback SWIG_d_string_callback = NULL;
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGRegisterStringCallback_$module(SWIG_DStringHelperCallback callback) {
+  SWIG_d_string_callback = callback;
+}
+%}
+
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmoduleimports = "static import tango.stdc.stringz;";
+
+%pragma(d) imdmodulecode = %{
+private class SwigStringHelper {
+  static this() {
+    swigRegisterStringCallback$module(&createString);
+  }
+
+  static char* createString(char* cString) {
+    // We are effectively dup'ing the string here.
+    return tango.stdc.stringz.toStringz(tango.stdc.stringz.fromStringz(cString));
+  }
+}
+alias char* function(char* cString) SwigStringCallback;
+%}
+#else
+%pragma(d) imdmoduleimports = %{
+static import std.conv;
+static import std.string;
+%}
+
+%pragma(d) imdmodulecode = %{
+private class SwigStringHelper {
+  static this() {
+    swigRegisterStringCallback$module(&createString);
+  }
+
+  static const(char)* createString(const(char*) cString) {
+    // We are effectively dup'ing the string here.
+    // TODO: Is this also correct for D2/Phobos?
+    return std.string.toStringz(std.conv.to!string(cString));
+  }
+}
+alias const(char)* function(const(char*) cString) SwigStringCallback;
+%}
+#endif
+// Callback registering function in wrapperloader.swg.
+#endif // SWIG_D_NO_STRING_HELPER
+
+
+/*
+ * Function pointer support code.
+ */
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmodulecode = %{
+template SwigExternC(T) {
+  static if (is(typeof(*(T.init)) R == return)) {
+    static if (is(typeof(*(T.init)) P == function)) {
+      alias extern(C) R function(P) SwigExternC;
+    }
+  }
+}
+%}
+#else
+%pragma(d) imdmodulecode = %{
+template SwigExternC(T) if (is(typeof(*(T.init)) P == function)) {
+  static if (is(typeof(*(T.init)) R == return)) {
+    static if (is(typeof(*(T.init)) P == function)) {
+      alias extern(C) R function(P) SwigExternC;
+    }
+  }
+}
+%}
+#endif
diff --git a/share/swig/2.0.11/d/director.swg b/share/swig/2.0.11/d/director.swg
new file mode 100644
index 0000000..9692e03
--- /dev/null
+++ b/share/swig/2.0.11/d/director.swg
@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that D proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+
+namespace Swig {
+  // Director base class – not used in D directors.
+  class Director {
+  };
+
+  // Base class for director exceptions.
+  class DirectorException {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const char* msg) : swig_msg(msg) {
+    }
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+    const std::string& what() const {
+      return swig_msg;
+    }
+    virtual ~DirectorException() {
+    }
+  };
+
+  // Exception which is thrown when attempting to call a pure virtual method
+  // from D code thorugh the director layer.
+  class DirectorPureVirtualException : public Swig::DirectorException {
+  public:
+    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempted to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
+#endif /* __cplusplus */
diff --git a/share/swig/2.0.11/d/dkw.swg b/share/swig/2.0.11/d/dkw.swg
new file mode 100644
index 0000000..581093f
--- /dev/null
+++ b/share/swig/2.0.11/d/dkw.swg
@@ -0,0 +1,128 @@
+#ifndef D_DKW_SWG_
+#define D_DKW_SWG_
+
+/* Warnings for D keywords */
+#define DKEYWORD(x) %keywordwarn("'" `x` "' is a D keyword, renaming to '_" `x` "'",rename="_%s")  `x`
+
+// Source: http://www.digitalmars.com/d/{1.0,2.0}/lex.html and
+DKEYWORD(Error);
+DKEYWORD(Exception);
+DKEYWORD(Object);
+DKEYWORD(__FILE__);
+DKEYWORD(__LINE__);
+DKEYWORD(__gshared);
+DKEYWORD(__thread);
+DKEYWORD(__traits);
+DKEYWORD(abstract);
+DKEYWORD(alias);
+DKEYWORD(align);
+DKEYWORD(asm);
+DKEYWORD(assert);
+DKEYWORD(auto);
+DKEYWORD(body);
+DKEYWORD(bool);
+DKEYWORD(break);
+DKEYWORD(byte);
+DKEYWORD(case);
+DKEYWORD(cast);
+DKEYWORD(catch);
+DKEYWORD(cdouble);
+DKEYWORD(cent);
+DKEYWORD(cfloat);
+DKEYWORD(char);
+DKEYWORD(class);
+DKEYWORD(const);
+DKEYWORD(continue);
+DKEYWORD(creal);
+DKEYWORD(dchar);
+DKEYWORD(debug);
+DKEYWORD(default);
+DKEYWORD(delegate);
+DKEYWORD(delete);
+DKEYWORD(deprecated);
+DKEYWORD(do);
+DKEYWORD(double);
+DKEYWORD(dstring);
+DKEYWORD(else);
+DKEYWORD(enum);
+DKEYWORD(export);
+DKEYWORD(extern);
+DKEYWORD(false);
+DKEYWORD(final);
+DKEYWORD(finally);
+DKEYWORD(float);
+DKEYWORD(for);
+DKEYWORD(foreach);
+DKEYWORD(foreach_reverse);
+DKEYWORD(function);
+DKEYWORD(goto);
+DKEYWORD(idouble);
+DKEYWORD(if);
+DKEYWORD(ifloat);
+DKEYWORD(immutable);
+DKEYWORD(import);
+DKEYWORD(in);
+DKEYWORD(inout);
+DKEYWORD(int);
+DKEYWORD(interface);
+DKEYWORD(invariant);
+DKEYWORD(ireal);
+DKEYWORD(is);
+DKEYWORD(lazy);
+DKEYWORD(long);
+DKEYWORD(macro);
+DKEYWORD(mixin);
+DKEYWORD(module);
+DKEYWORD(new);
+DKEYWORD(nothrow);
+DKEYWORD(null);
+DKEYWORD(out);
+DKEYWORD(override);
+DKEYWORD(package);
+DKEYWORD(pragma);
+DKEYWORD(private);
+DKEYWORD(protected);
+DKEYWORD(public);
+DKEYWORD(pure);
+DKEYWORD(real);
+DKEYWORD(ref);
+DKEYWORD(return);
+DKEYWORD(scope);
+DKEYWORD(shared);
+DKEYWORD(short);
+DKEYWORD(static);
+DKEYWORD(string);
+DKEYWORD(struct);
+DKEYWORD(super);
+DKEYWORD(switch);
+DKEYWORD(synchronized);
+DKEYWORD(template);
+DKEYWORD(this);
+DKEYWORD(throw);
+DKEYWORD(true);
+DKEYWORD(try);
+DKEYWORD(typedef);
+DKEYWORD(typeid);
+DKEYWORD(typeof);
+DKEYWORD(ubyte);
+DKEYWORD(ucent);
+DKEYWORD(uint);
+DKEYWORD(ulong);
+DKEYWORD(union);
+DKEYWORD(unittest);
+DKEYWORD(ushort);
+DKEYWORD(version);
+DKEYWORD(void);
+DKEYWORD(volatile);
+DKEYWORD(wchar);
+DKEYWORD(while);
+DKEYWORD(with);
+DKEYWORD(wstring);
+
+// Not really a keyword, but dispose() methods are generated in proxy classes
+// and it's a special method name for D1/Tango.
+DKEYWORD(dispose);
+
+#undef DKEYWORD
+
+#endif //D_DKW_SWG_
diff --git a/share/swig/2.0.11/d/dmemberfunctionpointers.swg b/share/swig/2.0.11/d/dmemberfunctionpointers.swg
new file mode 100644
index 0000000..c33ff38
--- /dev/null
+++ b/share/swig/2.0.11/d/dmemberfunctionpointers.swg
@@ -0,0 +1,92 @@
+/* -----------------------------------------------------------------------------
+ * dmemberfunctionpointers.swg
+ *
+ * Typemaps for member function pointers.
+ * ----------------------------------------------------------------------------- */
+
+
+%typemap(ctype) SWIGTYPE (CLASS::*) "char *"
+%typemap(imtype) SWIGTYPE (CLASS::*) "char*"
+%typemap(dtype) SWIGTYPE (CLASS::*) "$dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+  SWIGTYPE (CLASS::*)
+  ""
+
+
+/*
+ * Conversion generation typemaps.
+ */
+
+%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) %{
+  SWIG_UnpackData($input, (void *)&$1, sizeof($1));
+%}
+%typemap(out, fragment="SWIG_PackData") SWIGTYPE (CLASS::*) %{
+  char buf[128];
+  char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
+  *data = '\0';
+  $result = SWIG_d_string_callback(buf);
+%}
+
+%typemap(directorin) SWIGTYPE (CLASS::*) "$input = (void *) $1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE (CLASS::*)
+  "$result = ($1_ltype)$input;"
+
+%typemap(ddirectorin) SWIGTYPE (CLASS::*)
+  "($winput is null) ? null : new $dclassname($winput, false)"
+%typemap(ddirectorout) SWIGTYPE (CLASS::*) "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din) SWIGTYPE (CLASS::*) "$dclassname.swigGetCMemberPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE (CLASS::*) {
+  char* cMemberPtr = $imcall;
+  $dclassname ret = (cMemberPtr is null) ? null : new $dclassname(cMemberPtr, $owner);$excode
+  return ret;
+}
+
+
+/*
+ * Helper functions to pack/unpack arbitrary binary data (member function
+ * pointers in this case) into a string.
+ */
+
+%fragment("SWIG_PackData", "header") {
+/* Pack binary data into a string */
+SWIGINTERN char * SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  register const unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+}
+
+%fragment("SWIG_UnPackData", "header") {
+/* Unpack binary data from a string */
+SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+}
diff --git a/share/swig/2.0.11/d/doperators.swg b/share/swig/2.0.11/d/doperators.swg
new file mode 100644
index 0000000..0cb6353
--- /dev/null
+++ b/share/swig/2.0.11/d/doperators.swg
@@ -0,0 +1,259 @@
+/* -----------------------------------------------------------------------------
+ * doperators.swg
+ *
+ * Mapping of C++ operator overloading methods to D.
+ * ----------------------------------------------------------------------------- */
+
+#if (SWIG_D_VERSION == 1)
+
+%pragma(d) imdmodulecode=%{
+template SwigOperatorDefinitions() {
+  public override int opEquals(Object o) {
+    if (auto rhs = cast(typeof(this))o) {
+      if (swigCPtr == rhs.swigCPtr) return 1;
+      static if (is(typeof(swigOpEquals(rhs)))) {
+        return swigOpEquals(rhs) ? 1 : 0;
+      } else {
+        return 0; 
+      }
+    }
+    return super.opEquals(o);
+  }
+%}
+// opEquals is emitted in pure C mode as well to define two proxy classes
+// pointing to the same struct as equal.
+
+#ifdef __cplusplus
+%rename(opPos) *::operator+();
+%rename(opPos) *::operator+() const;
+%rename(opNeg) *::operator-();
+%rename(opNeg) *::operator-() const;
+%rename(opCom) *::operator~();
+%rename(opCom) *::operator~() const;
+
+%rename(opAdd) *::operator+;
+%rename(opAddAssign) *::operator+=;
+%rename(opSub) *::operator-;
+%rename(opSubAssign) *::operator-=;
+%rename(opMul) *::operator*;
+%rename(opMulAssign) *::operator*=;
+%rename(opDiv) *::operator/;
+%rename(opDivAssign) *::operator/=;
+%rename(opMod) *::operator%;
+%rename(opModAssign) *::operator%=;
+%rename(opAnd) *::operator&;
+%rename(opAndAssign) *::operator&=;
+%rename(opOr) *::operator|;
+%rename(opOrAssign) *::operator|=;
+%rename(opXor) *::operator^;
+%rename(opXorAssign) *::operator^=;
+%rename(opShl) *::operator<<;
+%rename(opShlAssign) *::operator<<=;
+%rename(opShr) *::operator>>;
+%rename(opShrAssign) *::operator>>=;
+
+%rename(opIndex) *::operator[](unsigned) const;
+// opIndexAssign is not currently generated, it needs more extensive support
+// mechanisms.
+
+%rename(opCall) *::operator();
+  
+// !a is not overrideable in D1.
+%ignoreoperator(LNOT) operator!;
+
+// opCmp is used in D.
+%rename(swigOpEquals) *::operator==;
+%rename(swigOpLt) *::operator<;
+%rename(swigOpLtEquals) *::operator<=;
+%rename(swigOpGt) *::operator>;
+%rename(swigOpGtEquals) *::operator>=;
+
+// a != b is rewritten as !a.opEquals(b) in D.
+%ignoreoperator(NOTEQUAL) operator!=;
+
+// The logic operators are not overrideable in D.
+%ignoreoperator(LAND) operator&&;
+%ignoreoperator(LOR) operator||;
+
+// ++/--a is rewritten as a +/-= 1 in D1,so ignore the prefix operators.
+%ignoreoperator(PLUSPLUS) *::operator++();
+%ignoreoperator(MINUSMINUS) *::operator--();
+%rename(swigOpInc) *::operator++(int);
+%rename(swigOpDec) *::operator--(int);
+
+// The C++ assignment operator does not translate well to D where the proxy
+// classes have reference semantics.
+%ignoreoperator(EQ) operator=;
+
+%pragma(d) imdmodulecode=%{
+  public override int opCmp(Object o) {
+    static if (is(typeof(swigOpLt(typeof(this).init) &&
+        swigOpEquals(typeof(this).init)))) {
+      if (auto rhs = cast(typeof(this))o) {
+        if (swigOpLt(rhs)) {
+          return -1;
+        } else if (swigOpEquals(rhs)) {
+          return 0;
+        } else {
+          return 1;
+        }
+      }
+    }
+    return super.opCmp(o);
+  }
+
+  public typeof(this) opPostInc(T = int)(T unused = 0) {
+    static assert(
+      is(typeof(swigOpInc(int.init))),
+      "opPostInc called on " ~ typeof(this).stringof ~ ", but no postfix " ~
+        "increment operator exists in the corresponding C++ class."
+    );
+    return swigOpInc(int.init);
+  }
+
+  public typeof(this) opPostDec(T = int)(T unused = 0) {
+    static assert(
+      is(typeof(swigOpDec(int.init))),
+      "opPostInc called on " ~ typeof(this).stringof ~ ", but no postfix " ~
+        "decrement operator exists in the corresponding C++ class."
+    );
+    return swigOpDec(int.init);
+  }
+%}
+#endif
+
+%pragma(d) imdmodulecode=%{
+}
+%}
+
+#else
+%pragma(d) imdmodulecode=%{
+mixin template SwigOperatorDefinitions() {
+  public override bool opEquals(Object o) {
+    if (auto rhs = cast(typeof(this))o) {
+      if (swigCPtr == rhs.swigCPtr) return true;
+      static if (is(typeof(swigOpEquals(rhs)))) {
+        return swigOpEquals(rhs);
+      } else {
+        return false; 
+      }
+    }
+    return super.opEquals(o);
+  }
+%}
+// opEquals is emitted in pure C mode as well to define two proxy classes
+// pointing to the same struct as equal.
+
+#ifdef __cplusplus
+%rename(swigOpPos) *::operator+();
+%rename(swigOpPos) *::operator+() const;
+%rename(swigOpNeg) *::operator-();
+%rename(swigOpNeg) *::operator-() const;
+%rename(swigOpCom) *::operator~();
+%rename(swigOpCom) *::operator~() const;
+%rename(swigOpInc) *::operator++();
+%rename(swigOpDec) *::operator--();
+%ignoreoperator(PLUSPLUS) *::operator++(int);
+%ignoreoperator(MINUSMINUS) *::operator--(int);
+// The postfix increment/decrement operators are ignored because they are
+// rewritten to (auto t = e, ++e, t) in D2. The unary * operator (used for
+// pointer dereferencing in C/C++) isn't mapped to opUnary("*") by default,
+// despite this would be possible in D2 – the difference in member access
+// semantics would only lead to confusion in most cases.
+
+%rename(swigOpAdd) *::operator+;
+%rename(swigOpSub) *::operator-;
+%rename(swigOpMul) *::operator*;
+%rename(swigOpDiv) *::operator/;
+%rename(swigOpMod) *::operator%;
+%rename(swigOpAnd) *::operator&;
+%rename(swigOpOr) *::operator|;
+%rename(swigOpXor) *::operator^;
+%rename(swigOpShl) *::operator<<;
+%rename(swigOpShr) *::operator>>;
+
+%rename(swigOpAddAssign) *::operator+=;
+%rename(swigOpSubAssign) *::operator-=;
+%rename(swigOpMulAssign) *::operator*=;
+%rename(swigOpDivAssign) *::operator/=;
+%rename(swigOpModAssign) *::operator%=;
+%rename(swigOpAndAssign) *::operator&=;
+%rename(swigOpOrAssign) *::operator|=;
+%rename(swigOpXorAssign) *::operator^=;
+%rename(swigOpShlAssign) *::operator<<=;
+%rename(swigOpShrAssign) *::operator>>=;
+
+%rename(opIndex) *::operator[];
+// opIndexAssign is not currently generated, it needs more extensive support
+// mechanisms.
+
+%rename(opCall) *::operator();
+
+%rename(swigOpEquals) *::operator==;
+%rename(swigOpLt) *::operator<;
+%rename(swigOpLtEquals) *::operator<=;
+%rename(swigOpGt) *::operator>;
+%rename(swigOpGtEquals) *::operator>=;
+
+// a != b is rewritten as !a.opEquals(b) in D.
+%ignoreoperator(NOTEQUAL) operator!=;
+
+// The logic operators are not overrideable in D.
+%ignoreoperator(LAND) operator&&;
+%ignoreoperator(LOR) operator||;
+
+// The C++ assignment operator does not translate well to D where the proxy
+// classes have reference semantics.
+%ignoreoperator(EQ) operator=;
+
+%pragma(d) imdmodulecode=%{  
+  public override int opCmp(Object o) {
+    static if (__traits(compiles, swigOpLt(typeof(this).init) &&
+        swigOpEquals(typeof(this).init))) {
+      if (auto rhs = cast(typeof(this))o) {
+        if (swigOpLt(rhs)) {
+          return -1;
+        } else if (swigOpEquals(rhs)) {
+          return 0;
+        } else {
+          return 1;
+        }
+      }
+    }
+    return super.opCmp(o);
+  }
+
+  private template swigOpBinary(string operator, string name) {
+    enum swigOpBinary = `public void opOpAssign(string op, T)(T rhs) if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `Assign(rhs))) { swigOp` ~ name ~ `Assign(rhs);}` ~
+      `public auto opBinary(string op, T)(T rhs) if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `(rhs))) { return swigOp` ~ name ~ `(rhs);}`;
+  }
+  mixin(swigOpBinary!("+", "Add"));
+  mixin(swigOpBinary!("-", "Sub"));
+  mixin(swigOpBinary!("*", "Mul"));
+  mixin(swigOpBinary!("/", "Div"));
+  mixin(swigOpBinary!("%", "Mod"));
+  mixin(swigOpBinary!("&", "And"));
+  mixin(swigOpBinary!("|", "Or"));
+  mixin(swigOpBinary!("^", "Xor"));
+  mixin(swigOpBinary!("<<", "Shl"));
+  mixin(swigOpBinary!(">>", "Shr"));
+  
+  private template swigOpUnary(string operator, string name) {
+    enum swigOpUnary = `public auto opUnary(string op)() if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `())) { return swigOp` ~ name ~ `();}`;   
+  }
+  mixin(swigOpUnary!("+", "Pos"));
+  mixin(swigOpUnary!("-", "Neg"));
+  mixin(swigOpUnary!("~", "Com"));
+  mixin(swigOpUnary!("++", "Inc"));
+  mixin(swigOpUnary!("--", "Dec"));
+%}
+#endif
+
+%pragma(d) imdmodulecode=%{
+}
+%}
+
+#endif
diff --git a/share/swig/2.0.11/d/dprimitives.swg b/share/swig/2.0.11/d/dprimitives.swg
new file mode 100644
index 0000000..4454379
--- /dev/null
+++ b/share/swig/2.0.11/d/dprimitives.swg
@@ -0,0 +1,171 @@
+/* -----------------------------------------------------------------------------
+ * dprimitves.swg
+ *
+ * Typemaps for primitive types.
+ * ----------------------------------------------------------------------------- */
+
+// C long/ulong width depends on the target arch, use stdlib aliases for them.
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmoduleimports = "static import tango.stdc.config;"
+%pragma(d) globalproxyimports = "static import tango.stdc.config;"
+#define SWIG_LONG_DTYPE tango.stdc.config.c_long
+#define SWIG_ULONG_DTYPE tango.stdc.config.c_ulong
+#else
+%pragma(d) imdmoduleimports = "static import core.stdc.config;"
+%pragma(d) globalproxyimports = "static import core.stdc.config;"
+#define SWIG_LONG_DTYPE core.stdc.config.c_long
+#define SWIG_ULONG_DTYPE core.stdc.config.c_ulong
+#endif
+
+/*
+ * The SWIG_D_PRIMITIVE macro is used to define the typemaps for the primitive
+ * types, because are more or less the same for all of them. The few special
+ * cases are handeled below.
+ */
+%define SWIG_D_PRIMITIVE(TYPE, DTYPE)
+%typemap(ctype) TYPE, const TYPE & "TYPE"
+%typemap(imtype) TYPE, const TYPE & "DTYPE"
+%typemap(dtype, cprimitive="1") TYPE, const TYPE & "DTYPE"
+
+%typemap(in) TYPE "$1 = ($1_ltype)$input;"
+%typemap(out) TYPE "$result = $1;"
+%typemap(directorin) TYPE "$input = $1;"
+%typemap(directorout) TYPE "$result = ($1_ltype)$input;"
+%typemap(ddirectorin) TYPE "$winput"
+%typemap(ddirectorout) TYPE "$dcall"
+
+%typemap(in) const TYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input;
+   $1 = &temp; %}
+%typemap(out) const TYPE & "$result = *$1;"
+%typemap(directorin) const TYPE & "$input = $1;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const TYPE &
+%{ static $*1_ltype temp;
+   temp = ($*1_ltype)$input;
+   $result = &temp; %}
+%typemap(ddirectorin) const TYPE & "$winput"
+%typemap(ddirectorout) const TYPE & "$dcall"
+
+%typemap(din) TYPE, const TYPE & "$dinput"
+%typemap(dout, excode=SWIGEXCODE) TYPE, const TYPE & {
+  auto ret = $imcall;$excode
+  return ret;
+}
+%enddef
+
+
+SWIG_D_PRIMITIVE(bool, bool)
+SWIG_D_PRIMITIVE(char, char)
+SWIG_D_PRIMITIVE(signed char, byte)
+SWIG_D_PRIMITIVE(unsigned char, ubyte)
+SWIG_D_PRIMITIVE(short, short)
+SWIG_D_PRIMITIVE(unsigned short, ushort)
+SWIG_D_PRIMITIVE(int, int)
+SWIG_D_PRIMITIVE(unsigned int, uint)
+SWIG_D_PRIMITIVE(long, SWIG_LONG_DTYPE)
+SWIG_D_PRIMITIVE(unsigned long, SWIG_ULONG_DTYPE)
+SWIG_D_PRIMITIVE(size_t, size_t)
+SWIG_D_PRIMITIVE(long long, long)
+SWIG_D_PRIMITIVE(unsigned long long, ulong)
+SWIG_D_PRIMITIVE(float, float)
+SWIG_D_PRIMITIVE(double, double)
+
+
+// The C++ boolean type needs some special casing since it is not part of the
+// C standard and is thus represented as unsigned int in the C wrapper layer.
+%typemap(ctype) bool, const bool & "unsigned int"
+%typemap(imtype) bool, const bool & "uint"
+
+%typemap(in) bool "$1 = $input ? true : false;"
+%typemap(in) const bool & ($*1_ltype temp)
+%{ temp = $input ? true : false;
+   $1 = &temp; %}
+
+%typemap(directorout) bool
+  "$result = $input ? true : false;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const bool &
+%{ static $*1_ltype temp;
+   temp = $input ? true : false;
+   $result = &temp; %}
+
+%typemap(ddirectorin) bool "($winput ? true : false)"
+
+%typemap(dout, excode=SWIGEXCODE) bool, const bool & {
+  bool ret = $imcall ? true : false;$excode
+  return ret;
+}
+
+
+// Judging from the history of the C# module, the explicit casts are needed for
+// certain versions of VC++.
+%typemap(out) unsigned long "$result = (unsigned long)$1;"
+%typemap(out) const unsigned long & "$result = (unsigned long)*$1;"
+
+
+/*
+ * Typecheck typemaps.
+ */
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR)
+    char,
+    const char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8)
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT8)
+    unsigned char,
+    const unsigned char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16)
+    short,
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT16)
+    unsigned short,
+    const unsigned short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32)
+    int,
+    long,
+    const int &,
+    const long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT32)
+    unsigned int,
+    unsigned long,
+    const unsigned int &,
+    const unsigned long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64)
+    long long,
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT64)
+    unsigned long long,
+    const unsigned long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT)
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+    double,
+    const double &
+    ""
diff --git a/share/swig/2.0.11/d/dstrings.swg b/share/swig/2.0.11/d/dstrings.swg
new file mode 100644
index 0000000..02895c1
--- /dev/null
+++ b/share/swig/2.0.11/d/dstrings.swg
@@ -0,0 +1,80 @@
+/* -----------------------------------------------------------------------------
+ * dstrings.swg
+ *
+ * Typemaps for wrapping pointers to/arrays of C chars as D strings.
+ * ----------------------------------------------------------------------------- */
+
+%define SWIGD_STRING_TYPEMAPS(DW_STRING_TYPE, DP_STRING_TYPE, FROM_STRINGZ, TO_STRINGZ)
+%typemap(ctype) char *, char *&, char[ANY], char[]   "char *"
+%typemap(imtype) char *, char *&, char[ANY], char[]   #DW_STRING_TYPE
+%typemap(dtype) char *, char *&, char[ANY], char[]   #DP_STRING_TYPE
+
+
+/*
+ * char* typemaps.
+ */
+
+%typemap(in) char * %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char * %{ $result = SWIG_d_string_callback((const char *)$1); %}
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char * %{ $input = SWIG_d_string_callback((const char *)$1); %}
+%typemap(ddirectorin) char * "FROM_STRINGZ($winput)"
+%typemap(ddirectorout) char * "TO_STRINGZ($dcall)"
+
+
+/*
+ * char*& typemaps.
+ */
+
+%typemap(in) char *& ($*1_ltype temp = 0) %{
+  temp = ($*1_ltype)$input;
+  $1 = &temp;
+%}
+%typemap(out) char *& %{ if ($1) $result = SWIG_d_string_callback((const char *)*$1); %}
+
+
+/*
+ * char array typemaps.
+ */
+
+%typemap(in) char[ANY], char[] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char[ANY], char[] %{ $result = SWIG_d_string_callback((const char *)$1); %}
+
+%typemap(directorout) char[ANY], char[] %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char[ANY], char[] %{ $input = SWIG_d_string_callback((const char *)$1); %}
+
+%typemap(ddirectorin) char[ANY], char[] "$winput"
+%typemap(ddirectorout) char[ANY], char[] "$dcall"
+
+
+%typemap(din) char *, char *&, char[ANY], char[] "($dinput ? TO_STRINGZ($dinput) : null)"
+%typemap(dout, excode=SWIGEXCODE) char *, char *&, char[ANY], char[] {
+  DP_STRING_TYPE ret = FROM_STRINGZ ## ($imcall);$excode
+  return ret;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING)
+    char *,
+    char *&,
+    char[ANY],
+    char[]
+  ""
+%enddef
+
+
+// We need to have the \0-terminated string conversion functions available in
+// the D proxy modules.
+#if (SWIG_D_VERSION == 1)
+// Could be easily extended to support Phobos as well.
+SWIGD_STRING_TYPEMAPS(char*, char[], tango.stdc.stringz.fromStringz, tango.stdc.stringz.toStringz)
+
+%pragma(d) globalproxyimports = "static import tango.stdc.stringz;";
+#else
+SWIGD_STRING_TYPEMAPS(const(char)*, string, std.conv.to!string, std.string.toStringz)
+
+%pragma(d) globalproxyimports = %{
+static import std.conv;
+static import std.string;
+%}
+#endif
+#undef SWIGD_STRING_TYPEMAPS
diff --git a/share/swig/2.0.11/d/dswigtype.swg b/share/swig/2.0.11/d/dswigtype.swg
new file mode 100644
index 0000000..41336dc
--- /dev/null
+++ b/share/swig/2.0.11/d/dswigtype.swg
@@ -0,0 +1,184 @@
+/* -----------------------------------------------------------------------------
+ * dswigtype.swg
+ *
+ * Typemaps for non-primitive types (C/C++ classes and structs).
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) SWIGTYPE "void *"
+%typemap(imtype) SWIGTYPE "void*"
+%typemap(dtype) SWIGTYPE "$&dclassname"
+
+%typemap(ctype) SWIGTYPE [] "void *"
+%typemap(imtype) SWIGTYPE [] "void*"
+%typemap(dtype) SWIGTYPE [] "$dclassname"
+
+%typemap(ctype) SWIGTYPE * "void *"
+%typemap(imtype) SWIGTYPE * "void*"
+%typemap(dtype, nativepointer="$dtype") SWIGTYPE * "$dclassname"
+
+%typemap(ctype) SWIGTYPE & "void *"
+%typemap(imtype) SWIGTYPE & "void*"
+%typemap(dtype, nativepointer="$dtype") SWIGTYPE & "$dclassname"
+
+%typemap(ctype) SWIGTYPE *const& "void *"
+%typemap(imtype) SWIGTYPE *const& "void*"
+%typemap(dtype) SWIGTYPE *const& "$*dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+    SWIGTYPE,
+    SWIGTYPE *,
+    SWIGTYPE &,
+    SWIGTYPE [],
+    SWIGTYPE *const&
+  ""
+
+
+/*
+ * By-value conversion typemaps (parameter is converted to a pointer).
+ */
+
+%typemap(in, canthrow=1) SWIGTYPE ($&1_type argp)
+%{ argp = ($&1_ltype)$input;
+   if (!argp) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Attempt to dereference null $1_type");
+     return $null;
+   }
+   $1 = *argp; %}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+%{ $result = new $1_ltype((const $1_ltype &)$1); %}
+#else
+{
+  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
+  memmove($1ptr, &$1, sizeof($1_type));
+  $result = $1ptr;
+}
+#endif
+
+%typemap(directorin) SWIGTYPE
+  "$input = (void *)&$1;"
+%typemap(directorout) SWIGTYPE
+%{ if (!$input) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = *($&1_ltype)$input; %}
+
+%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, false)"
+%typemap(ddirectorout) SWIGTYPE "$&dclassname.swigGetCPtr($dcall)"
+
+%typemap(din) SWIGTYPE "$&dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE {
+  $&dclassname ret = new $&dclassname($imcall, true);$excode
+  return ret;
+}
+
+
+/*
+ * Pointer conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE * "$1 = ($1_ltype)$input;"
+%typemap(out) SWIGTYPE * "$result = (void *)$1;"
+
+%typemap(directorin) SWIGTYPE *
+  "$input = (void *) $1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE *
+  "$result = ($1_ltype)$input;"
+
+%typemap(ddirectorin,
+  nativepointer="cast($dtype)$winput"
+) SWIGTYPE * "($winput is null) ? null : new $dclassname($winput, false)"
+
+%typemap(ddirectorout,
+  nativepointer="cast(void*)$dcall"
+) SWIGTYPE * "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) SWIGTYPE * "$dclassname.swigGetCPtr($dinput)"
+
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}"
+) SWIGTYPE * {
+  void* cPtr = $imcall;
+  $dclassname ret = (cPtr is null) ? null : new $dclassname(cPtr, $owner);$excode
+  return ret;
+}
+
+// Use the same typemaps for const pointers.
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+
+/*
+ * Reference conversion typemaps.
+ */
+
+%typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
+  if (!$1) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type type is null");
+    return $null;
+  } %}
+%typemap(out) SWIGTYPE & "$result = (void *)$1;"
+
+%typemap(directorin) SWIGTYPE &
+  "$input = ($1_ltype) &$1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
+%{ if (!$input) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = ($1_ltype)$input; %}
+
+%typemap(ddirectorin,
+  nativepointer="cast($dtype)$winput"
+) SWIGTYPE & "new $dclassname($winput, false)"
+%typemap(ddirectorout,
+  nativepointer="cast(void*)$dcall"
+) SWIGTYPE & "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) SWIGTYPE & "$dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}") SWIGTYPE & {
+  $dclassname ret = new $dclassname($imcall, $owner);$excode
+  return ret;
+}
+
+
+/*
+ * Array conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE [] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) SWIGTYPE [] %{ $result = $1; %}
+
+%typemap(din) SWIGTYPE [] "$dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE [] {
+  void* cPtr = $imcall;
+  $dclassname ret = (cPtr is null) ? null : new $dclassname(cPtr, $owner);$excode
+  return ret;
+}
+
+// Treat references to arrays like like references to a single element.
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+
+/*
+ * Pointer reference conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
+%{ temp = ($*1_ltype)$input;
+   $1 = ($1_ltype)&temp; %}
+%typemap(out) SWIGTYPE *const&
+%{ $result = (void *)*$1; %}
+
+%typemap(din) SWIGTYPE *const& "$*dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE *const& {
+  void* cPtr = $imcall;
+  $*dclassname ret = (cPtr is null) ? null : new $*dclassname(cPtr, $owner);$excode
+  return ret;
+}
diff --git a/share/swig/2.0.11/d/dvoid.swg b/share/swig/2.0.11/d/dvoid.swg
new file mode 100644
index 0000000..805f1e7
--- /dev/null
+++ b/share/swig/2.0.11/d/dvoid.swg
@@ -0,0 +1,18 @@
+/* -----------------------------------------------------------------------------
+ * dvoid.swg
+ *
+ * Typemaps for handling void function return types and empty parameter lists.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) void "void"
+%typemap(imtype) void "void"
+%typemap(dtype, cprimitive="1") void "void"
+
+%typemap(out, null="") void ""
+%typemap(ddirectorin) void "$winput"
+%typemap(ddirectorout) void "$dcall"
+%typemap(directorin) void ""
+
+%typemap(dout, excode=SWIGEXCODE) void {
+  $imcall;$excode
+}
diff --git a/share/swig/2.0.11/d/std_common.i b/share/swig/2.0.11/d/std_common.i
new file mode 100644
index 0000000..cee11e8
--- /dev/null
+++ b/share/swig/2.0.11/d/std_common.i
@@ -0,0 +1,5 @@
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
+
diff --git a/share/swig/2.0.11/d/std_deque.i b/share/swig/2.0.11/d/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/2.0.11/d/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/2.0.11/d/std_except.i b/share/swig/2.0.11/d/std_except.i
new file mode 100644
index 0000000..2b557e5
--- /dev/null
+++ b/share/swig/2.0.11/d/std_except.i
@@ -0,0 +1,30 @@
+/* -----------------------------------------------------------------------------
+ * std_except.i
+ *
+ * Typemaps used by the STL wrappers that throw exceptions. These typemaps are
+ * used when methods are declared with an STL exception specification, such as
+ *   size_t at() const throw (std::out_of_range);
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <stdexcept>
+%}
+
+namespace std
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws, canthrow=1) std::bad_exception     "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::domain_error      "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::exception         "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::invalid_argument  "SWIG_DSetPendingException(SWIG_DIllegalArgumentException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::length_error      "SWIG_DSetPendingException(SWIG_DNoSuchElementException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::logic_error       "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::out_of_range      "SWIG_DSetPendingException(SWIG_DNoSuchElementException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::overflow_error    "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::range_error       "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::runtime_error     "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::underflow_error   "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+
diff --git a/share/swig/2.0.11/d/std_map.i b/share/swig/2.0.11/d/std_map.i
new file mode 100644
index 0000000..0e8574b
--- /dev/null
+++ b/share/swig/2.0.11/d/std_map.i
@@ -0,0 +1,59 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+    template<class K, class T> class map {
+        // add typemaps here
+      public:
+        typedef size_t size_type;
+        typedef ptrdiff_t difference_type;
+        typedef K key_type;
+        typedef T mapped_type;
+        map();
+        map(const map<K,T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            const T& get(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    return i->second;
+                else
+                    throw std::out_of_range("key not found");
+            }
+            void set(const K& key, const T& x) {
+                (*self)[key] = x;
+            }
+            void del(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    self->erase(i);
+                else
+                    throw std::out_of_range("key not found");
+            }
+            bool has_key(const K& key) {
+                std::map<K,T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+        }
+    };
+}
diff --git a/share/swig/2.0.11/d/std_pair.i b/share/swig/2.0.11/d/std_pair.i
new file mode 100644
index 0000000..0712ad7
--- /dev/null
+++ b/share/swig/2.0.11/d/std_pair.i
@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// ------------------------------------------------------------------------
+// std::pair
+// ------------------------------------------------------------------------
+
+%{
+#include <utility>
+%}
+
+namespace std {
+
+  template<class T, class U> struct pair {
+
+    pair();
+    pair(T t, U u);
+    pair(const pair& p);
+
+    template <class U1, class U2> pair(const pair<U1, U2> &p);
+
+    T first;
+    U second;
+  };
+
+  // add specializations here
+
+}
diff --git a/share/swig/2.0.11/d/std_shared_ptr.i b/share/swig/2.0.11/d/std_shared_ptr.i
new file mode 100644
index 0000000..df87367
--- /dev/null
+++ b/share/swig/2.0.11/d/std_shared_ptr.i
@@ -0,0 +1,2 @@
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>
diff --git a/share/swig/2.0.11/d/std_string.i b/share/swig/2.0.11/d/std_string.i
new file mode 100644
index 0000000..8d75d23
--- /dev/null
+++ b/share/swig/2.0.11/d/std_string.i
@@ -0,0 +1,98 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * Typemaps for std::string and const std::string&
+ * These are mapped to a D char[] and are passed around by value.
+ *
+ * To use non-const std::string references, use the following %apply. Note
+ * that they are passed by value.
+ * %apply const std::string & {std::string &};
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+%naturalvar string;
+
+class string;
+
+%define SWIGD_STD_STRING_TYPEMAPS(DW_STRING_TYPE, DP_STRING_TYPE, FROM_STRINGZ, TO_STRINGZ)
+// string
+%typemap(ctype) string, const string & "char *"
+%typemap(imtype) string, const string & #DW_STRING_TYPE
+%typemap(dtype) string, const string & #DP_STRING_TYPE
+
+%typemap(in, canthrow=1) string, const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  $1.assign($input); %}
+%typemap(in, canthrow=1) const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+   }
+   $*1_ltype $1_str($input);
+   $1 = &$1_str; %}
+
+%typemap(out) string %{ $result = SWIG_d_string_callback($1.c_str()); %}
+%typemap(out) const string & %{ $result = SWIG_d_string_callback($1->c_str()); %}
+
+%typemap(din) string, const string & "($dinput ? TO_STRINGZ($dinput) : null)"
+%typemap(dout, excode=SWIGEXCODE) string, const string & {
+  DP_STRING_TYPE ret = FROM_STRINGZ($imcall);$excode
+  return ret;
+}
+
+%typemap(directorin) string, const string & %{ $input = SWIG_d_string_callback($1.c_str()); %}
+
+%typemap(directorout, canthrow=1) string
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  $result.assign($input); %}
+
+%typemap(directorout, canthrow=1, warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  /* possible thread/reentrant code problem */
+  static $*1_ltype $1_str;
+  $1_str = $input;
+  $result = &$1_str; %}
+
+%typemap(ddirectorin) string, const string & "FROM_STRINGZ($winput)"
+%typemap(ddirectorout) string, const string & "TO_STRINGZ($dcall)"
+
+%typemap(throws, canthrow=1) string, const string &
+%{ SWIG_DSetPendingException(SWIG_DException, $1.c_str());
+  return $null; %}
+
+%typemap(typecheck) string, const string & = char *;
+%enddef
+
+// We need to have the \0-terminated string conversion functions available in
+// the D proxy modules.
+#if (SWIG_D_VERSION == 1)
+// Could be easily extended to support Phobos as well.
+SWIGD_STD_STRING_TYPEMAPS(char*, char[], tango.stdc.stringz.fromStringz, tango.stdc.stringz.toStringz)
+
+%pragma(d) globalproxyimports = "static import tango.stdc.stringz;";
+#else
+SWIGD_STD_STRING_TYPEMAPS(const(char)*, string, std.conv.to!string, std.string.toStringz)
+
+%pragma(d) globalproxyimports = %{
+static import std.conv;
+static import std.string;
+%}
+#endif
+
+#undef SWIGD_STD_STRING_TYPEMAPS
+
+} // namespace std
diff --git a/share/swig/2.0.11/d/std_vector.i b/share/swig/2.0.11/d/std_vector.i
new file mode 100644
index 0000000..b7d4e22
--- /dev/null
+++ b/share/swig/2.0.11/d/std_vector.i
@@ -0,0 +1,591 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector<T>, D implementation.
+ *
+ * The D wrapper is made to loosely resemble a tango.util.container.more.Vector
+ * and to provide built-in array-like access.
+ *
+ * If T does define an operator==, then use the SWIG_STD_VECTOR_ENHANCED
+ * macro to obtain enhanced functionality (none yet), for example:
+ *
+ *   SWIG_STD_VECTOR_ENHANCED(SomeNamespace::Klass)
+ *   %template(VectKlass) std::vector<SomeNamespace::Klass>;
+ *
+ * Warning: heavy macro usage in this file. Use swig -E to get a sane view on
+ * the real file contents!
+ * ----------------------------------------------------------------------------- */
+
+// Warning: Use the typemaps here in the expectation that the macros they are in will change name.
+
+%include <std_common.i>
+
+// MACRO for use within the std::vector class body
+%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CONST_REFERENCE, CTYPE...)
+#if (SWIG_D_VERSION == 1)
+%typemap(dimports) std::vector< CTYPE > "static import tango.core.Exception;"
+%typemap(dcode) std::vector< CTYPE > %{
+public this($typemap(dtype, CTYPE)[] values) {
+  this();
+  append(values);
+}
+
+alias push_back add;
+alias push_back push;
+alias push_back opCatAssign;
+alias size length;
+alias opSlice slice;
+
+public $typemap(dtype, CTYPE) opIndexAssign($typemap(dtype, CTYPE) value, size_t index) {
+  if (index >= size()) {
+    throw new tango.core.Exception.NoSuchElementException("Tried to assign to element out of vector bounds.");
+  }
+  setElement(index, value);
+  return value;
+}
+
+public $typemap(dtype, CTYPE) opIndex(size_t index) {
+  if (index >= size()) {
+    throw new tango.core.Exception.NoSuchElementException("Tried to read from element out of vector bounds.");
+  }
+  return getElement(index);
+}
+
+public void append($typemap(dtype, CTYPE)[] value...) {
+  foreach (v; value) {
+    add(v);
+  }
+}
+
+public $typemap(dtype, CTYPE)[] opSlice() {
+  $typemap(dtype, CTYPE)[] array = new $typemap(dtype, CTYPE)[size()];
+  foreach (i, ref value; array) {
+    value = getElement(i);
+  }
+  return array;
+}
+
+public int opApply(int delegate(ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+    result = dg(value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+public int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+
+    // Workaround for http://d.puremagic.com/issues/show_bug.cgi?id=2443.
+    auto index = i;
+
+    result = dg(index, value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+public void capacity(size_t value) {
+  if (value < size()) {
+    throw new tango.core.Exception.IllegalArgumentException("Tried to make the capacity of a vector smaller than its size.");
+  }
+
+  reserve(value);
+}
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef CTYPE value_type;
+    typedef CONST_REFERENCE const_reference;
+    void clear();
+    void push_back(CTYPE const& x);
+    size_type size() const;
+    size_type capacity() const;
+    void reserve(size_type n) throw (std::length_error);
+    vector();
+    vector(const vector &other);
+    %extend {
+      vector(size_type capacity) throw (std::length_error) {
+        std::vector< CTYPE >* pv = 0;
+        pv = new std::vector< CTYPE >();
+
+        // Might throw std::length_error.
+        pv->reserve(capacity);
+
+        return pv;
+      }
+
+      size_type unused() const {
+        return $self->capacity() - $self->size();
+      }
+
+      const_reference remove() throw (std::out_of_range) {
+        if ($self->empty()) {
+          throw std::out_of_range("Tried to remove last element from empty vector.");
+        }
+
+        std::vector< CTYPE >::const_reference value = $self->back();
+        $self->pop_back();
+        return value;
+      }
+
+      const_reference remove(size_type index) throw (std::out_of_range) {
+        if (index >= $self->size()) {
+          throw std::out_of_range("Tried to remove element with invalid index.");
+        }
+
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        std::vector< CTYPE >::const_reference value = *it;
+        $self->erase(it);
+        return value;
+      }
+    }
+
+    // Wrappers for setting/getting items with the possibly thrown exception
+    // specified (important for SWIG wrapper generation).
+    %extend {
+      const_reference getElement(size_type index) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to get value of element with invalid index.");
+        }
+        return (*$self)[index];
+      }
+    }
+
+    // Use CTYPE const& instead of const_reference to work around SWIG code
+    // generation issue when using const pointers as vector elements (like
+    // std::vector< const int* >).
+    %extend {
+      void setElement(size_type index, CTYPE const& val) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to set value of element with invalid index.");
+        }
+        (*$self)[index] = val;
+      }
+    }
+
+%dmethodmodifiers std::vector::getElement "private"
+%dmethodmodifiers std::vector::setElement "private"
+%dmethodmodifiers std::vector::reserve "private"
+
+#else
+
+%typemap(dimports) std::vector< CTYPE > %{
+static import std.algorithm;
+static import std.exception;
+static import std.range;
+static import std.traits;
+%}
+%typemap(dcode) std::vector< CTYPE > %{
+alias size_t KeyType;
+alias $typemap(dtype, CTYPE) ValueType;
+
+this(ValueType[] values...) {
+  this();
+  reserve(values.length);
+  foreach (e; values) {
+    this ~= e;
+  }
+}
+
+struct Range {
+  private $typemap(dtype, std::vector< CTYPE >) _outer;
+  private size_t _a, _b;
+
+  this($typemap(dtype, std::vector< CTYPE >) data, size_t a, size_t b) {
+    _outer = data;
+    _a = a;
+    _b = b;
+  }
+
+  @property bool empty() const {
+    assert((cast($typemap(dtype, std::vector< CTYPE >))_outer).length >= _b);
+    return _a >= _b;
+  }
+
+  @property Range save() {
+    return this;
+  }
+
+  @property ValueType front() {
+    std.exception.enforce(!empty);
+    return _outer[_a];
+  }
+
+  @property void front(ValueType value) {
+    std.exception.enforce(!empty);
+    _outer[_a] = std.algorithm.move(value);
+  }
+
+  void popFront() {
+    std.exception.enforce(!empty);
+    ++_a;
+  }
+
+  void opIndexAssign(ValueType value, size_t i) {
+    i += _a;
+    std.exception.enforce(i < _b && _b <= _outer.length);
+    _outer[i] = value;
+  }
+
+  void opIndexOpAssign(string op)(ValueType value, size_t i) {
+    std.exception.enforce(_outer && _a + i < _b && _b <= _outer.length);
+    auto element = _outer[i];
+    mixin("element "~op~"= value;");
+    _outer[i] = element;
+  }
+}
+
+// TODO: dup?
+
+Range opSlice() {
+  return Range(this, 0, length);
+}
+
+Range opSlice(size_t a, size_t b) {
+  std.exception.enforce(a <= b && b <= length);
+  return Range(this, a, b);
+}
+
+size_t opDollar() const {
+  return length;
+}
+
+@property ValueType front() {
+  std.exception.enforce(!empty);
+  return getElement(0);
+}
+
+@property void front(ValueType value) {
+  std.exception.enforce(!empty);
+  setElement(0, value);
+}
+
+@property ValueType back() {
+  std.exception.enforce(!empty);
+  return getElement(length - 1);
+}
+
+@property void back(ValueType value) {
+  std.exception.enforce(!empty);
+  setElement(length - 1, value);
+}
+
+ValueType opIndex(size_t i) {
+  return getElement(i);
+}
+
+void opIndexAssign(ValueType value, size_t i) {
+  setElement(i, value);
+}
+
+void opIndexOpAssign(string op)(ValueType value, size_t i) {
+  auto element = this[i];
+  mixin("element "~op~"= value;");
+  this[i] = element;
+}
+
+ValueType[] opBinary(string op, Stuff)(Stuff stuff) if (op == "~") {
+  ValueType[] result;
+  result ~= this[];
+  assert(result.length == length);
+  result ~= stuff[];
+  return result;
+}
+
+void opOpAssign(string op, Stuff)(Stuff stuff) if (op == "~") {
+  static if (is(typeof(insertBack(stuff)))) {
+    insertBack(stuff);
+  } else if (is(typeof(insertBack(stuff[])))) {
+    insertBack(stuff[]);
+  } else {
+    static assert(false, "Cannot append " ~ Stuff.stringof ~ " to " ~ typeof(this).stringof);
+  }
+}
+
+alias size length;
+
+alias remove removeAny;
+alias removeAny stableRemoveAny;
+
+size_t insertBack(Stuff)(Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType)){
+  push_back(stuff);
+  return 1;
+}
+size_t insertBack(Stuff)(Stuff stuff)
+if (std.range.isInputRange!Stuff &&
+    std.traits.isImplicitlyConvertible!(std.range.ElementType!Stuff, ValueType)) {
+  size_t itemCount;
+  foreach(item; stuff) {
+    insertBack(item);
+    ++itemCount;
+  }
+  return itemCount;
+}
+alias insertBack insert;
+
+alias pop_back removeBack;
+alias pop_back stableRemoveBack;
+
+size_t insertBefore(Stuff)(Range r, Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType)) {
+  std.exception.enforce(r._outer.swigCPtr == swigCPtr && r._a < length);
+  insertAt(r._a, stuff);
+  return 1;
+}
+
+size_t insertBefore(Stuff)(Range r, Stuff stuff)
+if (std.range.isInputRange!Stuff && std.traits.isImplicitlyConvertible!(ElementType!Stuff, ValueType)) {
+  std.exception.enforce(r._outer.swigCPtr == swigCPtr && r._a <= length);
+
+  size_t insertCount;
+  foreach(i, item; stuff) {
+    insertAt(r._a + i, item);
+    ++insertCount;
+  }
+
+  return insertCount;
+}
+
+size_t insertAfter(Stuff)(Range r, Stuff stuff) {
+  // TODO: optimize
+  immutable offset = r._a + r.length;
+  std.exception.enforce(offset <= length);
+  auto result = insertBack(stuff);
+  std.algorithm.bringToFront(this[offset .. length - result],
+    this[length - result .. length]);
+  return result;
+}
+
+size_t replace(Stuff)(Range r, Stuff stuff)
+if (std.range.isInputRange!Stuff &&
+    std.traits.isImplicitlyConvertible!(ElementType!Stuff, ValueType)) {
+  immutable offset = r._a;
+  std.exception.enforce(offset <= length);
+  size_t result;
+  for (; !stuff.empty; stuff.popFront()) {
+    if (r.empty) {
+      // append the rest
+      return result + insertBack(stuff);
+    }
+    r.front = stuff.front;
+    r.popFront();
+    ++result;
+  }
+  // Remove remaining stuff in r
+  remove(r);
+  return result;
+}
+
+size_t replace(Stuff)(Range r, Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType))
+{
+    if (r.empty)
+    {
+        insertBefore(r, stuff);
+    }
+    else
+    {
+        r.front = stuff;
+        r.popFront();
+        remove(r);
+    }
+    return 1;
+}
+
+Range linearRemove(Range r) {
+  std.exception.enforce(r._a <= r._b && r._b <= length);
+  immutable tailLength = length - r._b;
+  linearRemove(r._a, r._b);
+  return this[length - tailLength .. length];
+}
+alias remove stableLinearRemove;
+
+int opApply(int delegate(ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+    result = dg(value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+
+    // Workaround for http://d.puremagic.com/issues/show_bug.cgi?id=2443.
+    auto index = i;
+
+    result = dg(index, value);
+    setElement(i, value);
+  }
+  return result;
+}
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef CTYPE value_type;
+    typedef CONST_REFERENCE const_reference;
+    bool empty() const;
+    void clear();
+    void push_back(CTYPE const& x);
+    void pop_back();
+    size_type size() const;
+    size_type capacity() const;
+    void reserve(size_type n) throw (std::length_error);
+    vector();
+    vector(const vector &other);
+    %extend {
+      vector(size_type capacity) throw (std::length_error) {
+        std::vector< CTYPE >* pv = 0;
+        pv = new std::vector< CTYPE >();
+
+        // Might throw std::length_error.
+        pv->reserve(capacity);
+
+        return pv;
+      }
+
+      const_reference remove() throw (std::out_of_range) {
+        if ($self->empty()) {
+          throw std::out_of_range("Tried to remove last element from empty vector.");
+        }
+
+        std::vector< CTYPE >::const_reference value = $self->back();
+        $self->pop_back();
+        return value;
+      }
+
+      const_reference remove(size_type index) throw (std::out_of_range) {
+        if (index >= $self->size()) {
+          throw std::out_of_range("Tried to remove element with invalid index.");
+        }
+
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        std::vector< CTYPE >::const_reference value = *it;
+        $self->erase(it);
+        return value;
+      }
+
+      void removeBack(size_type how_many) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator end = $self->end();
+        std::vector< CTYPE >::iterator start = end - how_many;
+        $self->erase(start, end);
+      }
+
+      void linearRemove(size_type start_index, size_type end_index) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator start = $self->begin() + start_index;
+        std::vector< CTYPE >::iterator end = $self->begin() + end_index;
+        $self->erase(start, end);
+      }
+
+      void insertAt(size_type index, CTYPE const& x) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        $self->insert(it, x);
+      }
+    }
+
+    // Wrappers for setting/getting items with the possibly thrown exception
+    // specified (important for SWIG wrapper generation).
+    %extend {
+      const_reference getElement(size_type index) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to get value of element with invalid index.");
+        }
+        return (*$self)[index];
+      }
+    }
+    // Use CTYPE const& instead of const_reference to work around SWIG code
+    // generation issue when using const pointers as vector elements (like
+    // std::vector< const int* >).
+    %extend {
+      void setElement(size_type index, CTYPE const& val) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to set value of element with invalid index.");
+        }
+        (*$self)[index] = val;
+      }
+    }
+
+%dmethodmodifiers std::vector::getElement "private"
+%dmethodmodifiers std::vector::setElement "private"
+#endif
+%enddef
+
+// Extra methods added to the collection class if operator== is defined for the class being wrapped
+// The class will then implement IList<>, which adds extra functionality
+%define SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE...)
+    %extend {
+    }
+%enddef
+
+// For vararg handling in macros, from swigmacros.swg
+#define %arg(X...) X
+
+// Macros for std::vector class specializations/enhancements
+%define SWIG_STD_VECTOR_ENHANCED(CTYPE...)
+namespace std {
+  template<> class vector<CTYPE > {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(%arg(CTYPE const&), %arg(CTYPE))
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE)
+  };
+}
+%enddef
+
+%{
+#include <vector>
+#include <stdexcept>
+%}
+
+namespace std {
+  // primary (unspecialized) class template for std::vector
+  // does not require operator== to be defined
+  template<class T> class vector {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(T const&, T)
+  };
+  // specializations for pointers
+  template<class T> class vector<T *> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(T *const&, T *)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(T *)
+  };
+  // bool is a bit different in the C++ standard - const_reference in particular
+  template<> class vector<bool> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(bool, bool)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(bool)
+  };
+}
+
+// template specializations for std::vector
+// these provide extra collections methods as operator== is defined
+SWIG_STD_VECTOR_ENHANCED(char)
+SWIG_STD_VECTOR_ENHANCED(signed char)
+SWIG_STD_VECTOR_ENHANCED(unsigned char)
+SWIG_STD_VECTOR_ENHANCED(short)
+SWIG_STD_VECTOR_ENHANCED(unsigned short)
+SWIG_STD_VECTOR_ENHANCED(int)
+SWIG_STD_VECTOR_ENHANCED(unsigned int)
+SWIG_STD_VECTOR_ENHANCED(long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long)
+SWIG_STD_VECTOR_ENHANCED(long long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long long)
+SWIG_STD_VECTOR_ENHANCED(float)
+SWIG_STD_VECTOR_ENHANCED(double)
+SWIG_STD_VECTOR_ENHANCED(std::string) // also requires a %include <std_string.i>
diff --git a/share/swig/2.0.11/d/stl.i b/share/swig/2.0.11/d/stl.i
new file mode 100644
index 0000000..9d2e91e
--- /dev/null
+++ b/share/swig/2.0.11/d/stl.i
@@ -0,0 +1,12 @@
+/* -----------------------------------------------------------------------------
+ * stl.i
+ *
+ * Initial STL definition. extended as needed in each language
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
+
diff --git a/share/swig/2.0.11/d/typemaps.i b/share/swig/2.0.11/d/typemaps.i
new file mode 100644
index 0000000..4f1b599
--- /dev/null
+++ b/share/swig/2.0.11/d/typemaps.i
@@ -0,0 +1,261 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer and reference handling typemap library
+ *
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers and C++ references.
+ * ----------------------------------------------------------------------------- */
+
+/*
+INPUT typemaps
+--------------
+
+These typemaps are used for pointer/reference parameters that are input only
+and are mapped to a D input parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a simple
+input value.  That is, instead of passing a pointer or reference to an object,
+you would use a real value instead.
+
+        bool               *INPUT, bool               &INPUT
+        signed char        *INPUT, signed char        &INPUT
+        unsigned char      *INPUT, unsigned char      &INPUT
+        short              *INPUT, short              &INPUT
+        unsigned short     *INPUT, unsigned short     &INPUT
+        int                *INPUT, int                &INPUT
+        unsigned int       *INPUT, unsigned int       &INPUT
+        long               *INPUT, long               &INPUT
+        unsigned long      *INPUT, unsigned long      &INPUT
+        long long          *INPUT, long long          &INPUT
+        unsigned long long *INPUT, unsigned long long &INPUT
+        float              *INPUT, float              &INPUT
+        double             *INPUT, double             &INPUT
+
+To use these, suppose you had a C function like this :
+
+        double fadd(double *a, double *b) {
+               return *a+*b;
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double fadd(double *INPUT, double *INPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INPUT { double *a, double *b };
+        double fadd(double *a, double *b);
+
+In D you could then use it like this:
+        double answer = fadd(10.0, 20.0);
+*/
+
+%define INPUT_TYPEMAP(TYPE, CTYPE, DTYPE)
+%typemap(ctype, out="void *") TYPE *INPUT, TYPE &INPUT "CTYPE"
+%typemap(imtype, out="void*") TYPE *INPUT, TYPE &INPUT "DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *INPUT, TYPE &INPUT "DTYPE"
+%typemap(din) TYPE *INPUT, TYPE &INPUT "$dinput"
+
+%typemap(in) TYPE *INPUT, TYPE &INPUT
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(typecheck) TYPE *INPUT = TYPE;
+%typemap(typecheck) TYPE &INPUT = TYPE;
+%enddef
+
+INPUT_TYPEMAP(bool,               unsigned int,         bool)
+//INPUT_TYPEMAP(char,               char,                 char) // Why was this commented out?
+INPUT_TYPEMAP(signed char,        signed char,          byte)
+INPUT_TYPEMAP(unsigned char,      unsigned char,        ubyte)
+INPUT_TYPEMAP(short,              short,                short)
+INPUT_TYPEMAP(unsigned short,     unsigned short,       ushort)
+INPUT_TYPEMAP(int,                int,                  int)
+INPUT_TYPEMAP(unsigned int,       unsigned int,         uint)
+INPUT_TYPEMAP(long,               long,                 SWIG_LONG_DTYPE)
+INPUT_TYPEMAP(unsigned long,      unsigned long,        SWIG_ULONG_DTYPE)
+INPUT_TYPEMAP(long long,          long long,            long)
+INPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong)
+INPUT_TYPEMAP(float,              float,                float)
+INPUT_TYPEMAP(double,             double,               double)
+
+INPUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int)
+%typemap(dtype) enum SWIGTYPE *INPUT, enum SWIGTYPE &INPUT "$*dclassname"
+
+#undef INPUT_TYPEMAP
+
+
+/*
+OUTPUT typemaps
+---------------
+
+These typemaps are used for pointer/reference parameters that are output only and
+are mapped to a D output parameter.
+
+The following typemaps can be applied to turn a pointer or reference into an
+"output" value. When calling a function, no input value would be given for
+a parameter, but an output value would be returned. In D, the 'out' keyword is
+used when passing the parameter to a function that takes an output parameter.
+
+        bool               *OUTPUT, bool               &OUTPUT
+        signed char        *OUTPUT, signed char        &OUTPUT
+        unsigned char      *OUTPUT, unsigned char      &OUTPUT
+        short              *OUTPUT, short              &OUTPUT
+        unsigned short     *OUTPUT, unsigned short     &OUTPUT
+        int                *OUTPUT, int                &OUTPUT
+        unsigned int       *OUTPUT, unsigned int       &OUTPUT
+        long               *OUTPUT, long               &OUTPUT
+        unsigned long      *OUTPUT, unsigned long      &OUTPUT
+        long long          *OUTPUT, long long          &OUTPUT
+        unsigned long long *OUTPUT, unsigned long long &OUTPUT
+        float              *OUTPUT, float              &OUTPUT
+        double             *OUTPUT, double             &OUTPUT
+
+For example, suppose you were trying to wrap the modf() function in the
+C math library which splits x into integral and fractional parts (and
+returns the integer part in one of its parameters):
+
+        double modf(double x, double *ip);
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double modf(double x, double *OUTPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *OUTPUT { double *ip };
+        double modf(double x, double *ip);
+
+The D output of the function would be the function return value and the
+value returned in the second output parameter. In D you would use it like this:
+
+    double dptr;
+    double fraction = modf(5, dptr);
+*/
+
+%define OUTPUT_TYPEMAP(TYPE, CTYPE, DTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"
+%typemap(imtype, out="void*") TYPE *OUTPUT, TYPE &OUTPUT "out DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *OUTPUT, TYPE &OUTPUT "out DTYPE"
+%typemap(din) TYPE *OUTPUT, TYPE &OUTPUT "$dinput"
+
+%typemap(in) TYPE *OUTPUT, TYPE &OUTPUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *OUTPUT, TYPE &OUTPUT ""
+%enddef
+
+OUTPUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//OUTPUT_TYPEMAP(char,               char,                 char,     CHAR_PTR) // Why was this commented out?
+OUTPUT_TYPEMAP(signed char,        signed char,          byte,     INT8_PTR)
+OUTPUT_TYPEMAP(unsigned char,      unsigned char,        ubyte,    UINT8_PTR)
+OUTPUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+OUTPUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+OUTPUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+OUTPUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+OUTPUT_TYPEMAP(long,               long,           SWIG_LONG_DTYPE,INT32_PTR)
+OUTPUT_TYPEMAP(unsigned long,      unsigned long, SWIG_ULONG_DTYPE,UINT32_PTR)
+OUTPUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+OUTPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+OUTPUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+OUTPUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+OUTPUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int,      INT32_PTR)
+%typemap(dtype) enum SWIGTYPE *OUTPUT, enum SWIGTYPE &OUTPUT "out $*dclassname"
+
+#undef OUTPUT_TYPEMAP
+
+%typemap(in) bool *OUTPUT, bool &OUTPUT
+%{ *$input = 0;
+   $1 = ($1_ltype)$input; %}
+
+
+/*
+INOUT typemaps
+--------------
+
+These typemaps are for pointer/reference parameters that are both input and
+output and are mapped to a D reference parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a
+reference parameters, that is the parameter is both an input and an output.
+In D, the 'ref' keyword is used for reference parameters.
+
+        bool               *INOUT, bool               &INOUT
+        signed char        *INOUT, signed char        &INOUT
+        unsigned char      *INOUT, unsigned char      &INOUT
+        short              *INOUT, short              &INOUT
+        unsigned short     *INOUT, unsigned short     &INOUT
+        int                *INOUT, int                &INOUT
+        unsigned int       *INOUT, unsigned int       &INOUT
+        long               *INOUT, long               &INOUT
+        unsigned long      *INOUT, unsigned long      &INOUT
+        long long          *INOUT, long long          &INOUT
+        unsigned long long *INOUT, unsigned long long &INOUT
+        float              *INOUT, float              &INOUT
+        double             *INOUT, double             &INOUT
+
+For example, suppose you were trying to wrap the following function :
+
+        void neg(double *x) {
+             *x = -(*x);
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        void neg(double *INOUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *x };
+        void neg(double *x);
+
+The D output of the function would be the new value returned by the
+reference parameter. In D you would use it like this:
+
+
+       double x = 5.0;
+       neg(x);
+
+The implementation of the OUTPUT and INOUT typemaps is different to the scripting
+languages in that the scripting languages will return the output value as part
+of the function return value.
+*/
+
+%define INOUT_TYPEMAP(TYPE, CTYPE, DTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *INOUT, TYPE &INOUT "CTYPE *"
+%typemap(imtype, out="void*") TYPE *INOUT, TYPE &INOUT "ref DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *INOUT, TYPE &INOUT "ref DTYPE"
+%typemap(din) TYPE *INOUT, TYPE &INOUT "$dinput"
+
+%typemap(in) TYPE *INOUT, TYPE &INOUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *INOUT, TYPE &INOUT ""
+%enddef
+
+INOUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//INOUT_TYPEMAP(char,               char,                 char,     CHAR_PTR)
+INOUT_TYPEMAP(signed char,        signed char,          byte,     INT8_PTR)
+INOUT_TYPEMAP(unsigned char,      unsigned char,        ubyte,    UINT8_PTR)
+INOUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+INOUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+INOUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+INOUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+INOUT_TYPEMAP(long,               long,           SWIG_LONG_DTYPE,INT32_PTR)
+INOUT_TYPEMAP(unsigned long,      unsigned long, SWIG_ULONG_DTYPE,UINT32_PTR)
+INOUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+INOUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+INOUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+INOUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+INOUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int,      INT32_PTR)
+%typemap(dtype) enum SWIGTYPE *INOUT, enum SWIGTYPE &INOUT "ref $*dclassname"
+
+#undef INOUT_TYPEMAP
diff --git a/share/swig/2.0.11/d/wrapperloader.swg b/share/swig/2.0.11/d/wrapperloader.swg
new file mode 100644
index 0000000..b3c1d0d
--- /dev/null
+++ b/share/swig/2.0.11/d/wrapperloader.swg
@@ -0,0 +1,308 @@
+/* -----------------------------------------------------------------------------
+ * wrapperloader.swg
+ *
+ * Support code for dynamically linking the C wrapper library from the D
+ * wrapper module.
+ *
+ * The loading code was adapted from the Derelict project and is used with
+ * permission from Michael Parker, the original author.
+ * ----------------------------------------------------------------------------- */
+
+%pragma(d) wrapperloadercode = %{
+private {
+  version(linux) {
+    version = Nix;
+  } else version(darwin) {
+    version = Nix;
+  } else version(OSX) {
+    version = Nix;
+  } else version(FreeBSD) {
+    version = Nix;
+    version = freebsd;
+  } else version(freebsd) {
+    version = Nix;
+  } else version(Unix) {
+    version = Nix;
+  } else version(Posix) {
+    version = Nix;
+  }
+
+  version(Tango) {
+    static import tango.stdc.string;
+    static import tango.stdc.stringz;
+
+    version (PhobosCompatibility) {
+    } else {
+      alias char[] string;
+      alias wchar[] wstring;
+      alias dchar[] dstring;
+    }
+  } else {
+    version(D_Version2) {
+      static import std.conv;
+    }
+    static import std.string;
+    static import std.c.string;
+  }
+
+  version(D_Version2) {
+    mixin("alias const(char)* CCPTR;");
+  } else {
+    alias char* CCPTR;
+  }
+
+  CCPTR swigToCString(string str) {
+    version(Tango) {
+      return tango.stdc.stringz.toStringz(str);
+    } else {
+      return std.string.toStringz(str);
+    }
+  }
+
+  string swigToDString(CCPTR cstr) {
+    version(Tango) {
+      return tango.stdc.stringz.fromStringz(cstr);
+    } else {
+      version(D_Version2) {
+        mixin("return std.conv.to!string(cstr);");
+      } else {
+        return std.c.string.toString(cstr);
+      }
+    }
+  }
+}
+
+class SwigSwigSharedLibLoadException : Exception {
+  this(in string[] libNames, in string[] reasons) {
+    string msg = "Failed to load one or more shared libraries:";
+    foreach(i, n; libNames) {
+      msg ~= "\n\t" ~ n ~ " - ";
+      if(i < reasons.length)
+        msg ~= reasons[i];
+      else
+        msg ~= "Unknown";
+    }
+    super(msg);
+  }
+}
+
+class SwigSymbolLoadException : Exception {
+  this(string SwigSharedLibName, string symbolName) {
+    super("Failed to load symbol " ~ symbolName ~ " from shared library " ~ SwigSharedLibName);
+    _symbolName = symbolName;
+  }
+
+  string symbolName() {
+    return _symbolName;
+  }
+
+private:
+  string _symbolName;
+}
+
+private {
+  version(Nix) {
+    version(freebsd) {
+      // the dl* functions are in libc on FreeBSD
+    }
+    else {
+      pragma(lib, "dl");
+    }
+
+    version(Tango) {
+      import tango.sys.Common;
+    } else version(linux) {
+      import std.c.linux.linux;
+    } else {
+      extern(C) {
+        const RTLD_NOW = 2;
+
+        void *dlopen(CCPTR file, int mode);
+        int dlclose(void* handle);
+        void *dlsym(void* handle, CCPTR name);
+        CCPTR dlerror();
+      }
+    }
+
+    alias void* SwigSharedLibHandle;
+
+    SwigSharedLibHandle swigLoadSharedLib(string libName) {
+      return dlopen(swigToCString(libName), RTLD_NOW);
+    }
+
+    void swigUnloadSharedLib(SwigSharedLibHandle hlib) {
+      dlclose(hlib);
+    }
+
+    void* swigGetSymbol(SwigSharedLibHandle hlib, string symbolName) {
+      return dlsym(hlib, swigToCString(symbolName));
+    }
+
+    string swigGetErrorStr() {
+      CCPTR err = dlerror();
+      if (err is null) {
+        return "Unknown Error";
+      }
+      return swigToDString(err);
+    }
+  } else version(Windows) {
+    alias ushort WORD;
+    alias uint DWORD;
+    alias CCPTR LPCSTR;
+    alias void* HMODULE;
+    alias void* HLOCAL;
+    alias int function() FARPROC;
+    struct VA_LIST {}
+
+    extern (Windows) {
+      HMODULE LoadLibraryA(LPCSTR);
+      FARPROC GetProcAddress(HMODULE, LPCSTR);
+      void FreeLibrary(HMODULE);
+      DWORD GetLastError();
+      DWORD FormatMessageA(DWORD, in void*, DWORD, DWORD, LPCSTR, DWORD, VA_LIST*);
+      HLOCAL LocalFree(HLOCAL);
+    }
+
+    DWORD MAKELANGID(WORD p, WORD s) {
+      return (((cast(WORD)s) << 10) | cast(WORD)p);
+    }
+
+    enum {
+      LANG_NEUTRAL                    = 0,
+      SUBLANG_DEFAULT                 = 1,
+      FORMAT_MESSAGE_ALLOCATE_BUFFER  = 256,
+      FORMAT_MESSAGE_IGNORE_INSERTS   = 512,
+      FORMAT_MESSAGE_FROM_SYSTEM      = 4096
+    }
+
+    alias HMODULE SwigSharedLibHandle;
+
+    SwigSharedLibHandle swigLoadSharedLib(string libName) {
+      return LoadLibraryA(swigToCString(libName));
+    }
+
+    void swigUnloadSharedLib(SwigSharedLibHandle hlib) {
+      FreeLibrary(hlib);
+    }
+
+    void* swigGetSymbol(SwigSharedLibHandle hlib, string symbolName) {
+      return GetProcAddress(hlib, swigToCString(symbolName));
+    }
+
+    string swigGetErrorStr() {
+      DWORD errcode = GetLastError();
+
+      LPCSTR msgBuf;
+      DWORD i = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        null,
+        errcode,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        cast(LPCSTR)&msgBuf,
+        0,
+        null);
+
+      string text = swigToDString(msgBuf);
+      LocalFree(cast(HLOCAL)msgBuf);
+
+      if (i >= 2) {
+        i -= 2;
+      }
+      return text[0 .. i];
+    }
+  } else {
+    static assert(0, "Operating system not supported by the wrapper loading code.");
+  }
+
+  final class SwigSharedLib {
+    void load(string[] names) {
+      if (_hlib !is null) return;
+
+      string[] failedLibs;
+      string[] reasons;
+
+      foreach(n; names) {
+        _hlib = swigLoadSharedLib(n);
+        if (_hlib is null) {
+          failedLibs ~= n;
+          reasons ~= swigGetErrorStr();
+          continue;
+        }
+        _name = n;
+        break;
+      }
+
+      if (_hlib is null) {
+        throw new SwigSwigSharedLibLoadException(failedLibs, reasons);
+      }
+    }
+
+    void* loadSymbol(string symbolName, bool doThrow = true) {
+      void* sym = swigGetSymbol(_hlib, symbolName);
+      if(doThrow && (sym is null)) {
+        throw new SwigSymbolLoadException(_name, symbolName);
+      }
+      return sym;
+    }
+
+    void unload() {
+      if(_hlib !is null) {
+        swigUnloadSharedLib(_hlib);
+        _hlib = null;
+      }
+    }
+
+  private:
+    string _name;
+    SwigSharedLibHandle _hlib;
+  }
+}
+
+static this() {
+  string[] possibleFileNames;
+  version (Posix) {
+    version (OSX) {
+      possibleFileNames ~= ["lib$wraplibrary.dylib", "lib$wraplibrary.bundle"];
+    }
+    possibleFileNames ~= ["lib$wraplibrary.so"];
+  } else version (Windows) {
+    possibleFileNames ~= ["$wraplibrary.dll", "lib$wraplibrary.so"];
+  } else {
+    static assert(false, "Operating system not supported by the wrapper loading code.");
+  }
+
+  auto library = new SwigSharedLib;
+  library.load(possibleFileNames);
+
+  string bindCode(string functionPointer, string symbol) {
+    return functionPointer ~ " = cast(typeof(" ~ functionPointer ~
+      "))library.loadSymbol(`" ~ symbol ~ "`);";
+  }
+
+  //#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+  mixin(bindCode("swigRegisterExceptionCallbacks$module", "SWIGRegisterExceptionCallbacks_$module"));
+  //#endif // SWIG_D_NO_EXCEPTION_HELPER
+  //#if !defined(SWIG_D_NO_STRING_HELPER)
+  mixin(bindCode("swigRegisterStringCallback$module", "SWIGRegisterStringCallback_$module"));
+  //#endif // SWIG_D_NO_STRING_HELPER
+  $wrapperloaderbindcode
+}
+
+//#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+extern(C) void function(
+  SwigExceptionCallback exceptionCallback,
+  SwigExceptionCallback illegalArgumentCallback,
+  SwigExceptionCallback illegalElementCallback,
+  SwigExceptionCallback ioCallback,
+  SwigExceptionCallback noSuchElementCallback) swigRegisterExceptionCallbacks$module;
+//#endif // SWIG_D_NO_EXCEPTION_HELPER
+
+//#if !defined(SWIG_D_NO_STRING_HELPER)
+extern(C) void function(SwigStringCallback callback) swigRegisterStringCallback$module;
+//#endif // SWIG_D_NO_STRING_HELPER
+%}
+
+%pragma(d) wrapperloaderbindcommand = %{
+  mixin(bindCode("$function", "$symbol"));%}
diff --git a/share/swig/2.0.11/exception.i b/share/swig/2.0.11/exception.i
new file mode 100644
index 0000000..050042d
--- /dev/null
+++ b/share/swig/2.0.11/exception.i
@@ -0,0 +1,304 @@
+/* -----------------------------------------------------------------------------
+ * exception.i
+ *
+ * SWIG library file providing language independent exception handling
+ * ----------------------------------------------------------------------------- */
+
+#if defined(SWIGUTL)
+#error "This version of exception.i should not be used"
+#endif
+
+
+%insert("runtime") "swigerrors.swg"
+
+
+#ifdef SWIGPHP
+%{
+#include "zend_exceptions.h"
+#define SWIG_exception(code, msg) { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); }
+%}
+#endif
+
+#ifdef SWIGGUILE
+%{
+  SWIGINTERN void SWIG_exception_ (int code, const char *msg,
+                               const char *subr) {
+#define ERROR(scmerr)					\
+	scm_error(scm_from_locale_string((char *) (scmerr)),	\
+		  (char *) subr, (char *) msg,		\
+		  SCM_EOL, SCM_BOOL_F)
+#define MAP(swigerr, scmerr)			\
+	case swigerr:				\
+	  ERROR(scmerr);			\
+	  break
+    switch (code) {
+      MAP(SWIG_MemoryError,	"swig-memory-error");
+      MAP(SWIG_IOError,		"swig-io-error");
+      MAP(SWIG_RuntimeError,	"swig-runtime-error");
+      MAP(SWIG_IndexError,	"swig-index-error");
+      MAP(SWIG_TypeError,	"swig-type-error");
+      MAP(SWIG_DivisionByZero,	"swig-division-by-zero");
+      MAP(SWIG_OverflowError,	"swig-overflow-error");
+      MAP(SWIG_SyntaxError,	"swig-syntax-error");
+      MAP(SWIG_ValueError,	"swig-value-error");
+      MAP(SWIG_SystemError,	"swig-system-error");
+    default:
+      ERROR("swig-error");
+    }
+#undef ERROR
+#undef MAP
+  }
+
+#define SWIG_exception(a,b) SWIG_exception_(a, b, FUNC_NAME)
+%}
+#endif
+
+#ifdef SWIGMZSCHEME
+
+%{
+SWIGINTERN void SWIG_exception_ (int code, const char *msg) {
+#define ERROR(errname)				\
+	scheme_signal_error(errname " (%s)", msg);
+#define MAP(swigerr, errname)			\
+	case swigerr:				\
+	  ERROR(errname);			\
+	  break
+    switch (code) {
+      MAP(SWIG_MemoryError,	"swig-memory-error");
+      MAP(SWIG_IOError,		"swig-io-error");
+      MAP(SWIG_RuntimeError,	"swig-runtime-error");
+      MAP(SWIG_IndexError,	"swig-index-error");
+      MAP(SWIG_TypeError,	"swig-type-error");
+      MAP(SWIG_DivisionByZero,	"swig-division-by-zero");
+      MAP(SWIG_OverflowError,	"swig-overflow-error");
+      MAP(SWIG_SyntaxError,	"swig-syntax-error");
+      MAP(SWIG_ValueError,	"swig-value-error");
+      MAP(SWIG_SystemError,	"swig-system-error");
+    default:
+      ERROR("swig-error");
+    }
+#undef ERROR
+#undef MAP
+  }
+
+#define SWIG_exception(a,b) SWIG_exception_(a, b)
+%}
+#endif
+
+#ifdef SWIGJAVA
+%{
+SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
+  SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
+  switch(code) {
+  case SWIG_MemoryError:
+    exception_code = SWIG_JavaOutOfMemoryError;
+    break;
+  case SWIG_IOError:
+    exception_code = SWIG_JavaIOException;
+    break;
+  case SWIG_SystemError:
+  case SWIG_RuntimeError:
+    exception_code = SWIG_JavaRuntimeException;
+    break;
+  case SWIG_OverflowError:
+  case SWIG_IndexError:
+    exception_code = SWIG_JavaIndexOutOfBoundsException;
+    break;
+  case SWIG_DivisionByZero:
+    exception_code = SWIG_JavaArithmeticException;
+    break;
+  case SWIG_SyntaxError:
+  case SWIG_ValueError:
+  case SWIG_TypeError:
+    exception_code = SWIG_JavaIllegalArgumentException;
+    break;
+  case SWIG_UnknownError:
+  default:
+    exception_code = SWIG_JavaUnknownError;
+    break;
+  }
+  SWIG_JavaThrowException(jenv, exception_code, msg);
+}
+%}
+
+#define SWIG_exception(code, msg)\
+{ SWIG_JavaException(jenv, code, msg); return $null; }
+#endif // SWIGJAVA
+
+#ifdef SWIGOCAML
+%{
+#define OCAML_MSG_BUF_LEN 1024
+SWIGINTERN void SWIG_exception_(int code, const char *msg) {
+  char msg_buf[OCAML_MSG_BUF_LEN];
+  sprintf( msg_buf, "Exception(%d): %s\n", code, msg );
+  failwith( msg_buf );
+}
+#define SWIG_exception(a,b) SWIG_exception_((a),(b))
+%}
+#endif
+
+
+#ifdef SWIGCHICKEN
+%{
+SWIGINTERN void SWIG_exception_(int code, const char *msg) {
+  C_word *a;
+  C_word scmmsg;
+  C_word list;
+
+  a = C_alloc (C_SIZEOF_STRING (strlen (msg)) + C_SIZEOF_LIST(2));
+  scmmsg = C_string2 (&a, (char *) msg);
+  list = C_list(&a, 2, C_fix(code), scmmsg);
+  SWIG_ThrowException(list);
+}
+#define SWIG_exception(a,b) SWIG_exception_((a),(b))
+%}
+#endif
+
+#ifdef SWIGCSHARP
+%{
+SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
+  if (code == SWIG_ValueError) {
+    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
+    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
+  } else {
+    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
+    switch(code) {
+    case SWIG_MemoryError:
+      exception_code = SWIG_CSharpOutOfMemoryException;
+      break;
+    case SWIG_IndexError:
+      exception_code = SWIG_CSharpIndexOutOfRangeException;
+      break;
+    case SWIG_DivisionByZero:
+      exception_code = SWIG_CSharpDivideByZeroException;
+      break;
+    case SWIG_IOError:
+      exception_code = SWIG_CSharpIOException;
+      break;
+    case SWIG_OverflowError:
+      exception_code = SWIG_CSharpOverflowException;
+      break;
+    case SWIG_RuntimeError:
+    case SWIG_TypeError:
+    case SWIG_SyntaxError:
+    case SWIG_SystemError:
+    case SWIG_UnknownError:
+    default:
+      exception_code = SWIG_CSharpApplicationException;
+      break;
+    }
+    SWIG_CSharpSetPendingException(exception_code, msg);
+  }
+}
+%}
+
+#define SWIG_exception(code, msg)\
+{ SWIG_CSharpException(code, msg); return $null; }
+#endif // SWIGCSHARP
+
+#ifdef SWIGLUA
+
+%{
+#define SWIG_exception(a,b)\
+{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; }
+%}
+
+#endif // SWIGLUA
+
+#ifdef SWIGD
+%{
+SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
+  SWIG_DExceptionCodes exception_code;
+  switch(code) {
+  case SWIG_IndexError:
+    exception_code = SWIG_DNoSuchElementException;
+    break;
+  case SWIG_IOError:
+    exception_code = SWIG_DIOException;
+    break;
+  case SWIG_ValueError:
+    exception_code = SWIG_DIllegalArgumentException;
+    break;
+  case SWIG_DivisionByZero:
+  case SWIG_MemoryError:
+  case SWIG_OverflowError:
+  case SWIG_RuntimeError:
+  case SWIG_TypeError:
+  case SWIG_SyntaxError:
+  case SWIG_SystemError:
+  case SWIG_UnknownError:
+  default:
+    exception_code = SWIG_DException;
+    break;
+  }
+  SWIG_DSetPendingException(exception_code, msg);
+}
+%}
+
+#define SWIG_exception(code, msg)\
+{ SWIG_DThrowException(code, msg); return $null; }
+#endif // SWIGD
+
+#ifdef __cplusplus
+/*
+  You can use the SWIG_CATCH_STDEXCEPT macro with the %exception
+  directive as follows:
+
+  %exception {
+    try {
+      $action
+    }
+    catch (my_except& e) {
+      ...
+    }
+    SWIG_CATCH_STDEXCEPT // catch std::exception
+    catch (...) {
+     SWIG_exception(SWIG_UnknownError, "Unknown exception");
+    }
+  }
+*/
+%{
+#include <stdexcept>
+%}
+%define SWIG_CATCH_STDEXCEPT
+  /* catching std::exception  */
+  catch (std::invalid_argument& e) {
+    SWIG_exception(SWIG_ValueError, e.what() );
+  } catch (std::domain_error& e) {
+    SWIG_exception(SWIG_ValueError, e.what() );
+  } catch (std::overflow_error& e) {
+    SWIG_exception(SWIG_OverflowError, e.what() );
+  } catch (std::out_of_range& e) {
+    SWIG_exception(SWIG_IndexError, e.what() );
+  } catch (std::length_error& e) {
+    SWIG_exception(SWIG_IndexError, e.what() );
+  } catch (std::runtime_error& e) {
+    SWIG_exception(SWIG_RuntimeError, e.what() );
+  } catch (std::exception& e) {
+    SWIG_exception(SWIG_SystemError, e.what() );
+  }
+%enddef
+%define SWIG_CATCH_UNKNOWN
+  catch (std::exception& e) {
+    SWIG_exception(SWIG_SystemError, e.what() );
+  }
+  catch (...) {
+    SWIG_exception(SWIG_UnknownError, "unknown exception");
+  }
+%enddef
+
+/* rethrow the unknown exception */
+
+#if defined(SWIGCSHARP) || defined(SWIGD)
+%typemap(throws,noblock=1, canthrow=1) (...) {
+  SWIG_exception(SWIG_RuntimeError,"unknown exception");
+}
+#else
+%typemap(throws,noblock=1) (...) {
+  SWIG_exception(SWIG_RuntimeError,"unknown exception");
+}
+#endif
+
+#endif /* __cplusplus */
+
+/* exception.i ends here */
diff --git a/share/swig/2.0.11/gcj/cni.i b/share/swig/2.0.11/gcj/cni.i
new file mode 100644
index 0000000..b12148e
--- /dev/null
+++ b/share/swig/2.0.11/gcj/cni.i
@@ -0,0 +1,43 @@
+%{
+#include <gcj/cni.h>
+%}
+
+%include <gcj/javaprims.i>
+
+extern jobject JvAllocObject (jclass cls);
+
+extern jobject JvAllocObject (jclass cls, jsize sz);
+
+extern void JvInitClass (jclass cls);
+
+extern jstring JvAllocString (jsize sz);
+
+extern jstring JvNewString (const jchar *chars, jsize len);
+
+extern jstring JvNewStringLatin1 (const char *bytes, jsize len);
+
+extern jstring JvNewStringLatin1 (const char *bytes);
+
+extern jchar* JvGetStringChars (jstring str);
+
+extern jsize JvGetStringUTFLength (jstring string);
+
+extern jsize JvGetStringUTFRegion (jstring str, jsize start, jsize len, char *buf);
+
+extern jstring JvNewStringUTF (const char *bytes);
+
+extern void *JvMalloc (jsize size);
+
+extern void JvFree (void *ptr);
+
+extern jint JvCreateJavaVM (void* vm_args);
+
+extern java::lang::Thread* JvAttachCurrentThread (jstring name, java::lang::ThreadGroup* group);
+
+extern java::lang::Thread* JvAttachCurrentThreadAsDaemon (jstring name, java::lang::ThreadGroup* group);
+
+extern jint JvDetachCurrentThread (void);
+
+
+%include <gcj/cni.swg>
+
diff --git a/share/swig/2.0.11/gcj/cni.swg b/share/swig/2.0.11/gcj/cni.swg
new file mode 100644
index 0000000..4bd07df
--- /dev/null
+++ b/share/swig/2.0.11/gcj/cni.swg
@@ -0,0 +1,14 @@
+/* -----------------------------------------------------------------------------
+ * cni.swg
+ * ----------------------------------------------------------------------------- */
+
+#ifdef SWIG
+
+#define __attribute__(...)
+%ignore class$;
+#pragma SWIG nowarn=313,402
+
+%nodefaultdtor;
+
+#endif
+
diff --git a/share/swig/2.0.11/gcj/javaprims.i b/share/swig/2.0.11/gcj/javaprims.i
new file mode 100644
index 0000000..12c92a7
--- /dev/null
+++ b/share/swig/2.0.11/gcj/javaprims.i
@@ -0,0 +1,422 @@
+%include <stdint.i>
+
+typedef int8_t jbyte;
+typedef int16_t jshort;
+typedef int32_t jint;
+typedef int64_t jlong;
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+typedef int8_t jboolean;
+
+extern "Java" 
+{
+  namespace java
+  {
+    namespace io
+    {
+      class BufferedInputStream;
+      class BufferedOutputStream;
+      class BufferedReader;
+      class BufferedWriter;
+      class ByteArrayInputStream;
+      class ByteArrayOutputStream;
+      class CharArrayReader;
+      class CharArrayWriter;
+      class CharConversionException;
+      class DataInput;
+      class DataInputStream;
+      class DataOutput;
+      class DataOutputStream;
+      class EOFException;
+      class Externalizable;
+      class File;
+      class FileDescriptor;
+      class FileFilter;
+      class FileInputStream;
+      class FileNotFoundException;
+      class FileOutputStream;
+      class FilePermission;
+      class FileReader;
+      class FileWriter;
+      class FilenameFilter;
+      class FilterInputStream;
+      class FilterOutputStream;
+      class FilterReader;
+      class FilterWriter;
+      class IOException;
+      class InputStream;
+      class InputStreamReader;
+      class InterfaceComparator;
+      class InterruptedIOException;
+      class InvalidClassException;
+      class InvalidObjectException;
+      class LineNumberInputStream;
+      class LineNumberReader;
+      class MemberComparator;
+      class NotActiveException;
+      class NotSerializableException;
+      class ObjectInput;
+      class ObjectInputStream;
+      class ObjectInputStream$GetField;
+      class ObjectInputValidation;
+      class ObjectOutput;
+      class ObjectOutputStream;
+      class ObjectOutputStream$PutField;
+      class ObjectStreamClass;
+      class ObjectStreamConstants;
+      class ObjectStreamException;
+      class ObjectStreamField;
+      class OptionalDataException;
+      class OutputStream;
+      class OutputStreamWriter;
+      class PipedInputStream;
+      class PipedOutputStream;
+      class PipedReader;
+      class PipedWriter;
+      class PrintStream;
+      class PrintWriter;
+      class PushbackInputStream;
+      class PushbackReader;
+      class RandomAccessFile;
+      class Reader;
+      class SequenceInputStream;
+      class Serializable;
+      class SerializablePermission;
+      class StreamCorruptedException;
+      class StreamTokenizer;
+      class StringBufferInputStream;
+      class StringReader;
+      class StringWriter;
+      class SyncFailedException;
+      class UTFDataFormatException;
+      class UnsupportedEncodingException;
+      class VMObjectStreamClass;
+      class ValidatorAndPriority;
+      class WriteAbortedException;
+      class Writer;
+    }
+
+    namespace lang
+    {
+      class AbstractMethodError;
+      class ArithmeticException;
+      class ArrayIndexOutOfBoundsException;
+      class ArrayStoreException;
+      class AssertionError;
+      class Boolean;
+      class Byte;
+      class CharSequence;
+      class Character;
+      class Character$Subset;
+      class Character$UnicodeBlock;
+      class Class;
+      class ClassCastException;
+      class ClassCircularityError;
+      class ClassFormatError;
+      class ClassLoader;
+      class ClassNotFoundException;
+      class CloneNotSupportedException;
+      class Cloneable;
+      class Comparable;
+      class Compiler;
+      class ConcreteProcess;
+      class Double;
+      class Error;
+      class Exception;
+      class ExceptionInInitializerError;
+      class Float;
+      class IllegalAccessError;
+      class IllegalAccessException;
+      class IllegalArgumentException;
+      class IllegalMonitorStateException;
+      class IllegalStateException;
+      class IllegalThreadStateException;
+      class IncompatibleClassChangeError;
+      class IndexOutOfBoundsException;
+      class InheritableThreadLocal;
+      class InstantiationError;
+      class InstantiationException;
+      class Integer;
+      class InternalError;
+      class InterruptedException;
+      class LinkageError;
+      class Long;
+      class Math;
+      class NegativeArraySizeException;
+      class NoClassDefFoundError;
+      class NoSuchFieldError;
+      class NoSuchFieldException;
+      class NoSuchMethodError;
+      class NoSuchMethodException;
+      class NullPointerException;
+      class Number;
+      class NumberFormatException;
+      class Object;
+      class OutOfMemoryError;
+      class Package;
+      class Process;
+      class Runnable;
+      class Runtime;
+      class RuntimeException;
+      class RuntimePermission;
+      class SecurityContext;
+      class SecurityException;
+      class SecurityManager;
+      class Short;
+      class StackOverflowError;
+      class StackTraceElement;
+      class StrictMath;
+      class String;
+      class String$CaseInsensitiveComparator;
+      class StringBuffer;
+      class StringIndexOutOfBoundsException;
+      class System;
+      class Thread;
+      class ThreadDeath;
+      class ThreadGroup;
+      class ThreadLocal;
+      class Throwable;
+      class UnknownError;
+      class UnsatisfiedLinkError;
+      class UnsupportedClassVersionError;
+      class UnsupportedOperationException;
+      class VMClassLoader;
+      class VMSecurityManager;
+      class VMThrowable;
+      class VerifyError;
+      class VirtualMachineError;
+      class Void;
+      namespace ref
+      {
+        class PhantomReference;
+        class Reference;
+        class ReferenceQueue;
+        class SoftReference;
+        class WeakReference;
+      }
+
+      namespace reflect
+      {
+        class AccessibleObject;
+        class Array;
+        class Constructor;
+        class Field;
+        class InvocationHandler;
+        class InvocationTargetException;
+        class Member;
+        class Method;
+        class Modifier;
+        class Proxy;
+        class Proxy$ClassFactory;
+        class Proxy$ProxyData;
+        class Proxy$ProxySignature;
+        class Proxy$ProxyType;
+        class ReflectPermission;
+        class UndeclaredThrowableException;
+      }
+    }
+
+    namespace util
+    {
+      class AbstractCollection;
+      class AbstractList;
+      class AbstractMap;
+      class AbstractMap$BasicMapEntry;
+      class AbstractSequentialList;
+      class AbstractSet;
+      class ArrayList;
+      class Arrays;
+      class Arrays$ArrayList;
+      class BitSet;
+      class Calendar;
+      class Collection;
+      class Collections;
+      class Collections$CopiesList;
+      class Collections$EmptyList;
+      class Collections$EmptyMap;
+      class Collections$EmptySet;
+      class Collections$ReverseComparator;
+      class Collections$SingletonList;
+      class Collections$SingletonMap;
+      class Collections$SingletonSet;
+      class Collections$SynchronizedCollection;
+      class Collections$SynchronizedIterator;
+      class Collections$SynchronizedList;
+      class Collections$SynchronizedListIterator;
+      class Collections$SynchronizedMap;
+      class Collections$SynchronizedMapEntry;
+      class Collections$SynchronizedRandomAccessList;
+      class Collections$SynchronizedSet;
+      class Collections$SynchronizedSortedMap;
+      class Collections$SynchronizedSortedSet;
+      class Collections$UnmodifiableCollection;
+      class Collections$UnmodifiableEntrySet;
+      class Collections$UnmodifiableIterator;
+      class Collections$UnmodifiableList;
+      class Collections$UnmodifiableListIterator;
+      class Collections$UnmodifiableMap;
+      class Collections$UnmodifiableRandomAccessList;
+      class Collections$UnmodifiableSet;
+      class Collections$UnmodifiableSortedMap;
+      class Collections$UnmodifiableSortedSet;
+      class Comparator;
+      class ConcurrentModificationException;
+      class Currency;
+      class Date;
+      class Dictionary;
+      class EmptyStackException;
+      class Enumeration;
+      class EventListener;
+      class EventListenerProxy;
+      class EventObject;
+      class GregorianCalendar;
+      class HashMap;
+      class HashMap$HashEntry;
+      class HashMap$HashIterator;
+      class HashSet;
+      class Hashtable;
+      class Hashtable$Enumerator;
+      class Hashtable$HashEntry;
+      class Hashtable$HashIterator;
+      class IdentityHashMap;
+      class IdentityHashMap$IdentityEntry;
+      class IdentityHashMap$IdentityIterator;
+      class Iterator;
+      class LinkedHashMap;
+      class LinkedHashMap$LinkedHashEntry;
+      class LinkedHashSet;
+      class LinkedList;
+      class LinkedList$Entry;
+      class LinkedList$LinkedListItr;
+      class List;
+      class ListIterator;
+      class ListResourceBundle;
+      class Locale;
+      class Map;
+      class Map$Entry;
+      class Map$Map;
+      class MissingResourceException;
+      class MyResources;
+      class NoSuchElementException;
+      class Observable;
+      class Observer;
+      class Properties;
+      class PropertyPermission;
+      class PropertyPermissionCollection;
+      class PropertyResourceBundle;
+      class Random;
+      class RandomAccess;
+      class RandomAccessSubList;
+      class ResourceBundle;
+      class Set;
+      class SimpleTimeZone;
+      class SortedMap;
+      class SortedSet;
+      class Stack;
+      class StringTokenizer;
+      class SubList;
+      class TimeZone;
+      class Timer;
+      class Timer$Scheduler;
+      class Timer$TaskQueue;
+      class TimerTask;
+      class TooManyListenersException;
+      class TreeMap;
+      class TreeMap$Node;
+      class TreeMap$SubMap;
+      class TreeMap$TreeIterator;
+      class TreeSet;
+      class Vector;
+      class WeakHashMap;
+      class WeakHashMap$WeakBucket;
+      class WeakHashMap$WeakEntry;
+      class WeakHashMap$WeakEntrySet;
+      namespace jar
+      {
+        class Attributes;
+        class Attributes$Name;
+        class JarEntry;
+        class JarException;
+        class JarFile;
+        class JarFile$JarEnumeration;
+        class JarInputStream;
+        class JarOutputStream;
+        class Manifest;
+      }
+
+      namespace logging
+      {
+        class ConsoleHandler;
+        class ErrorManager;
+        class FileHandler;
+        class Filter;
+        class Formatter;
+        class Handler;
+        class Level;
+        class LogManager;
+        class LogRecord;
+        class Logger;
+        class LoggingPermission;
+        class MemoryHandler;
+        class SimpleFormatter;
+        class SocketHandler;
+        class StreamHandler;
+        class XMLFormatter;
+      }
+
+      namespace prefs
+      {
+        class AbstractPreferences;
+        class BackingStoreException;
+        class InvalidPreferencesFormatException;
+        class NodeChangeEvent;
+        class NodeChangeListener;
+        class PreferenceChangeEvent;
+        class PreferenceChangeListener;
+        class Preferences;
+        class PreferencesFactory;
+      }
+
+      namespace regex
+      {
+        class Matcher;
+        class Pattern;
+        class PatternSyntaxException;
+      }
+
+      namespace zip
+      {
+        class Adler32;
+        class CRC32;
+        class CheckedInputStream;
+        class CheckedOutputStream;
+        class Checksum;
+        class DataFormatException;
+        class Deflater;
+        class DeflaterOutputStream;
+        class GZIPInputStream;
+        class GZIPOutputStream;
+        class Inflater;
+        class InflaterInputStream;
+        class ZipConstants;
+        class ZipEntry;
+        class ZipException;
+        class ZipFile;
+        class ZipFile$PartialInputStream;
+        class ZipFile$ZipEntryEnumeration;
+        class ZipInputStream;
+        class ZipOutputStream;
+      }
+    }
+  }
+}
+  
+typedef class java::lang::Object* jobject;
+typedef class java::lang::Class* jclass;
+typedef class java::lang::Throwable* jthrowable;
+typedef class java::lang::String* jstring;
+
+
+%include <gcj/cni.swg>
+
diff --git a/share/swig/2.0.11/go/cdata.i b/share/swig/2.0.11/go/cdata.i
new file mode 100644
index 0000000..0dac642
--- /dev/null
+++ b/share/swig/2.0.11/go/cdata.i
@@ -0,0 +1,64 @@
+/* -----------------------------------------------------------------------------
+ * cdata.i
+ *
+ * SWIG library file containing macros for manipulating raw C data as strings.
+ * ----------------------------------------------------------------------------- */
+
+%{
+typedef struct SWIGCDATA {
+    char *data;
+    int   len;
+} SWIGCDATA;
+%}
+
+%typemap(gotype) SWIGCDATA %{ []byte %}
+%typemap(out) SWIGCDATA %{
+  $result.data = (char*)_swig_goallocate($1.len);
+  memcpy($result.data, $1.data, $1.len);
+  $result.len = (int)$1.len;
+%}
+
+/* -----------------------------------------------------------------------------
+ * %cdata(TYPE [, NAME]) 
+ *
+ * Convert raw C data to a binary string.
+ * ----------------------------------------------------------------------------- */
+
+%define %cdata(TYPE,NAME...)
+
+%insert("header") {
+#if #NAME == ""
+static SWIGCDATA cdata_##TYPE(TYPE *ptr, int nelements) {
+#else
+static SWIGCDATA cdata_##NAME(TYPE *ptr, int nelements) {
+#endif
+   SWIGCDATA d;
+   d.data = (char *) ptr;
+#if #TYPE != "void"
+   d.len  = nelements*sizeof(TYPE);
+#else
+   d.len  = nelements;
+#endif
+   return d;
+}
+}
+
+%typemap(default) int nelements "$1 = 1;"
+
+#if #NAME == ""
+SWIGCDATA cdata_##TYPE(TYPE *ptr, int nelements);
+#else
+SWIGCDATA cdata_##NAME(TYPE *ptr, int nelements);
+#endif
+%enddef
+
+%typemap(default) int nelements;
+
+%rename(cdata) ::cdata_void(void *ptr, int nelements);
+
+%cdata(void);
+
+/* Memory move function. Due to multi-argument typemaps this appears
+   to be wrapped as
+   void memmove(void *data, const char *s); */
+void memmove(void *data, char *indata, int inlen);
diff --git a/share/swig/2.0.11/go/exception.i b/share/swig/2.0.11/go/exception.i
new file mode 100644
index 0000000..5abd306
--- /dev/null
+++ b/share/swig/2.0.11/go/exception.i
@@ -0,0 +1,7 @@
+%typemap(throws,noblock=1) (...) {
+  SWIG_exception(SWIG_RuntimeError,"unknown exception");
+}
+
+%insert("runtime") %{
+#define SWIG_exception(code, msg) _swig_gopanic(msg)
+%}
diff --git a/share/swig/2.0.11/go/go.swg b/share/swig/2.0.11/go/go.swg
new file mode 100644
index 0000000..cc3beef
--- /dev/null
+++ b/share/swig/2.0.11/go/go.swg
@@ -0,0 +1,541 @@
+/* ------------------------------------------------------------
+ * go.swg
+ *
+ * Go configuration module.
+ * ------------------------------------------------------------ */
+
+/* Basic types */
+
+%typemap(gotype) bool,               const bool &               "bool"
+%typemap(gotype) char,               const char &               "byte"
+%typemap(gotype) signed char,        const signed char &        "int8"
+%typemap(gotype) unsigned char,      const unsigned char &      "byte"
+%typemap(gotype) short,              const short &              "int16"
+%typemap(gotype) unsigned short,     const unsigned short &     "uint16"
+%typemap(gotype) int,                const int &                "int"
+%typemap(gotype) unsigned int,       const unsigned int &       "uint"
+#if SWIGGO_LONG_TYPE_SIZE == 32
+%typemap(gotype) long,               const long &               "int32"
+%typemap(gotype) unsigned long,      const unsigned long &      "uint32"
+#elif SWIGGO_LONG_TYPE_SIZE == 64
+%typemap(gotype) long,               const long &               "int64"
+%typemap(gotype) unsigned long,      const unsigned long &      "uint64"
+#else
+#error "SWIGGO_LONG_TYPE_SIZE not 32 or 64"
+#endif
+%typemap(gotype) long long,          const long long &          "int64"
+%typemap(gotype) unsigned long long, const unsigned long long & "uint64"
+%typemap(gotype) float,              const float &              "float32"
+%typemap(gotype) double,             const double &             "float64"
+
+%typemap(in) bool,
+	     char,
+	     signed char,
+	     unsigned char,
+	     short,
+	     unsigned short,
+	     int,
+	     unsigned int,
+	     long,
+	     unsigned long,
+	     long long,
+	     unsigned long long,
+	     float,
+	     double
+%{ $1 = ($1_ltype)$input; %}
+
+%typemap(in) const bool &,
+	     const char &,
+	     const signed char &,
+	     const unsigned char &,
+	     const short &,
+	     const unsigned short &,
+	     const int &,
+	     const unsigned int &,
+	     const long &,
+	     const unsigned long &,
+	     const long long &,
+	     const unsigned long long &,
+	     const float &,
+	     const double &
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(out) bool,
+	      char,
+	      signed char,
+	      unsigned char,
+	      short,
+	      unsigned short,
+	      int,
+	      unsigned int,
+	      long,
+	      unsigned long,
+	      long long,
+	      unsigned long long,
+	      float,
+	      double
+%{ $result = $1; %}
+
+%typemap(out) const bool &,
+	      const char &,
+	      const signed char &,
+	      const unsigned char &,
+	      const short &,
+	      const unsigned short &,
+	      const int &,
+	      const unsigned int &,
+	      const long &,
+	      const unsigned long &,
+	      const long long &,
+	      const unsigned long long &,
+	      const float &,
+	      const double &
+%{ $result = ($*1_ltype)*$1; %}
+
+%typemap(out) void ""
+
+%typemap(directorin) bool,
+		     char,
+		     signed char,
+		     unsigned char,
+		     short,
+		     unsigned short,
+		     int,
+		     unsigned int,
+		     long,
+		     unsigned long,
+		     long long,
+		     unsigned long long,
+		     float,
+		     double
+%{ $input = ($1_ltype)$1; %}
+
+%typemap(directorin) const bool &,
+		     const char &,
+		     const signed char &,
+		     const unsigned char &,
+		     const short &,
+		     const unsigned short &,
+		     const int &,
+		     const unsigned int &,
+		     const long &,
+		     const unsigned long &,
+		     const long long &,
+		     const unsigned long long &,
+		     const float &,
+		     const double &
+%{ $input = ($*1_ltype)$1; %}
+
+%typemap(directorout) bool,
+		      char,
+		      signed char,
+		      unsigned char,
+		      short,
+		      unsigned short,
+		      int,
+		      unsigned int,
+		      long,
+		      unsigned long,
+		      long long,
+		      unsigned long long,
+		      float,
+		      double
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorout) const bool &,
+		      const char &,
+		      const signed char &,
+		      const unsigned char &,
+		      const short &,
+		      const unsigned short &,
+		      const int &,
+		      const unsigned int &,
+		      const long &,
+		      const unsigned long &,
+		      const long long &,
+		      const unsigned long long &,
+		      const float &,
+		      const double &
+%{
+  $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
+  *$result = *($1_ltype)&$input;
+%}
+
+/* The size_t type.  */
+
+#if SWIGGO_LONG_TYPE_SIZE == 32
+%typemap(gotype) size_t, const size_t & %{int%}
+#else
+%typemap(gotype) size_t, const size_t & %{int64%}
+#endif
+
+%typemap(in) size_t
+%{ $1 = (size_t)$input; %}
+
+%typemap(in) const size_t &
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(out) size_t
+%{ $result = $1; %}
+
+%typemap(out) const size_t &
+%{ $result = ($*1_ltype)*$1; %}
+
+%typemap(directorin) size_t
+%{ $input = (size_t)$1; %}
+
+%typemap(directorin) const size_t &
+%{ $input = ($*1_ltype)$1; %}
+
+%typemap(directorout) size_t
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorout) const size_t &
+%{
+  $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
+  *$result = *($1_ltype)$input;
+%}
+
+/* Member pointers.  */
+
+%typemap(gotype) SWIGTYPE (CLASS::*)
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE (CLASS::*)
+%{ $1 = *($&1_ltype)$input; %}
+
+%typemap(out) SWIGTYPE (CLASS::*)
+%{
+  $result = _swig_goallocate(sizeof($1_ltype));
+  *($&1_ltype)$result = $1;
+%}
+
+%typemap(directorin) SWIGTYPE (CLASS::*)
+%{ $input = *($&1_ltype)$1; %}
+
+%typemap(directorout) SWIGTYPE (CLASS::*)
+%{
+  $result = _swig_goallocate(sizeof($1_ltype));
+  *($&1_ltype)$result = $input;
+%}
+
+/* Pointers.  */
+
+/* We can't translate pointers using a typemap, so that is handled in
+   the C++ code.  */
+%typemap(gotype) SWIGTYPE *
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE *
+%{ $1 = *($&1_ltype)&$input; %}
+
+%typemap(out) SWIGTYPE *
+%{ *($&1_ltype)&$result = $1; %}
+
+%typemap(directorin) SWIGTYPE *
+%{ $input = ($1_ltype)$1; %}
+
+%typemap(directorout) SWIGTYPE *
+%{ $result = ($1_ltype)$input; %}
+
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* Pointer references.  */
+
+%typemap(gotype) SWIGTYPE *const&
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
+%{
+  temp = *($1_ltype)&$input;
+  $1 = ($1_ltype)&temp;
+%}
+
+%typemap(out) SWIGTYPE *const&
+%{ *($1_ltype)&$result = *$1; %}
+
+/* References.  */
+
+/* Converting a C++ reference to Go has to be handled in the C++
+   code.  */
+%typemap(gotype) SWIGTYPE &
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE &
+%{ $1 = *($&1_ltype)&$input; %}
+
+%typemap(out) SWIGTYPE &
+%{ *($&1_ltype)&$result = $1; %}
+
+%typemap(directorin) SWIGTYPE &
+%{ $input = ($1_ltype)&$1; %}
+
+%typemap(directorout) SWIGTYPE &
+%{ *($&1_ltype)&$result = $input; %}
+
+/* C arrays turn into Go pointers.  If we know the length we can use a
+   slice.  */
+
+%typemap(gotype) SWIGTYPE []
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE []
+%{ $1 = *($&1_ltype)&$input; %}
+
+%typemap(out) SWIGTYPE []
+%{ *($&1_ltype)&$result = $1; %}
+
+%typemap(directorin) SWIGTYPE []
+%{ $input = *($1_ltype)&$1; %}
+
+%typemap(directorout) SWIGTYPE []
+%{ *($&1_ltype)&$result = $input; %}
+
+/* Strings.  */
+
+%typemap(gotype)
+	char *, char *&, char[ANY], char[],
+	signed char *, signed char *&, signed char[ANY], signed char[],
+	unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
+"string"
+
+/* Needed to avoid confusion with the way the go module handles
+   references.  */
+%typemap(gotype) char&, unsigned char& "*byte"
+%typemap(gotype) signed char& "*int8"
+
+%typemap(in)
+	char *, char[ANY], char[],
+	signed char *, signed char[ANY], signed char[],
+	unsigned char *, unsigned char[ANY], unsigned char[]
+%{ $1 = ($1_ltype)$input.p; %}
+
+%typemap(in) char *&, signed char *&, unsigned char *&
+%{ $1 = ($1_ltype)$input.p; %}
+
+%typemap(out)
+	char *, char *&, char[ANY], char[],
+	signed char *, signed char *&, signed char[ANY], signed char[],
+	unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
+%{ $result = _swig_makegostring((char*)$1, $1 ? strlen((char*)$1) : 0); %}
+
+%typemap(directorin)
+	char *, char *&, char[ANY], char[],
+	signed char *, signed char *&, signed char[ANY], signed char[],
+	unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
+%{
+  $input = _swig_makegostring((char*)$1, $1 ? strlen((char*)$1) : 0);
+%}
+
+%typemap(directorout)
+	char *, char *&, char[ANY], char[],
+	signed char *, signed char *&, signed char[ANY], signed char[],
+	unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
+%{ $result = ($1_ltype)$input.p; %}
+
+/* String & length */
+
+%typemap(gotype) (char *STRING, size_t LENGTH) "string"
+
+%typemap(in) (char *STRING, size_t LENGTH)
+%{
+  $1 = ($1_ltype)$input.p;
+  $2 = ($2_ltype)$input.n;
+%}
+
+%typemap(out) (char *STRING, size_t LENGTH)
+%{ $result = _swig_makegostring((char*)$1, (size_t)$2); %}
+
+%typemap(directorin) (char *STRING, size_t LENGTH)
+%{ $input = _swig_makegostring((char*)$1, $2); %}
+
+%typemap(directorout) (char *STRING, size_t LENGTH)
+%{
+  $1 = ($1_ltype)$input.p;
+  $2 = ($2_ltype)$input.n;
+%}
+
+/* Enums.  We can't do the right thing for enums in typemap(gotype) so
+   we deliberately don't define them.  The right thing would be to
+   capitalize the name.  This is instead done in go.cxx.  */
+
+%typemap(gotype) enum SWIGTYPE
+%{$gotypename%}
+
+%typemap(in) enum SWIGTYPE
+%{ $1 = ($1_ltype)$input; %}
+
+%typemap(out) enum SWIGTYPE
+%{ $result = (intgo)$1; %}
+
+%typemap(directorin) enum SWIGTYPE
+%{ $input = ($1_ltype)$1; %}
+
+%typemap(directorout) enum SWIGTYPE
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorin) enum SWIGTYPE & (intgo e)
+%{
+  e = (intgo)$1;
+  $input = &e;
+%}
+
+%typemap(directorout) enum SWIGTYPE &
+%{
+  $*1_ltype f = ($*1_ltype)*$input;
+  $result = ($1_ltype)&f;
+%}
+
+/* Arbitrary type.  This is a type passed by value in the C/C++ code.
+   We convert it to a pointer for the Go code.  Note that all basic
+   types are explicitly handled above.  */
+
+%typemap(gotype) SWIGTYPE
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE ($&1_type argp)
+%{
+  argp = ($&1_ltype)$input;
+  if (argp == NULL) {
+    _swig_gopanic("Attempt to dereference null $1_type");
+  }
+  $1 = ($1_ltype)*argp;
+%}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+%{ *($&1_ltype*)&$result = new $1_ltype($1); %}
+#else
+{
+  $&1_ltype $1ptr = ($&1_ltype)malloc(sizeof($1_ltype));
+  memmove($1ptr, &$1, sizeof($1_type));
+  *($&1_ltype*)&$result = $1ptr;
+}
+#endif
+
+%typemap(directorin) SWIGTYPE
+%{ $input = ($&1_ltype)&$1; %}
+
+%typemap(directorout) SWIGTYPE
+%{ $result = *($&1_ltype)$input; %}
+
+/* Exception handling */
+
+%typemap(throws) char *
+%{ _swig_gopanic($1); %}
+
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
+%{
+  (void)$1;
+  _swig_gopanic("C++ $1_type exception thrown");
+%}
+
+/* Typecheck typemaps.  The purpose of these is merely to issue a
+   warning for overloaded C++ functions * that cannot be overloaded in
+   Go as more than one C++ type maps to a single Go type.  */
+
+%typecheck(SWIG_TYPECHECK_BOOL) /* Go bool */
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR) /* Go byte */
+    char,
+    const char &,
+    unsigned char,
+    const unsigned char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8) /* Go int8 */
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16) /* Go int16 */
+    short,
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16) /* Go uint16 */
+    unsigned short,
+    const unsigned short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32) /* Go int */
+    int,
+    const int &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32) /* Go uint */
+    unsigned int,
+    const unsigned int &
+    ""
+
+#if SWIGGO_LONG_TYPE_SIZE == 32
+%typecheck(SWIG_TYPECHECK_INT32) /* Go int32 */
+    long,
+    const long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32) /* Go uint32 */
+    unsigned long,
+    const unsigned long &
+    ""
+#endif
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Go int64 */
+#if SWIGGO_LONG_TYPE_SIZE == 64
+    long, 
+    const long &, 
+#endif
+    long long,
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Go uint64 */
+#if SWIGGO_LONG_TYPE_SIZE == 64
+    unsigned long, 
+    const unsigned long &, 
+#endif
+    unsigned long long,
+    const unsigned long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT) /* Go float32 */
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE) /* Go float64 */
+    double,
+    const double &
+    ""
+
+%typecheck(SWIG_TYPECHECK_STRING) /* Go string */
+    char *,
+    char *&,
+    char[ANY],
+    char [],
+    signed char *,
+    signed char *&,
+    signed char[ANY],
+    signed char [],
+    unsigned char *,
+    unsigned char *&,
+    unsigned char[ANY],
+    unsigned char []
+    ""
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+    SWIGTYPE,
+    SWIGTYPE *,
+    SWIGTYPE &,
+    SWIGTYPE *const&,
+    SWIGTYPE [],
+    SWIGTYPE (CLASS::*)
+    ""
+
+/* Go keywords.  */
+%include <gokw.swg>
+
+%include <goruntime.swg>
diff --git a/share/swig/2.0.11/go/gokw.swg b/share/swig/2.0.11/go/gokw.swg
new file mode 100644
index 0000000..dd9f35a
--- /dev/null
+++ b/share/swig/2.0.11/go/gokw.swg
@@ -0,0 +1,33 @@
+/* Rename keywords.  */
+
+#define GOKW(x) %keywordwarn("'" `x` "' is a Go keyword, renaming to 'X"`x`"'",rename="X%s")  `x`
+#define GOBN(x) %builtinwarn("'" `x` "' conflicts with a built-in name in Go")  "::"`x`
+
+GOKW(break);
+GOKW(case);
+GOKW(chan);
+GOKW(const);
+GOKW(continue);
+GOKW(default);
+GOKW(defer);
+GOKW(else);
+GOKW(fallthrough);
+GOKW(for);
+GOKW(func);
+GOKW(go);
+GOKW(goto);
+GOKW(if);
+GOKW(import);
+GOKW(interface);
+GOKW(package);
+GOKW(range);
+GOKW(return);
+GOKW(select);
+GOKW(struct);
+GOKW(switch);
+GOKW(type);
+GOKW(var);
+
+GOBN(map);
+
+#undef GOKW
diff --git a/share/swig/2.0.11/go/goruntime.swg b/share/swig/2.0.11/go/goruntime.swg
new file mode 100644
index 0000000..4b7daf4
--- /dev/null
+++ b/share/swig/2.0.11/go/goruntime.swg
@@ -0,0 +1,218 @@
+/* ------------------------------------------------------------
+ * goruntime.swg
+ *
+ * Go runtime code for the various generated files.
+ * ------------------------------------------------------------ */
+
+%insert(runtime) %{
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+%}
+
+#if SWIGGO_INTGO_SIZE == 32
+%insert(runtime) %{
+typedef int intgo;
+typedef unsigned int uintgo;
+%}
+#elif SWIGGO_INTGO_SIZE == 64
+%insert(runtime) %{
+typedef long long intgo;
+typedef unsigned long long uintgo;
+%}
+#else
+%insert(runtime) %{
+typedef ptrdiff_t intgo;
+typedef size_t uintgo;
+%}
+#endif
+
+%insert(runtime) %{
+
+typedef struct { char *p; intgo n; } _gostring_;
+typedef struct { void* array; intgo len; intgo cap; } _goslice_;
+
+%}
+
+#ifndef SWIGGO_GCCGO
+/* Boilerplate for C/C++ code when using 6g/8g.  This code is compiled
+   with gcc.  */
+%insert(runtime) %{
+
+#define swiggo_size_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
+#define swiggo_size_assert(t, n) swiggo_size_assert_eq(sizeof(t), n, swiggo_sizeof_##t##_is_not_##n)
+
+swiggo_size_assert(char, 1)
+swiggo_size_assert(short, 2)
+swiggo_size_assert(int, 4)
+typedef long long swiggo_long_long;
+swiggo_size_assert(swiggo_long_long, 8)
+swiggo_size_assert(float, 4)
+swiggo_size_assert(double, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void crosscall2(void (*fn)(void *, int), void *, int);
+extern void _cgo_allocate(void *, int);
+extern void _cgo_panic(void *, int);
+#ifdef __cplusplus
+}
+#endif
+
+static void *_swig_goallocate(size_t len) {
+  struct {
+    size_t len;
+    void *ret;
+  } a;
+  a.len = len;
+  crosscall2(_cgo_allocate, &a, (int) sizeof a);
+  return a.ret;
+}
+
+static void _swig_gopanic(const char *p) {
+  struct {
+    const char *p;
+  } a;
+  a.p = p;
+  crosscall2(_cgo_panic, &a, (int) sizeof a);
+}
+
+%}
+
+/* Boilerplate for C code when using 6g/8g.  This code is compiled
+   with 6c/8c.  */
+%insert(gc_header) %{
+#include "runtime.h"
+#include "cgocall.h"
+
+#ifdef _64BIT
+#define SWIG_PARM_SIZE 8
+#else
+#define SWIG_PARM_SIZE 4
+#endif
+%}
+
+#else
+
+/* Boilerplate for C/C++ code when using gccgo.  */
+%insert(runtime) %{
+#define SWIGGO_GCCGO
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void *_cgo_allocate(size_t);
+extern void _cgo_panic(const char *);
+
+/* Implementations of SwigCgocall and friends for different versions
+   of gccgo.  The Go code will call these functions using C names with
+   a prefix of the module name.  The implementations here call the
+   routine in libgo.  The routines to call vary depending on the gccgo
+   version.  We assume that the version of gcc used to compile this
+   file is the same as the version of gccgo.  */
+
+#define SWIGCONCAT2(s1, s2) s1 ## s2
+#define SWIGCONCAT1(s1, s2) SWIGCONCAT2(s1, s2)
+#define SwigCgocall SWIGCONCAT1(SWIGMODULE, SwigCgocall)
+#define SwigCgocallDone SWIGCONCAT1(SWIGMODULE, SwigCgocallDone)
+#define SwigCgocallBack SWIGCONCAT1(SWIGMODULE, SwigCgocallBack)
+#define SwigCgocallBackDone SWIGCONCAT1(SWIGMODULE, SwigCgocallBackDone)
+
+#define SWIG_GCC_VERSION \
+  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC__PATH_LEVEL__)
+
+#if SWIG_GCC_VERSION < 40700
+#define SwigDoCgocall()
+#define SwigDoCgocallDone()
+#define SwigDoCgocallBack()
+#define SwigDoCgocallBackDone()
+#elif SWIG_GCC_VERSION == 40700
+void SwigDoCgocall(void) __asm__("libgo_syscall.syscall.Entersyscall");
+void SwigDoCgocallDone(void) __asm__("libgo_syscall.syscall.Exitsyscall");
+void SwigDoCgocallBack(void) __asm__("libgo_syscall.syscall.Exitsyscall");
+void SwigDoCgocallBackDone(void) __asm__("libgo_syscall.syscall.Entersyscall");
+#else
+void SwigDoCgocall(void) __asm__("syscall.Cgocall");
+void SwigDoCgocallDone(void) __asm__("syscall.CgocallDone");
+void SwigDoCgocallBack(void) __asm__("syscall.CgocallBack");
+void SwigDoCgocallBackDone(void) __asm__("syscall.CgocallBackDone");
+#endif
+
+void SwigCgocall() {
+  SwigDoCgocall();
+}
+
+void SwigCgocallDone() {
+  SwigDoCgocallDone();
+}
+
+void SwigCgocallBack() {
+  SwigDoCgocallBack();
+}
+
+void SwigCgocallBackDone() {
+  SwigDoCgocallBackDone();
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#define _swig_goallocate _cgo_allocate
+#define _swig_gopanic _cgo_panic
+
+%}
+
+#endif
+
+%insert(runtime) %{
+
+static _gostring_ _swig_makegostring(const char *p, size_t l) {
+  _gostring_ ret;
+  ret.p = (char*)_swig_goallocate(l + 1);
+  memcpy(ret.p, p, l);
+  ret.n = l;
+  return ret;
+}
+
+#define SWIG_contract_assert(expr, msg) \
+  if (!(expr)) { _swig_gopanic(msg); } else
+%}
+
+#ifndef SWIGGO_GCCGO
+
+%insert(go_header) %{
+
+import _ "runtime/cgo"
+import "unsafe"
+
+type _ unsafe.Pointer
+
+%}
+
+#else
+
+%insert(go_header) %{
+
+import "syscall"
+import "unsafe"
+
+type _ syscall.Sockaddr
+
+type _ unsafe.Pointer
+
+%}
+
+#endif
+
+/* Function pointers are translated by the code in go.cxx into
+   _swig_fnptr.  Member pointers are translated to _swig_memberptr.  */
+
+%insert(go_header) %{
+type _swig_fnptr *byte
+type _swig_memberptr *byte
+%}
diff --git a/share/swig/2.0.11/go/std_common.i b/share/swig/2.0.11/go/std_common.i
new file mode 100644
index 0000000..c010fac
--- /dev/null
+++ b/share/swig/2.0.11/go/std_common.i
@@ -0,0 +1,4 @@
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
diff --git a/share/swig/2.0.11/go/std_deque.i b/share/swig/2.0.11/go/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/2.0.11/go/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/2.0.11/go/std_except.i b/share/swig/2.0.11/go/std_except.i
new file mode 100644
index 0000000..789a335
--- /dev/null
+++ b/share/swig/2.0.11/go/std_except.i
@@ -0,0 +1,29 @@
+/* -----------------------------------------------------------------------------
+ * std_except.i
+ *
+ * Typemaps used by the STL wrappers that throw exceptions.
+ * These typemaps are used when methods are declared with an STL exception specification, such as
+ *   size_t at() const throw (std::out_of_range);
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <stdexcept>
+%}
+
+namespace std 
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws) std::bad_exception	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::domain_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::exception		%{_swig_gopanic($1.what());%}
+%typemap(throws) std::invalid_argument	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::length_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::logic_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::out_of_range	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::overflow_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::range_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::runtime_error	%{_swig_gopanic($1.what());%}
+%typemap(throws) std::underflow_error	%{_swig_gopanic($1.what());%}
diff --git a/share/swig/2.0.11/go/std_list.i b/share/swig/2.0.11/go/std_list.i
new file mode 100644
index 0000000..e026233
--- /dev/null
+++ b/share/swig/2.0.11/go/std_list.i
@@ -0,0 +1,40 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <list>
+#include <stdexcept>
+%}
+
+namespace std {
+
+  template<class T, class Alloc = allocator<T> >
+  class list {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef Alloc allocator_type;
+
+    list();
+    size_type size() const;
+    bool empty() const;
+    %rename(isEmpty) empty;
+    void clear();
+    void push_front(const value_type& x);
+    void pop_front();
+    void push_back(const value_type& x);
+    void pop_back();
+    void remove(value_type x);
+    void reverse();
+    void unique();
+    void sort();
+    void merge(list& x);
+  };
+
+}
diff --git a/share/swig/2.0.11/go/std_map.i b/share/swig/2.0.11/go/std_map.i
new file mode 100644
index 0000000..84b0c74
--- /dev/null
+++ b/share/swig/2.0.11/go/std_map.i
@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+    template<class K, class T> class map {
+        // add typemaps here
+      public:
+        typedef size_t size_type;
+        typedef ptrdiff_t difference_type;
+        typedef K key_type;
+        typedef T mapped_type;
+        map();
+        map(const map<K,T> &);
+        
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            const T& get(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    return i->second;
+                else
+                    throw std::out_of_range("key not found");
+            }
+            void set(const K& key, const T& x) {
+                (*self)[key] = x;
+            }
+            void del(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    self->erase(i);
+                else
+                    throw std::out_of_range("key not found");
+            }
+            bool has_key(const K& key) {
+                std::map<K,T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+        }
+    };
+}
diff --git a/share/swig/2.0.11/go/std_pair.i b/share/swig/2.0.11/go/std_pair.i
new file mode 100644
index 0000000..fe45ee6
--- /dev/null
+++ b/share/swig/2.0.11/go/std_pair.i
@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// ------------------------------------------------------------------------
+// std::pair
+// ------------------------------------------------------------------------
+
+%{
+#include <utility>
+%}
+
+namespace std {
+
+  template<class T, class U> struct pair {
+
+    pair();
+    pair(T first, U second);
+    pair(const pair& p);
+
+    template <class U1, class U2> pair(const pair<U1, U2> &p);
+
+    T first;
+    U second;
+  };
+
+  // add specializations here
+
+}
diff --git a/share/swig/2.0.11/go/std_string.i b/share/swig/2.0.11/go/std_string.i
new file mode 100644
index 0000000..9922fbe
--- /dev/null
+++ b/share/swig/2.0.11/go/std_string.i
@@ -0,0 +1,55 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * Typemaps for std::string and const std::string&
+ * These are mapped to a Go string and are passed around by value.
+ *
+ * To use non-const std::string references use the following %apply.  Note 
+ * that they are passed by value.
+ * %apply const std::string & {std::string &};
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+%naturalvar string;
+
+class string;
+
+%typemap(gotype) string, const string & "string"
+
+%typemap(in) string
+%{ $1.assign($input.p, $input.n); %}
+
+%typemap(directorout) string
+%{ $result.assign($input.p, $input.n); %}
+
+%typemap(out) string
+%{ $result = _swig_makegostring($1.data(), $1.length()); %}
+
+%typemap(directorin) string
+%{ $input = _swig_makegostring($1.data(), $1.length()); %}
+
+%typemap(in) const string &
+%{
+  $*1_ltype $1_str($input.p, $input.n);
+  $1 = &$1_str;
+%}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{
+  static $*1_ltype $1_str;
+  $1_str.assign($input.p, $input.n);
+  $result = &$1_str;
+%}
+
+%typemap(out) const string &
+%{ $result = _swig_makegostring((*$1).data(), (*$1).length()); %}
+
+%typemap(directorin) const string &
+%{ $input = _swig_makegostring($1.data(), $1.length()); %}
+
+}
diff --git a/share/swig/2.0.11/go/std_vector.i b/share/swig/2.0.11/go/std_vector.i
new file mode 100644
index 0000000..f4ce843
--- /dev/null
+++ b/share/swig/2.0.11/go/std_vector.i
@@ -0,0 +1,78 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <vector>
+#include <stdexcept>
+%}
+
+namespace std {
+    
+    template<class T> class vector {
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+        vector();
+        vector(size_type n);
+        size_type size() const;
+        size_type capacity() const;
+        void reserve(size_type n);
+        %rename(isEmpty) empty;
+        bool empty() const;
+        void clear();
+        %rename(add) push_back;
+        void push_back(const value_type& x);
+        %extend {
+            const_reference get(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    return (*self)[i];
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+            void set(int i, const value_type& val) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = val;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+
+    // bool specialization
+    template<> class vector<bool> {
+      public:
+        typedef size_t size_type;
+        typedef bool value_type;
+        typedef bool const_reference;
+        vector();
+        vector(size_type n);
+        size_type size() const;
+        size_type capacity() const;
+        void reserve(size_type n);
+        %rename(isEmpty) empty;
+        bool empty() const;
+        void clear();
+        %rename(add) push_back;
+        void push_back(const value_type& x);
+        %extend {
+            const_reference get(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    return (*self)[i];
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+            void set(int i, const value_type& val) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = val;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+}
diff --git a/share/swig/2.0.11/go/stl.i b/share/swig/2.0.11/go/stl.i
new file mode 100644
index 0000000..38aba67
--- /dev/null
+++ b/share/swig/2.0.11/go/stl.i
@@ -0,0 +1,9 @@
+/* -----------------------------------------------------------------------------
+ * stl.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
diff --git a/share/swig/2.0.11/go/typemaps.i b/share/swig/2.0.11/go/typemaps.i
new file mode 100644
index 0000000..c339fb3
--- /dev/null
+++ b/share/swig/2.0.11/go/typemaps.i
@@ -0,0 +1,292 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer and reference handling typemap library
+ *
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers and C++ references.
+ * ----------------------------------------------------------------------------- */
+
+/*
+INPUT typemaps
+--------------
+
+These typemaps remap a C pointer or C++ reference to be an "INPUT" value which is
+passed by value instead of reference.
+
+The following typemaps can be applied to turn a pointer or reference into a simple
+input value.  That is, instead of passing a pointer or reference to an object,
+you would use a real value instead.
+
+        bool               *INPUT, bool               &INPUT
+        signed char        *INPUT, signed char        &INPUT
+        unsigned char      *INPUT, unsigned char      &INPUT
+        short              *INPUT, short              &INPUT
+        unsigned short     *INPUT, unsigned short     &INPUT
+        int                *INPUT, int                &INPUT
+        unsigned int       *INPUT, unsigned int       &INPUT
+        long               *INPUT, long               &INPUT
+        unsigned long      *INPUT, unsigned long      &INPUT
+        long long          *INPUT, long long          &INPUT
+        unsigned long long *INPUT, unsigned long long &INPUT
+        float              *INPUT, float              &INPUT
+        double             *INPUT, double             &INPUT
+         
+To use these, suppose you had a C function like this :
+
+        double fadd(double *a, double *b) {
+               return *a+*b;
+        }
+
+You could wrap it with SWIG as follows :
+        
+        %include <typemaps.i>
+        double fadd(double *INPUT, double *INPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INPUT { double *a, double *b };
+        double fadd(double *a, double *b);
+
+In Go you could then use it like this:
+        answer := modulename.Fadd(10.0, 20.0)
+
+There are no char *INPUT typemaps, however you can apply the signed
+char * typemaps instead:
+        %include <typemaps.i>
+        %apply signed char *INPUT {char *input};
+        void f(char *input);
+*/
+
+%define INPUT_TYPEMAP(TYPE, GOTYPE)
+%typemap(gotype) TYPE *INPUT, TYPE &INPUT "GOTYPE"
+
+ %typemap(in) TYPE *INPUT, TYPE &INPUT
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(out) TYPE *INPUT, TYPE &INPUT ""
+
+%typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
+
+%typemap(argout) TYPE *INPUT, TYPE &INPUT ""
+
+// %typemap(typecheck) TYPE *INPUT = TYPE;
+// %typemap(typecheck) TYPE &INPUT = TYPE;
+%enddef
+
+INPUT_TYPEMAP(bool, bool);
+INPUT_TYPEMAP(signed char, int8);
+INPUT_TYPEMAP(char, byte);
+INPUT_TYPEMAP(unsigned char, byte);
+INPUT_TYPEMAP(short, int16);
+INPUT_TYPEMAP(unsigned short, uint16);
+INPUT_TYPEMAP(int, int);
+INPUT_TYPEMAP(unsigned int, uint);
+INPUT_TYPEMAP(long, int64);
+INPUT_TYPEMAP(unsigned long, uint64);
+INPUT_TYPEMAP(long long, int64);
+INPUT_TYPEMAP(unsigned long long, uint64);
+INPUT_TYPEMAP(float, float32);
+INPUT_TYPEMAP(double, float64);
+
+#undef INPUT_TYPEMAP
+
+// OUTPUT typemaps.   These typemaps are used for parameters that
+// are output only.   An array replaces the c pointer or reference parameter. 
+// The output value is returned in this array passed in. 
+
+/*
+OUTPUT typemaps
+---------------
+
+The following typemaps can be applied to turn a pointer or reference
+into an "output" value.  When calling a function, no input value would
+be given for a parameter, but an output value would be returned.  This
+works by a Go slice being passed as a parameter where a c pointer or
+reference is required.  As with any Go function, the array is passed
+by reference so that any modifications to the array will be picked up
+in the calling function.  Note that the array passed in MUST have at
+least one element, but as the c function does not require any input,
+the value can be set to anything.
+
+        bool               *OUTPUT, bool               &OUTPUT
+        signed char        *OUTPUT, signed char        &OUTPUT
+        unsigned char      *OUTPUT, unsigned char      &OUTPUT
+        short              *OUTPUT, short              &OUTPUT
+        unsigned short     *OUTPUT, unsigned short     &OUTPUT
+        int                *OUTPUT, int                &OUTPUT
+        unsigned int       *OUTPUT, unsigned int       &OUTPUT
+        long               *OUTPUT, long               &OUTPUT
+        unsigned long      *OUTPUT, unsigned long      &OUTPUT
+        long long          *OUTPUT, long long          &OUTPUT
+        unsigned long long *OUTPUT, unsigned long long &OUTPUT
+        float              *OUTPUT, float              &OUTPUT
+        double             *OUTPUT, double             &OUTPUT
+         
+For example, suppose you were trying to wrap the modf() function in the
+C math library which splits x into integral and fractional parts (and
+returns the integer part in one of its parameters):
+
+        double modf(double x, double *ip);
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double modf(double x, double *OUTPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *OUTPUT { double *ip };
+        double modf(double x, double *ip);
+
+The Go output of the function would be the function return value and the 
+value in the single element array. In Go you would use it like this:
+
+    ptr := []float64{0.0}
+    fraction := modulename.Modf(5.0,ptr)
+
+There are no char *OUTPUT typemaps, however you can apply the signed
+char * typemaps instead:
+        %include <typemaps.i>
+        %apply signed char *OUTPUT {char *output};
+        void f(char *output);
+*/
+
+%define OUTPUT_TYPEMAP(TYPE, GOTYPE)
+%typemap(gotype) TYPE *OUTPUT, TYPE &OUTPUT %{[]GOTYPE%}
+
+%typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
+{
+  if ($input.len == 0) {
+    _swig_gopanic("array must contain at least 1 element");
+  }
+  $1 = &temp;
+}
+
+%typemap(out) TYPE *OUTPUT, TYPE &OUTPUT ""
+
+%typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
+
+%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT
+{
+  TYPE* a = (TYPE *) $input.array;
+  a[0] = temp$argnum;
+}
+
+%enddef
+
+OUTPUT_TYPEMAP(bool, bool);
+OUTPUT_TYPEMAP(signed char, int8);
+OUTPUT_TYPEMAP(char, byte);
+OUTPUT_TYPEMAP(unsigned char, byte);
+OUTPUT_TYPEMAP(short, int16);
+OUTPUT_TYPEMAP(unsigned short, uint16);
+OUTPUT_TYPEMAP(int, int);
+OUTPUT_TYPEMAP(unsigned int, uint);
+OUTPUT_TYPEMAP(long, int64);
+OUTPUT_TYPEMAP(unsigned long, uint64);
+OUTPUT_TYPEMAP(long long, int64);
+OUTPUT_TYPEMAP(unsigned long long, uint64);
+OUTPUT_TYPEMAP(float, float32);
+OUTPUT_TYPEMAP(double, float64);
+
+#undef OUTPUT_TYPEMAP
+
+/*
+INOUT typemaps
+--------------
+
+Mappings for a parameter that is both an input and an output parameter
+
+The following typemaps can be applied to make a function parameter both
+an input and output value.  This combines the behavior of both the
+"INPUT" and "OUTPUT" typemaps described earlier.  Output values are
+returned as an element in a Go slice.
+
+        bool               *INOUT, bool               &INOUT
+        signed char        *INOUT, signed char        &INOUT
+        unsigned char      *INOUT, unsigned char      &INOUT
+        short              *INOUT, short              &INOUT
+        unsigned short     *INOUT, unsigned short     &INOUT
+        int                *INOUT, int                &INOUT
+        unsigned int       *INOUT, unsigned int       &INOUT
+        long               *INOUT, long               &INOUT
+        unsigned long      *INOUT, unsigned long      &INOUT
+        long long          *INOUT, long long          &INOUT
+        unsigned long long *INOUT, unsigned long long &INOUT
+        float              *INOUT, float              &INOUT
+        double             *INOUT, double             &INOUT
+         
+For example, suppose you were trying to wrap the following function :
+
+        void neg(double *x) {
+             *x = -(*x);
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        void neg(double *INOUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *x };
+        void neg(double *x);
+
+This works similarly to C in that the mapping directly modifies the
+input value - the input must be an array with a minimum of one element. 
+The element in the array is the input and the output is the element in 
+the array.
+
+       x := []float64{5.0}
+       Neg(x);
+
+The implementation of the OUTPUT and INOUT typemaps is different to
+other languages in that other languages will return the output value
+as part of the function return value. This difference is due to Go
+being a typed language.
+
+There are no char *INOUT typemaps, however you can apply the signed
+char * typemaps instead:
+        %include <typemaps.i>
+        %apply signed char *INOUT {char *inout};
+        void f(char *inout);
+*/
+
+%define INOUT_TYPEMAP(TYPE, GOTYPE)
+%typemap(gotype) TYPE *INOUT, TYPE &INOUT %{[]GOTYPE%}
+
+%typemap(in) TYPE *INOUT, TYPE &INOUT {
+  if ($input.len == 0) {
+    _swig_gopanic("array must contain at least 1 element");
+  }
+  $1 = ($1_ltype) $input.array;
+}
+
+%typemap(out) TYPE *INOUT, TYPE &INOUT ""
+
+%typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
+
+%typemap(argout) TYPE *INOUT, TYPE &INOUT ""
+
+%enddef
+
+INOUT_TYPEMAP(bool, bool);
+INOUT_TYPEMAP(signed char, int8);
+INOUT_TYPEMAP(char, byte);
+INOUT_TYPEMAP(unsigned char, byte);
+INOUT_TYPEMAP(short, int16);
+INOUT_TYPEMAP(unsigned short, uint16);
+INOUT_TYPEMAP(int, int);
+INOUT_TYPEMAP(unsigned int, uint);
+INOUT_TYP